]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:


026c59240c86d9c291990a5e9c3e44ca317ee2a2
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxMetafile swig_types[2]
1344 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1345 #define SWIGTYPE_p_wxLog swig_types[4]
1346 #define SWIGTYPE_p_wxMenu swig_types[5]
1347 #define SWIGTYPE_p_wxEvent swig_types[6]
1348 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1349 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1350 #define SWIGTYPE_p_wxDisplay swig_types[9]
1351 #define SWIGTYPE_p_wxFileType swig_types[10]
1352 #define SWIGTYPE_p_wxLogGui swig_types[11]
1353 #define SWIGTYPE_p_wxFont swig_types[12]
1354 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1355 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1356 #define SWIGTYPE_p_wxCaret swig_types[15]
1357 #define SWIGTYPE_ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_std__ptrdiff_t swig_types[17]
1359 #define SWIGTYPE_p_int swig_types[18]
1360 #define SWIGTYPE_p_wxSize swig_types[19]
1361 #define SWIGTYPE_p_wxClipboard swig_types[20]
1362 #define SWIGTYPE_p_wxStopWatch swig_types[21]
1363 #define SWIGTYPE_p_wxDC swig_types[22]
1364 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
1365 #define SWIGTYPE_p_wxIcon swig_types[24]
1366 #define SWIGTYPE_p_wxLogStderr swig_types[25]
1367 #define SWIGTYPE_p_wxLogTextCtrl swig_types[26]
1368 #define SWIGTYPE_p_wxTextCtrl swig_types[27]
1369 #define SWIGTYPE_p_wxBusyCursor swig_types[28]
1370 #define SWIGTYPE_p_wxBitmapDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxTextDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxPyTextDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxFileDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxURLDataObject swig_types[36]
1378 #define SWIGTYPE_p_wxMetafileDataObject swig_types[37]
1379 #define SWIGTYPE_p_wxSound swig_types[38]
1380 #define SWIGTYPE_p_wxTimerRunner swig_types[39]
1381 #define SWIGTYPE_p_wxLogWindow swig_types[40]
1382 #define SWIGTYPE_p_wxTimeSpan swig_types[41]
1383 #define SWIGTYPE_p_wxArrayString swig_types[42]
1384 #define SWIGTYPE_p_wxWindowDisabler swig_types[43]
1385 #define SWIGTYPE_p_form_ops_t swig_types[44]
1386 #define SWIGTYPE_p_wxToolTip swig_types[45]
1387 #define SWIGTYPE_p_wxDataObjectComposite swig_types[46]
1388 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1389 #define SWIGTYPE_p_wxFileConfig swig_types[48]
1390 #define SWIGTYPE_p_wxVideoMode swig_types[49]
1391 #define SWIGTYPE_p_wxDataObjectSimple swig_types[50]
1392 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[51]
1393 #define SWIGTYPE_p_wxDuplexMode swig_types[52]
1394 #define SWIGTYPE_p_wxEvtHandler swig_types[53]
1395 #define SWIGTYPE_p_wxRect swig_types[54]
1396 #define SWIGTYPE_p_char swig_types[55]
1397 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[56]
1398 #define SWIGTYPE_p_wxStandardPaths swig_types[57]
1399 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
1400 #define SWIGTYPE_p_wxFrame swig_types[59]
1401 #define SWIGTYPE_p_wxTimer swig_types[60]
1402 #define SWIGTYPE_p_wxPaperSize swig_types[61]
1403 #define SWIGTYPE_p_wxMimeTypesManager swig_types[62]
1404 #define SWIGTYPE_p_wxPyArtProvider swig_types[63]
1405 #define SWIGTYPE_p_wxPyTipProvider swig_types[64]
1406 #define SWIGTYPE_p_wxTipProvider swig_types[65]
1407 #define SWIGTYPE_p_wxJoystick swig_types[66]
1408 #define SWIGTYPE_p_wxSystemOptions swig_types[67]
1409 #define SWIGTYPE_p_wxPoint swig_types[68]
1410 #define SWIGTYPE_p_wxJoystickEvent swig_types[69]
1411 #define SWIGTYPE_p_wxCursor swig_types[70]
1412 #define SWIGTYPE_p_wxObject swig_types[71]
1413 #define SWIGTYPE_p_wxOutputStream swig_types[72]
1414 #define SWIGTYPE_p_wxDateTime swig_types[73]
1415 #define SWIGTYPE_p_wxPyDropSource swig_types[74]
1416 #define SWIGTYPE_p_unsigned_long swig_types[75]
1417 #define SWIGTYPE_p_wxKillError swig_types[76]
1418 #define SWIGTYPE_p_wxWindow swig_types[77]
1419 #define SWIGTYPE_p_wxString swig_types[78]
1420 #define SWIGTYPE_p_wxPyProcess swig_types[79]
1421 #define SWIGTYPE_p_wxBitmap swig_types[80]
1422 #define SWIGTYPE_p_wxConfig swig_types[81]
1423 #define SWIGTYPE_unsigned_int swig_types[82]
1424 #define SWIGTYPE_p_unsigned_int swig_types[83]
1425 #define SWIGTYPE_p_unsigned_char swig_types[84]
1426 #define SWIGTYPE_p_wxChar swig_types[85]
1427 #define SWIGTYPE_p_wxBusyInfo swig_types[86]
1428 #define SWIGTYPE_p_wxPyDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[88]
1430 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[89]
1431 #define SWIGTYPE_p_wxProcessEvent swig_types[90]
1432 #define SWIGTYPE_p_wxPyLog swig_types[91]
1433 #define SWIGTYPE_p_wxLogNull swig_types[92]
1434 #define SWIGTYPE_p_wxColour swig_types[93]
1435 #define SWIGTYPE_p_wxPyTimer swig_types[94]
1436 #define SWIGTYPE_p_wxConfigPathChanger swig_types[95]
1437 #define SWIGTYPE_p_wxDateSpan swig_types[96]
1438 static swig_type_info *swig_types[98];
1439
1440 /* -------- TYPES TABLE (END) -------- */
1441
1442
1443 /*-----------------------------------------------
1444 @(target):= _misc_.so
1445 ------------------------------------------------*/
1446 #define SWIG_init init_misc_
1447
1448 #define SWIG_name "_misc_"
1449
1450 #include "wx/wxPython/wxPython.h"
1451 #include "wx/wxPython/pyclasses.h"
1452 #include "wx/wxPython/pyistream.h"
1453
1454 static const wxString wxPyEmptyString(wxEmptyString);
1455
1456
1457
1458 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1459 #define SWIG_From_int PyInt_FromLong
1460 /*@@*/
1461
1462
1463 #include <limits.h>
1464
1465
1466 SWIGINTERN int
1467 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1468 const char *errmsg)
1469 {
1470 if (value < min_value) {
1471 if (errmsg) {
1472 PyErr_Format(PyExc_OverflowError,
1473 "value %ld is less than '%s' minimum %ld",
1474 value, errmsg, min_value);
1475 }
1476 return 0;
1477 } else if (value > max_value) {
1478 if (errmsg) {
1479 PyErr_Format(PyExc_OverflowError,
1480 "value %ld is greater than '%s' maximum %ld",
1481 value, errmsg, max_value);
1482 }
1483 return 0;
1484 }
1485 return 1;
1486 }
1487
1488
1489 SWIGINTERN int
1490 SWIG_AsVal_long(PyObject* obj, long* val)
1491 {
1492 if (PyNumber_Check(obj)) {
1493 if (val) *val = PyInt_AsLong(obj);
1494 return 1;
1495 }
1496 else {
1497 SWIG_type_error("number", obj);
1498 }
1499 return 0;
1500 }
1501
1502
1503 #if INT_MAX != LONG_MAX
1504 SWIGINTERN int
1505 SWIG_AsVal_int(PyObject *obj, int *val)
1506 {
1507 const char* errmsg = val ? "int" : (char*)0;
1508 long v;
1509 if (SWIG_AsVal_long(obj, &v)) {
1510 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1511 if (val) *val = (int)(v);
1512 return 1;
1513 } else {
1514 return 0;
1515 }
1516 } else {
1517 PyErr_Clear();
1518 }
1519 if (val) {
1520 SWIG_type_error(errmsg, obj);
1521 }
1522 return 0;
1523 }
1524 #else
1525 SWIGINTERNSHORT int
1526 SWIG_AsVal_int(PyObject *obj, int *val)
1527 {
1528 return SWIG_AsVal_long(obj,(long*)val);
1529 }
1530 #endif
1531
1532
1533 SWIGINTERNSHORT int
1534 SWIG_As_int(PyObject* obj)
1535 {
1536 int v;
1537 if (!SWIG_AsVal_int(obj, &v)) {
1538 /*
1539 this is needed to make valgrind/purify happier.
1540 */
1541 memset((void*)&v, 0, sizeof(int));
1542 }
1543 return v;
1544 }
1545
1546
1547 SWIGINTERNSHORT int
1548 SWIG_Check_int(PyObject* obj)
1549 {
1550 return SWIG_AsVal_int(obj, (int*)0);
1551 }
1552
1553 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1554
1555 #include <wx/stockitem.h>
1556
1557 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1558 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1559 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1560
1561 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1562 #define SWIG_From_long PyInt_FromLong
1563 /*@@*/
1564
1565
1566 SWIGINTERNSHORT long
1567 SWIG_As_long(PyObject* obj)
1568 {
1569 long v;
1570 if (!SWIG_AsVal_long(obj, &v)) {
1571 /*
1572 this is needed to make valgrind/purify happier.
1573 */
1574 memset((void*)&v, 0, sizeof(long));
1575 }
1576 return v;
1577 }
1578
1579
1580 SWIGINTERNSHORT int
1581 SWIG_Check_long(PyObject* obj)
1582 {
1583 return SWIG_AsVal_long(obj, (long*)0);
1584 }
1585
1586
1587 SWIGINTERN int
1588 SWIG_AsVal_bool(PyObject *obj, bool *val)
1589 {
1590 if (obj == Py_True) {
1591 if (val) *val = true;
1592 return 1;
1593 }
1594 if (obj == Py_False) {
1595 if (val) *val = false;
1596 return 1;
1597 }
1598 int res = 0;
1599 if (SWIG_AsVal_int(obj, &res)) {
1600 if (val) *val = res ? true : false;
1601 return 1;
1602 } else {
1603 PyErr_Clear();
1604 }
1605 if (val) {
1606 SWIG_type_error("bool", obj);
1607 }
1608 return 0;
1609 }
1610
1611
1612 SWIGINTERNSHORT bool
1613 SWIG_As_bool(PyObject* obj)
1614 {
1615 bool v;
1616 if (!SWIG_AsVal_bool(obj, &v)) {
1617 /*
1618 this is needed to make valgrind/purify happier.
1619 */
1620 memset((void*)&v, 0, sizeof(bool));
1621 }
1622 return v;
1623 }
1624
1625
1626 SWIGINTERNSHORT int
1627 SWIG_Check_bool(PyObject* obj)
1628 {
1629 return SWIG_AsVal_bool(obj, (bool*)0);
1630 }
1631
1632
1633 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1634 PyObject* o2;
1635 PyObject* o3;
1636
1637 if (!target) {
1638 target = o;
1639 } else if (target == Py_None) {
1640 Py_DECREF(Py_None);
1641 target = o;
1642 } else {
1643 if (!PyTuple_Check(target)) {
1644 o2 = target;
1645 target = PyTuple_New(1);
1646 PyTuple_SetItem(target, 0, o2);
1647 }
1648 o3 = PyTuple_New(1);
1649 PyTuple_SetItem(o3, 0, o);
1650
1651 o2 = target;
1652 target = PySequence_Concat(o2, o3);
1653 Py_DECREF(o2);
1654 Py_DECREF(o3);
1655 }
1656 return target;
1657 }
1658
1659
1660
1661 SWIGINTERN int
1662 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1663 {
1664 long v = 0;
1665 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1666 SWIG_type_error("unsigned number", obj);
1667 }
1668 else if (val)
1669 *val = (unsigned long)v;
1670 return 1;
1671 }
1672
1673
1674 SWIGINTERNSHORT unsigned long
1675 SWIG_As_unsigned_SS_long(PyObject* obj)
1676 {
1677 unsigned long v;
1678 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1679 /*
1680 this is needed to make valgrind/purify happier.
1681 */
1682 memset((void*)&v, 0, sizeof(unsigned long));
1683 }
1684 return v;
1685 }
1686
1687
1688 SWIGINTERNSHORT int
1689 SWIG_Check_unsigned_SS_long(PyObject* obj)
1690 {
1691 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1692 }
1693
1694
1695 SWIGINTERNSHORT PyObject*
1696 SWIG_From_unsigned_SS_long(unsigned long value)
1697 {
1698 return (value > LONG_MAX) ?
1699 PyLong_FromUnsignedLong(value)
1700 : PyInt_FromLong((long)(value));
1701 }
1702
1703
1704 bool wxThread_IsMain() {
1705 #ifdef WXP_WITH_THREAD
1706 return wxThread::IsMain();
1707 #else
1708 return true;
1709 #endif
1710 }
1711
1712 static void wxCaret_Destroy(wxCaret *self){
1713 delete self;
1714 }
1715
1716 #include <wx/snglinst.h>
1717
1718
1719 #ifdef __WXMSW__
1720 #include <wx/msw/private.h>
1721 #include <wx/dynload.h>
1722 #endif
1723
1724
1725
1726 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1727 #if 0
1728 , int method
1729 #endif
1730 )
1731 {
1732 #ifdef __WXMSW__
1733 #if 0
1734 switch (method)
1735 {
1736 case 1:
1737 // This one only partially works. Appears to be an undocumented
1738 // "standard" convention that not all widgets adhear to. For
1739 // example, for some widgets backgrounds or non-client areas may
1740 // not be painted.
1741 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1742 break;
1743
1744 case 2:
1745 #endif
1746 // This one works much better, nearly all widgets and their
1747 // children are captured correctly[**]. Prior to the big
1748 // background erase changes that Vadim did in 2004-2005 this
1749 // method failed badly on XP with Themes activated, most native
1750 // widgets draw only partially, if at all. Without themes it
1751 // worked just like on Win2k. After those changes this method
1752 // works very well.
1753 //
1754 // ** For example the radio buttons in a wxRadioBox are not its
1755 // children by default, but you can capture it via the panel
1756 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1757 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1758 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1759 PRF_ERASEBKGND | PRF_OWNED );
1760 return true;
1761 #if 0
1762 break;
1763
1764 case 3:
1765 // This one is only defined in the latest SDK and is only
1766 // available on XP. MSDN says it is similar to sending WM_PRINT
1767 // so I expect that it will work similar to the above. Since it
1768 // is avaialble only on XP, it can't be compiled like this and
1769 // will have to be loaded dynamically.
1770 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1771
1772 // fall through
1773
1774 case 4:
1775 // Use PrintWindow if available, or fallback to WM_PRINT
1776 // otherwise. Unfortunately using PrintWindow is even worse than
1777 // WM_PRINT. For most native widgets nothing is drawn to the dc
1778 // at all, with or without Themes.
1779 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1780 static bool s_triedToLoad = false;
1781 static PrintWindow_t pfnPrintWindow = NULL;
1782 if ( !s_triedToLoad )
1783 {
1784
1785 s_triedToLoad = true;
1786 wxDynamicLibrary dllUser32(_T("user32.dll"));
1787 if ( dllUser32.IsLoaded() )
1788 {
1789 wxLogNull nolog; // Don't report errors here
1790 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1791 }
1792 }
1793 if (pfnPrintWindow)
1794 {
1795 //printf("Using PrintWindow\n");
1796 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1797 }
1798 else
1799 {
1800 //printf("Using WM_PRINT\n");
1801 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1802 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1803 PRF_ERASEBKGND | PRF_OWNED );
1804 }
1805 }
1806 #endif // 0
1807 #else
1808 return false;
1809 #endif // __WXMSW__
1810 }
1811
1812
1813
1814 #include <wx/tipdlg.h>
1815
1816
1817 class wxPyTipProvider : public wxTipProvider {
1818 public:
1819 wxPyTipProvider(size_t currentTip)
1820 : wxTipProvider(currentTip) {}
1821
1822 DEC_PYCALLBACK_STRING__pure(GetTip);
1823 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1824 PYPRIVATE;
1825 };
1826
1827 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1828 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1829
1830
1831 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1832
1833 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1834
1835 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1836 : wxTimer(owner, id)
1837 {
1838 if (owner == NULL) SetOwner(this);
1839 }
1840
1841
1842 void wxPyTimer::Notify() {
1843 bool found;
1844 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1845 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1846 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1847 wxPyEndBlockThreads(blocked);
1848 if (! found)
1849 wxTimer::Notify();
1850 }
1851 void wxPyTimer::base_Notify() {
1852 wxTimer::Notify();
1853 }
1854
1855
1856
1857 SWIGINTERN PyObject *
1858 SWIG_FromCharPtr(const char* cptr)
1859 {
1860 if (cptr) {
1861 size_t size = strlen(cptr);
1862 if (size > INT_MAX) {
1863 return SWIG_NewPointerObj((char*)(cptr),
1864 SWIG_TypeQuery("char *"), 0);
1865 } else {
1866 if (size != 0) {
1867 return PyString_FromStringAndSize(cptr, size);
1868 } else {
1869 return PyString_FromString(cptr);
1870 }
1871 }
1872 }
1873 Py_INCREF(Py_None);
1874 return Py_None;
1875 }
1876
1877
1878 SWIGINTERNSHORT int
1879 SWIG_CheckUnsignedLongInRange(unsigned long value,
1880 unsigned long max_value,
1881 const char *errmsg)
1882 {
1883 if (value > max_value) {
1884 if (errmsg) {
1885 PyErr_Format(PyExc_OverflowError,
1886 "value %lu is greater than '%s' minimum %lu",
1887 value, errmsg, max_value);
1888 }
1889 return 0;
1890 }
1891 return 1;
1892 }
1893
1894
1895 #if UINT_MAX != ULONG_MAX
1896 SWIGINTERN int
1897 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1898 {
1899 const char* errmsg = val ? "unsigned int" : (char*)0;
1900 unsigned long v;
1901 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1902 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1903 if (val) *val = (unsigned int)(v);
1904 return 1;
1905 }
1906 } else {
1907 PyErr_Clear();
1908 }
1909 if (val) {
1910 SWIG_type_error(errmsg, obj);
1911 }
1912 return 0;
1913 }
1914 #else
1915 SWIGINTERNSHORT unsigned int
1916 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1917 {
1918 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1919 }
1920 #endif
1921
1922
1923 SWIGINTERNSHORT unsigned int
1924 SWIG_As_unsigned_SS_int(PyObject* obj)
1925 {
1926 unsigned int v;
1927 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1928 /*
1929 this is needed to make valgrind/purify happier.
1930 */
1931 memset((void*)&v, 0, sizeof(unsigned int));
1932 }
1933 return v;
1934 }
1935
1936
1937 SWIGINTERNSHORT int
1938 SWIG_Check_unsigned_SS_int(PyObject* obj)
1939 {
1940 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1941 }
1942
1943 static wxString Log_TimeStamp(){
1944 wxString msg;
1945 wxLog::TimeStamp(&msg);
1946 return msg;
1947 }
1948 static void wxLog_Destroy(wxLog *self){ delete self; }
1949 // Make somce wrappers that double any % signs so they are 'escaped'
1950 void wxPyLogFatalError(const wxString& msg)
1951 {
1952 wxString m(msg);
1953 m.Replace(wxT("%"), wxT("%%"));
1954 wxLogFatalError(m);
1955 }
1956
1957 void wxPyLogError(const wxString& msg)
1958 {
1959 wxString m(msg);
1960 m.Replace(wxT("%"), wxT("%%"));
1961 wxLogError(m);
1962 }
1963
1964 void wxPyLogWarning(const wxString& msg)
1965 {
1966 wxString m(msg);
1967 m.Replace(wxT("%"), wxT("%%"));
1968 wxLogWarning(m);
1969 }
1970
1971 void wxPyLogMessage(const wxString& msg)
1972 {
1973 wxString m(msg);
1974 m.Replace(wxT("%"), wxT("%%"));
1975 wxLogMessage(m);
1976 }
1977
1978 void wxPyLogInfo(const wxString& msg)
1979 {
1980 wxString m(msg);
1981 m.Replace(wxT("%"), wxT("%%"));
1982 wxLogInfo(m);
1983 }
1984
1985 void wxPyLogDebug(const wxString& msg)
1986 {
1987 wxString m(msg);
1988 m.Replace(wxT("%"), wxT("%%"));
1989 wxLogDebug(m);
1990 }
1991
1992 void wxPyLogVerbose(const wxString& msg)
1993 {
1994 wxString m(msg);
1995 m.Replace(wxT("%"), wxT("%%"));
1996 wxLogVerbose(m);
1997 }
1998
1999 void wxPyLogStatus(const wxString& msg)
2000 {
2001 wxString m(msg);
2002 m.Replace(wxT("%"), wxT("%%"));
2003 wxLogStatus(m);
2004 }
2005
2006 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2007 {
2008 wxString m(msg);
2009 m.Replace(wxT("%"), wxT("%%"));
2010 wxLogStatus(pFrame, m);
2011 }
2012
2013 void wxPyLogSysError(const wxString& msg)
2014 {
2015 wxString m(msg);
2016 m.Replace(wxT("%"), wxT("%%"));
2017 wxLogSysError(m);
2018 }
2019
2020 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2021 {
2022 wxString m(msg);
2023 m.Replace(wxT("%"), wxT("%%"));
2024 wxLogGeneric(level, m);
2025 }
2026
2027 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2028 {
2029 wxString m(msg);
2030 m.Replace(wxT("%"), wxT("%%"));
2031 wxLogTrace(mask, m);
2032 }
2033
2034 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2035 {
2036 wxString m(msg);
2037 m.Replace(wxT("%"), wxT("%%"));
2038 wxLogTrace(mask, m);
2039 }
2040
2041
2042
2043 // A wxLog class that can be derived from in wxPython
2044 class wxPyLog : public wxLog {
2045 public:
2046 wxPyLog() : wxLog() {}
2047
2048 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2049 bool found;
2050 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2051 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2052 PyObject* s = wx2PyString(szString);
2053 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2054 Py_DECREF(s);
2055 }
2056 wxPyEndBlockThreads(blocked);
2057 if (! found)
2058 wxLog::DoLog(level, szString, t);
2059 }
2060
2061 virtual void DoLogString(const wxChar *szString, time_t t) {
2062 bool found;
2063 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2064 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2065 PyObject* s = wx2PyString(szString);
2066 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2067 Py_DECREF(s);
2068 }
2069 wxPyEndBlockThreads(blocked);
2070 if (! found)
2071 wxLog::DoLogString(szString, t);
2072 }
2073
2074 PYPRIVATE;
2075 };
2076
2077
2078
2079
2080 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2081
2082
2083 #include <wx/joystick.h>
2084
2085
2086 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2087 // A C++ stub class for wxJoystick for platforms that don't have it.
2088 class wxJoystick : public wxObject {
2089 public:
2090 wxJoystick(int joystick = wxJOYSTICK1) {
2091 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2092 PyErr_SetString(PyExc_NotImplementedError,
2093 "wxJoystick is not available on this platform.");
2094 wxPyEndBlockThreads(blocked);
2095 }
2096 wxPoint GetPosition() { return wxPoint(-1,-1); }
2097 int GetZPosition() { return -1; }
2098 int GetButtonState() { return -1; }
2099 int GetPOVPosition() { return -1; }
2100 int GetPOVCTSPosition() { return -1; }
2101 int GetRudderPosition() { return -1; }
2102 int GetUPosition() { return -1; }
2103 int GetVPosition() { return -1; }
2104 int GetMovementThreshold() { return -1; }
2105 void SetMovementThreshold(int threshold) {}
2106
2107 bool IsOk(void) { return false; }
2108 int GetNumberJoysticks() { return -1; }
2109 int GetManufacturerId() { return -1; }
2110 int GetProductId() { return -1; }
2111 wxString GetProductName() { return wxEmptyString; }
2112 int GetXMin() { return -1; }
2113 int GetYMin() { return -1; }
2114 int GetZMin() { return -1; }
2115 int GetXMax() { return -1; }
2116 int GetYMax() { return -1; }
2117 int GetZMax() { return -1; }
2118 int GetNumberButtons() { return -1; }
2119 int GetNumberAxes() { return -1; }
2120 int GetMaxButtons() { return -1; }
2121 int GetMaxAxes() { return -1; }
2122 int GetPollingMin() { return -1; }
2123 int GetPollingMax() { return -1; }
2124 int GetRudderMin() { return -1; }
2125 int GetRudderMax() { return -1; }
2126 int GetUMin() { return -1; }
2127 int GetUMax() { return -1; }
2128 int GetVMin() { return -1; }
2129 int GetVMax() { return -1; }
2130
2131 bool HasRudder() { return false; }
2132 bool HasZ() { return false; }
2133 bool HasU() { return false; }
2134 bool HasV() { return false; }
2135 bool HasPOV() { return false; }
2136 bool HasPOV4Dir() { return false; }
2137 bool HasPOVCTS() { return false; }
2138
2139 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2140 bool ReleaseCapture() { return false; }
2141 };
2142 #endif
2143
2144
2145 #include <wx/sound.h>
2146
2147
2148 #if !wxUSE_SOUND
2149 // A C++ stub class for wxWave for platforms that don't have it.
2150 class wxSound : public wxObject
2151 {
2152 public:
2153 wxSound() {
2154 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2155 PyErr_SetString(PyExc_NotImplementedError,
2156 "wxSound is not available on this platform.");
2157 wxPyEndBlockThreads(blocked);
2158 }
2159 wxSound(const wxString&/*, bool*/) {
2160 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2161 PyErr_SetString(PyExc_NotImplementedError,
2162 "wxSound is not available on this platform.");
2163 wxPyEndBlockThreads(blocked);
2164 }
2165 wxSound(int, const wxByte*) {
2166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2167 PyErr_SetString(PyExc_NotImplementedError,
2168 "wxSound is not available on this platform.");
2169 wxPyEndBlockThreads(blocked);
2170 }
2171
2172 ~wxSound() {};
2173
2174 bool Create(const wxString&/*, bool*/) { return false; }
2175 bool Create(int, const wxByte*) { return false; };
2176 bool IsOk() { return false; };
2177 bool Play(unsigned) const { return false; }
2178 static bool Play(const wxString&, unsigned) { return false; }
2179 static void Stop() {}
2180 };
2181
2182 #endif
2183
2184 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2185 if (fileName.Length() == 0)
2186 return new wxSound;
2187 else
2188 return new wxSound(fileName);
2189 }
2190 static wxSound *new_wxSound(PyObject *data){
2191 unsigned char* buffer; int size;
2192 wxSound *sound = NULL;
2193
2194 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2195 if (!PyArg_Parse(data, "t#", &buffer, &size))
2196 goto done;
2197 sound = new wxSound(size, buffer);
2198 done:
2199 wxPyEndBlockThreads(blocked);
2200 return sound;
2201 }
2202 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2203 #ifndef __WXMAC__
2204 unsigned char* buffer;
2205 int size;
2206 bool rv = false;
2207
2208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2209 if (!PyArg_Parse(data, "t#", &buffer, &size))
2210 goto done;
2211 rv = self->Create(size, buffer);
2212 done:
2213 wxPyEndBlockThreads(blocked);
2214 return rv;
2215 #else
2216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2217 PyErr_SetString(PyExc_NotImplementedError,
2218 "Create from data is not available on this platform.");
2219 wxPyEndBlockThreads(blocked);
2220 return false;
2221 #endif
2222 }
2223
2224 #include <wx/mimetype.h>
2225
2226 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2227 wxString str;
2228 if (self->GetMimeType(&str))
2229 return wx2PyString(str);
2230 else
2231 RETURN_NONE();
2232 }
2233 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2234 wxArrayString arr;
2235 if (self->GetMimeTypes(arr))
2236 return wxArrayString2PyList_helper(arr);
2237 else
2238 RETURN_NONE();
2239 }
2240 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2241 wxArrayString arr;
2242 if (self->GetExtensions(arr))
2243 return wxArrayString2PyList_helper(arr);
2244 else
2245 RETURN_NONE();
2246 }
2247 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2248 wxIconLocation loc;
2249 if (self->GetIcon(&loc))
2250 return new wxIcon(loc);
2251 else
2252 return NULL;
2253 }
2254 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2255 wxIconLocation loc;
2256 if (self->GetIcon(&loc)) {
2257 wxString iconFile = loc.GetFileName();
2258 int iconIndex = -1;
2259
2260
2261
2262 // Make a tuple and put the values in it
2263 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2264 PyObject* tuple = PyTuple_New(3);
2265 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2266 wxT("wxIcon"), true));
2267 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2268 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2269 wxPyEndBlockThreads(blocked);
2270 return tuple;
2271 }
2272 else
2273 RETURN_NONE();
2274 }
2275 static PyObject *wxFileType_GetDescription(wxFileType *self){
2276 wxString str;
2277 if (self->GetDescription(&str))
2278 return wx2PyString(str);
2279 else
2280 RETURN_NONE();
2281 }
2282 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2283 wxString str;
2284 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2285 return wx2PyString(str);
2286 else
2287 RETURN_NONE();
2288 }
2289 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2290 wxString str;
2291 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2292 return wx2PyString(str);
2293 else
2294 RETURN_NONE();
2295 }
2296 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2297 wxArrayString verbs;
2298 wxArrayString commands;
2299 if (self->GetAllCommands(&verbs, &commands,
2300 wxFileType::MessageParameters(filename, mimetype))) {
2301 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2302 PyObject* tuple = PyTuple_New(2);
2303 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2304 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2305 wxPyEndBlockThreads(blocked);
2306 return tuple;
2307 }
2308 else
2309 RETURN_NONE();
2310 }
2311 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2312 return wxFileType::ExpandCommand(command,
2313 wxFileType::MessageParameters(filename, mimetype));
2314 }
2315 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2316 wxArrayString arr;
2317 self->EnumAllFileTypes(arr);
2318 return wxArrayString2PyList_helper(arr);
2319 }
2320
2321 #include <wx/artprov.h>
2322
2323 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2324 static const wxString wxPyART_MENU(wxART_MENU);
2325 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2326 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2327 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2328 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2329 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2330 static const wxString wxPyART_OTHER(wxART_OTHER);
2331 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2332 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2333 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2334 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2335 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2336 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2337 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2338 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2339 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2340 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2341 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2342 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2343 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2344 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2345 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2346 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2347 static const wxString wxPyART_PRINT(wxART_PRINT);
2348 static const wxString wxPyART_HELP(wxART_HELP);
2349 static const wxString wxPyART_TIP(wxART_TIP);
2350 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2351 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2352 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2353 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2354 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2355 static const wxString wxPyART_CDROM(wxART_CDROM);
2356 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2357 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2358 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2359 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2360 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2361 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2362 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2363 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2364 static const wxString wxPyART_ERROR(wxART_ERROR);
2365 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2366 static const wxString wxPyART_WARNING(wxART_WARNING);
2367 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2368 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2369 static const wxString wxPyART_COPY(wxART_COPY);
2370 static const wxString wxPyART_CUT(wxART_CUT);
2371 static const wxString wxPyART_PASTE(wxART_PASTE);
2372 static const wxString wxPyART_DELETE(wxART_DELETE);
2373 static const wxString wxPyART_UNDO(wxART_UNDO);
2374 static const wxString wxPyART_REDO(wxART_REDO);
2375 static const wxString wxPyART_QUIT(wxART_QUIT);
2376 static const wxString wxPyART_FIND(wxART_FIND);
2377 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2378 // Python aware wxArtProvider
2379 class wxPyArtProvider : public wxArtProvider {
2380 public:
2381
2382 virtual wxBitmap CreateBitmap(const wxArtID& id,
2383 const wxArtClient& client,
2384 const wxSize& size) {
2385 wxBitmap rval = wxNullBitmap;
2386 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2387 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2388 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2389 PyObject* ro;
2390 wxBitmap* ptr;
2391 PyObject* s1, *s2;
2392 s1 = wx2PyString(id);
2393 s2 = wx2PyString(client);
2394 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2395 Py_DECREF(so);
2396 Py_DECREF(s1);
2397 Py_DECREF(s2);
2398 if (ro) {
2399 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2400 rval = *ptr;
2401 Py_DECREF(ro);
2402 }
2403 }
2404 wxPyEndBlockThreads(blocked);
2405 return rval;
2406 }
2407
2408 PYPRIVATE;
2409 };
2410
2411 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2412
2413
2414
2415 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2416 PyObject* ret = PyTuple_New(3);
2417 if (ret) {
2418 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2419 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2420 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2421 }
2422 return ret;
2423 }
2424
2425 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2426 bool cont;
2427 long index = 0;
2428 wxString value;
2429
2430 cont = self->GetFirstGroup(value, index);
2431 return __EnumerationHelper(cont, value, index);
2432 }
2433 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2434 bool cont;
2435 wxString value;
2436
2437 cont = self->GetNextGroup(value, index);
2438 return __EnumerationHelper(cont, value, index);
2439 }
2440 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2441 bool cont;
2442 long index = 0;
2443 wxString value;
2444
2445 cont = self->GetFirstEntry(value, index);
2446 return __EnumerationHelper(cont, value, index);
2447 }
2448 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2449 bool cont;
2450 wxString value;
2451
2452 cont = self->GetNextEntry(value, index);
2453 return __EnumerationHelper(cont, value, index);
2454 }
2455 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2456 long rv;
2457 self->Read(key, &rv, defaultVal);
2458 return rv;
2459 }
2460
2461 SWIGINTERN int
2462 SWIG_AsVal_double(PyObject *obj, double* val)
2463 {
2464 if (PyNumber_Check(obj)) {
2465 if (val) *val = PyFloat_AsDouble(obj);
2466 return 1;
2467 }
2468 else {
2469 SWIG_type_error("number", obj);
2470 }
2471 return 0;
2472 }
2473
2474
2475 SWIGINTERNSHORT double
2476 SWIG_As_double(PyObject* obj)
2477 {
2478 double v;
2479 if (!SWIG_AsVal_double(obj, &v)) {
2480 /*
2481 this is needed to make valgrind/purify happier.
2482 */
2483 memset((void*)&v, 0, sizeof(double));
2484 }
2485 return v;
2486 }
2487
2488
2489 SWIGINTERNSHORT int
2490 SWIG_Check_double(PyObject* obj)
2491 {
2492 return SWIG_AsVal_double(obj, (double*)0);
2493 }
2494
2495 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2496 double rv;
2497 self->Read(key, &rv, defaultVal);
2498 return rv;
2499 }
2500
2501 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2502 #define SWIG_From_double PyFloat_FromDouble
2503 /*@@*/
2504
2505 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2506 bool rv;
2507 self->Read(key, &rv, defaultVal);
2508 return rv;
2509 }
2510
2511 #include <wx/datetime.h>
2512
2513 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2514 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2515
2516 #define LOCAL_TZ wxDateTime::Local
2517
2518 static PyObject *DateTime_GetAmPmStrings(){
2519 wxString am;
2520 wxString pm;
2521 wxDateTime::GetAmPmStrings(&am, &pm);
2522 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2523 PyObject* tup = PyTuple_New(2);
2524 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2525 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2526 wxPyEndBlockThreads(blocked);
2527 return tup;
2528 }
2529
2530 #if UINT_MAX < LONG_MAX
2531 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2532 #define SWIG_From_unsigned_SS_int SWIG_From_long
2533 /*@@*/
2534 #else
2535 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2536 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2537 /*@@*/
2538 #endif
2539
2540 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2541 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2542 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2543 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2544 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2545 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2546 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2547 return (*self < *other);
2548 }
2549 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2550 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2551 return (*self <= *other);
2552 }
2553 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2554 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2555 return (*self > *other);
2556 }
2557 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2558 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2559 return (*self >= *other);
2560 }
2561 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2562 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2563 return (*self == *other);
2564 }
2565 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2566 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2567 return (*self != *other);
2568 }
2569 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2570 const wxChar* rv;
2571 const wxChar* _date = date;
2572 rv = self->ParseRfc822Date(_date);
2573 if (rv == NULL) return -1;
2574 return rv - _date;
2575 }
2576 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2577 const wxChar* rv;
2578 const wxChar* _date = date;
2579 rv = self->ParseFormat(_date, format, dateDef);
2580 if (rv == NULL) return -1;
2581 return rv - _date;
2582 }
2583 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2584 const wxChar* rv;
2585 const wxChar* _datetime = datetime;
2586 rv = self->ParseDateTime(_datetime);
2587 if (rv == NULL) return -1;
2588 return rv - _datetime;
2589 }
2590 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2591 const wxChar* rv;
2592 const wxChar* _date = date;
2593 rv = self->ParseDate(_date);
2594 if (rv == NULL) return -1;
2595 return rv - _date;
2596 }
2597 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2598 const wxChar* rv;
2599 const wxChar* _time = time;
2600 rv = self->ParseTime(_time);
2601 if (rv == NULL) return -1;
2602 return rv - _time;
2603 }
2604 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2605 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2606 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2607 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2608 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2609 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2610 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2611 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2612 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2613 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2614 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2615 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2616 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2617 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2618 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2619 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2620
2621 #include <wx/dataobj.h>
2622
2623 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2624 size_t count = self->GetFormatCount(dir);
2625 wxDataFormat* formats = new wxDataFormat[count];
2626 self->GetAllFormats(formats, dir);
2627
2628 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2629 PyObject* list = PyList_New(count);
2630 for (size_t i=0; i<count; i++) {
2631 wxDataFormat* format = new wxDataFormat(formats[i]);
2632 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2633 PyList_Append(list, obj);
2634 Py_DECREF(obj);
2635 }
2636 wxPyEndBlockThreads(blocked);
2637 delete [] formats;
2638 return list;
2639 }
2640 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2641 PyObject* rval = NULL;
2642 size_t size = self->GetDataSize(format);
2643 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2644 if (size) {
2645 char* buf = new char[size];
2646 if (self->GetDataHere(format, buf))
2647 rval = PyString_FromStringAndSize(buf, size);
2648 delete [] buf;
2649 }
2650 if (! rval) {
2651 rval = Py_None;
2652 Py_INCREF(rval);
2653 }
2654 wxPyEndBlockThreads(blocked);
2655 return rval;
2656 }
2657 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2658 bool rval;
2659 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2660 if (PyString_Check(data)) {
2661 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2662 }
2663 else {
2664 // raise a TypeError if not a string
2665 PyErr_SetString(PyExc_TypeError, "String expected.");
2666 rval = false;
2667 }
2668 wxPyEndBlockThreads(blocked);
2669 return rval;
2670 }
2671 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2672 PyObject* rval = NULL;
2673 size_t size = self->GetDataSize();
2674 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2675 if (size) {
2676 char* buf = new char[size];
2677 if (self->GetDataHere(buf))
2678 rval = PyString_FromStringAndSize(buf, size);
2679 delete [] buf;
2680 }
2681 if (! rval) {
2682 rval = Py_None;
2683 Py_INCREF(rval);
2684 }
2685 wxPyEndBlockThreads(blocked);
2686 return rval;
2687 }
2688 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2689 bool rval;
2690 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2691 if (PyString_Check(data)) {
2692 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2693 }
2694 else {
2695 // raise a TypeError if not a string
2696 PyErr_SetString(PyExc_TypeError, "String expected.");
2697 rval = false;
2698 }
2699 wxPyEndBlockThreads(blocked);
2700 return rval;
2701 }
2702 // Create a new class for wxPython to use
2703 class wxPyDataObjectSimple : public wxDataObjectSimple {
2704 public:
2705 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2706 : wxDataObjectSimple(format) {}
2707
2708 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2709 bool GetDataHere(void *buf) const;
2710 bool SetData(size_t len, const void *buf) const;
2711 PYPRIVATE;
2712 };
2713
2714 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2715
2716 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2717 // We need to get the data for this object and write it to buf. I think
2718 // the best way to do this for wxPython is to have the Python method
2719 // return either a string or None and then act appropriately with the
2720 // C++ version.
2721
2722 bool rval = false;
2723 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2724 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2725 PyObject* ro;
2726 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2727 if (ro) {
2728 rval = (ro != Py_None && PyString_Check(ro));
2729 if (rval)
2730 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2731 Py_DECREF(ro);
2732 }
2733 }
2734 wxPyEndBlockThreads(blocked);
2735 return rval;
2736 }
2737
2738 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2739 // For this one we simply need to make a string from buf and len
2740 // and send it to the Python method.
2741 bool rval = false;
2742 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2743 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2744 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2745 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2746 Py_DECREF(data);
2747 }
2748 wxPyEndBlockThreads(blocked);
2749 return rval;
2750 }
2751
2752 // Create a new class for wxPython to use
2753 class wxPyTextDataObject : public wxTextDataObject {
2754 public:
2755 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2756 : wxTextDataObject(text) {}
2757
2758 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2759 DEC_PYCALLBACK_STRING__const(GetText);
2760 DEC_PYCALLBACK__STRING(SetText);
2761 PYPRIVATE;
2762 };
2763
2764 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2765 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2766 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2767
2768
2769 // Create a new class for wxPython to use
2770 class wxPyBitmapDataObject : public wxBitmapDataObject {
2771 public:
2772 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2773 : wxBitmapDataObject(bitmap) {}
2774
2775 wxBitmap GetBitmap() const;
2776 void SetBitmap(const wxBitmap& bitmap);
2777 PYPRIVATE;
2778 };
2779
2780 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2781 wxBitmap* rval = &wxNullBitmap;
2782 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2783 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2784 PyObject* ro;
2785 wxBitmap* ptr;
2786 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2787 if (ro) {
2788 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2789 rval = ptr;
2790 Py_DECREF(ro);
2791 }
2792 }
2793 wxPyEndBlockThreads(blocked);
2794 return *rval;
2795 }
2796
2797 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2798 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2799 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2800 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2801 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2802 Py_DECREF(bo);
2803 }
2804 wxPyEndBlockThreads(blocked);
2805 }
2806
2807 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2808 return new wxCustomDataObject(wxDataFormat(formatName));
2809 }
2810 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2811 bool rval;
2812 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2813 if (PyString_Check(data)) {
2814 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2815 }
2816 else {
2817 // raise a TypeError if not a string
2818 PyErr_SetString(PyExc_TypeError, "String expected.");
2819 rval = false;
2820 }
2821 wxPyEndBlockThreads(blocked);
2822 return rval;
2823 }
2824 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2825 PyObject* obj;
2826 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2827 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2828 wxPyEndBlockThreads(blocked);
2829 return obj;
2830 }
2831
2832 #include <wx/metafile.h>
2833
2834
2835 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2836
2837
2838 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2839 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2840 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2841 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2842 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2843
2844
2845 class wxPyTextDropTarget : public wxTextDropTarget {
2846 public:
2847 wxPyTextDropTarget() {}
2848
2849 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2850
2851 DEC_PYCALLBACK__(OnLeave);
2852 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2853 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2854 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2855 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2856
2857 PYPRIVATE;
2858 };
2859
2860 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2861 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2862 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2863 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2864 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2865 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2866
2867
2868
2869 class wxPyFileDropTarget : public wxFileDropTarget {
2870 public:
2871 wxPyFileDropTarget() {}
2872
2873 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2874
2875 DEC_PYCALLBACK__(OnLeave);
2876 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2877 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2878 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2879 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2880
2881 PYPRIVATE;
2882 };
2883
2884 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2885 const wxArrayString& filenames) {
2886 bool rval = false;
2887 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2888 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2889 PyObject* list = wxArrayString2PyList_helper(filenames);
2890 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2891 Py_DECREF(list);
2892 }
2893 wxPyEndBlockThreads(blocked);
2894 return rval;
2895 }
2896
2897
2898
2899 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2900 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2901 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2902 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2903 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2904
2905
2906
2907
2908 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2909
2910 #include <wx/display.h>
2911
2912 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2913 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2914
2915 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2916 #if !wxUSE_DISPLAY
2917 #include <wx/dynarray.h>
2918 #include <wx/vidmode.h>
2919
2920 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2921 #include "wx/arrimpl.cpp"
2922 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2923 const wxVideoMode wxDefaultVideoMode;
2924
2925 class wxDisplay
2926 {
2927 public:
2928 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2929 ~wxDisplay() {}
2930
2931 static size_t GetCount()
2932 { wxPyRaiseNotImplemented(); return 0; }
2933
2934 static int GetFromPoint(const wxPoint& pt)
2935 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2936 static int GetFromWindow(wxWindow *window)
2937 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2938
2939 virtual bool IsOk() const { return false; }
2940 virtual wxRect GetGeometry() const { wxRect r; return r; }
2941 virtual wxString GetName() const { return wxEmptyString; }
2942 bool IsPrimary() const { return false; }
2943
2944 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2945 { wxArrayVideoModes a; return a; }
2946
2947 virtual wxVideoMode GetCurrentMode() const
2948 { return wxDefaultVideoMode; }
2949
2950 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2951 { return false; }
2952
2953 void ResetMode() {}
2954 };
2955 #endif
2956
2957 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2958 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2959 PyObject* pyList = NULL;
2960 wxArrayVideoModes arr = self->GetModes(mode);
2961 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2962 pyList = PyList_New(0);
2963 for (int i=0; i < arr.GetCount(); i++) {
2964 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2965 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2966 PyList_Append(pyList, pyObj);
2967 Py_DECREF(pyObj);
2968 }
2969 wxPyEndBlockThreads(blocked);
2970 return pyList;
2971 }
2972
2973 #include <wx/stdpaths.h>
2974
2975 static wxStandardPaths *StandardPaths_Get(){
2976 return (wxStandardPaths*) &wxStandardPaths::Get();
2977 }
2978 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2979 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2980 #ifdef __cplusplus
2981 extern "C" {
2982 #endif
2983 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2984 PyObject *resultobj;
2985 wxSystemColour arg1 ;
2986 wxColour result;
2987 PyObject * obj0 = 0 ;
2988 char *kwnames[] = {
2989 (char *) "index", NULL
2990 };
2991
2992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2993 {
2994 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2995 if (SWIG_arg_fail(1)) SWIG_fail;
2996 }
2997 {
2998 if (!wxPyCheckForApp()) SWIG_fail;
2999 PyThreadState* __tstate = wxPyBeginAllowThreads();
3000 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3001
3002 wxPyEndAllowThreads(__tstate);
3003 if (PyErr_Occurred()) SWIG_fail;
3004 }
3005 {
3006 wxColour * resultptr;
3007 resultptr = new wxColour((wxColour &)(result));
3008 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3009 }
3010 return resultobj;
3011 fail:
3012 return NULL;
3013 }
3014
3015
3016 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3017 PyObject *resultobj;
3018 wxSystemFont arg1 ;
3019 wxFont result;
3020 PyObject * obj0 = 0 ;
3021 char *kwnames[] = {
3022 (char *) "index", NULL
3023 };
3024
3025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3026 {
3027 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3028 if (SWIG_arg_fail(1)) SWIG_fail;
3029 }
3030 {
3031 if (!wxPyCheckForApp()) SWIG_fail;
3032 PyThreadState* __tstate = wxPyBeginAllowThreads();
3033 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3034
3035 wxPyEndAllowThreads(__tstate);
3036 if (PyErr_Occurred()) SWIG_fail;
3037 }
3038 {
3039 wxFont * resultptr;
3040 resultptr = new wxFont((wxFont &)(result));
3041 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3042 }
3043 return resultobj;
3044 fail:
3045 return NULL;
3046 }
3047
3048
3049 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3050 PyObject *resultobj;
3051 wxSystemMetric arg1 ;
3052 wxWindow *arg2 = (wxWindow *) NULL ;
3053 int result;
3054 PyObject * obj0 = 0 ;
3055 PyObject * obj1 = 0 ;
3056 char *kwnames[] = {
3057 (char *) "index",(char *) "win", NULL
3058 };
3059
3060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3061 {
3062 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3063 if (SWIG_arg_fail(1)) SWIG_fail;
3064 }
3065 if (obj1) {
3066 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3067 if (SWIG_arg_fail(2)) SWIG_fail;
3068 }
3069 {
3070 if (!wxPyCheckForApp()) SWIG_fail;
3071 PyThreadState* __tstate = wxPyBeginAllowThreads();
3072 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3073
3074 wxPyEndAllowThreads(__tstate);
3075 if (PyErr_Occurred()) SWIG_fail;
3076 }
3077 {
3078 resultobj = SWIG_From_int((int)(result));
3079 }
3080 return resultobj;
3081 fail:
3082 return NULL;
3083 }
3084
3085
3086 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3087 PyObject *resultobj;
3088 wxSystemFeature arg1 ;
3089 bool result;
3090 PyObject * obj0 = 0 ;
3091 char *kwnames[] = {
3092 (char *) "index", NULL
3093 };
3094
3095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3096 {
3097 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3098 if (SWIG_arg_fail(1)) SWIG_fail;
3099 }
3100 {
3101 if (!wxPyCheckForApp()) SWIG_fail;
3102 PyThreadState* __tstate = wxPyBeginAllowThreads();
3103 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3104
3105 wxPyEndAllowThreads(__tstate);
3106 if (PyErr_Occurred()) SWIG_fail;
3107 }
3108 {
3109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3110 }
3111 return resultobj;
3112 fail:
3113 return NULL;
3114 }
3115
3116
3117 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3118 PyObject *resultobj;
3119 wxSystemScreenType result;
3120 char *kwnames[] = {
3121 NULL
3122 };
3123
3124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3125 {
3126 if (!wxPyCheckForApp()) SWIG_fail;
3127 PyThreadState* __tstate = wxPyBeginAllowThreads();
3128 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3129
3130 wxPyEndAllowThreads(__tstate);
3131 if (PyErr_Occurred()) SWIG_fail;
3132 }
3133 resultobj = SWIG_From_int((result));
3134 return resultobj;
3135 fail:
3136 return NULL;
3137 }
3138
3139
3140 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3141 PyObject *resultobj;
3142 wxSystemScreenType arg1 ;
3143 PyObject * obj0 = 0 ;
3144 char *kwnames[] = {
3145 (char *) "screen", NULL
3146 };
3147
3148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3149 {
3150 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3151 if (SWIG_arg_fail(1)) SWIG_fail;
3152 }
3153 {
3154 if (!wxPyCheckForApp()) SWIG_fail;
3155 PyThreadState* __tstate = wxPyBeginAllowThreads();
3156 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3157
3158 wxPyEndAllowThreads(__tstate);
3159 if (PyErr_Occurred()) SWIG_fail;
3160 }
3161 Py_INCREF(Py_None); resultobj = Py_None;
3162 return resultobj;
3163 fail:
3164 return NULL;
3165 }
3166
3167
3168 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3169 PyObject *obj;
3170 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3171 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3172 Py_INCREF(obj);
3173 return Py_BuildValue((char *)"");
3174 }
3175 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3176 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3177 return 1;
3178 }
3179
3180
3181 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3182 PyObject *pyobj;
3183
3184 {
3185 #if wxUSE_UNICODE
3186 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3187 #else
3188 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3189 #endif
3190 }
3191 return pyobj;
3192 }
3193
3194
3195 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3196 PyObject *resultobj;
3197 wxSystemOptions *result;
3198 char *kwnames[] = {
3199 NULL
3200 };
3201
3202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3203 {
3204 PyThreadState* __tstate = wxPyBeginAllowThreads();
3205 result = (wxSystemOptions *)new wxSystemOptions();
3206
3207 wxPyEndAllowThreads(__tstate);
3208 if (PyErr_Occurred()) SWIG_fail;
3209 }
3210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3211 return resultobj;
3212 fail:
3213 return NULL;
3214 }
3215
3216
3217 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3218 PyObject *resultobj;
3219 wxString *arg1 = 0 ;
3220 wxString *arg2 = 0 ;
3221 bool temp1 = false ;
3222 bool temp2 = false ;
3223 PyObject * obj0 = 0 ;
3224 PyObject * obj1 = 0 ;
3225 char *kwnames[] = {
3226 (char *) "name",(char *) "value", NULL
3227 };
3228
3229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3230 {
3231 arg1 = wxString_in_helper(obj0);
3232 if (arg1 == NULL) SWIG_fail;
3233 temp1 = true;
3234 }
3235 {
3236 arg2 = wxString_in_helper(obj1);
3237 if (arg2 == NULL) SWIG_fail;
3238 temp2 = true;
3239 }
3240 {
3241 PyThreadState* __tstate = wxPyBeginAllowThreads();
3242 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3243
3244 wxPyEndAllowThreads(__tstate);
3245 if (PyErr_Occurred()) SWIG_fail;
3246 }
3247 Py_INCREF(Py_None); resultobj = Py_None;
3248 {
3249 if (temp1)
3250 delete arg1;
3251 }
3252 {
3253 if (temp2)
3254 delete arg2;
3255 }
3256 return resultobj;
3257 fail:
3258 {
3259 if (temp1)
3260 delete arg1;
3261 }
3262 {
3263 if (temp2)
3264 delete arg2;
3265 }
3266 return NULL;
3267 }
3268
3269
3270 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3271 PyObject *resultobj;
3272 wxString *arg1 = 0 ;
3273 int arg2 ;
3274 bool temp1 = false ;
3275 PyObject * obj0 = 0 ;
3276 PyObject * obj1 = 0 ;
3277 char *kwnames[] = {
3278 (char *) "name",(char *) "value", NULL
3279 };
3280
3281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3282 {
3283 arg1 = wxString_in_helper(obj0);
3284 if (arg1 == NULL) SWIG_fail;
3285 temp1 = true;
3286 }
3287 {
3288 arg2 = (int)(SWIG_As_int(obj1));
3289 if (SWIG_arg_fail(2)) SWIG_fail;
3290 }
3291 {
3292 PyThreadState* __tstate = wxPyBeginAllowThreads();
3293 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3294
3295 wxPyEndAllowThreads(__tstate);
3296 if (PyErr_Occurred()) SWIG_fail;
3297 }
3298 Py_INCREF(Py_None); resultobj = Py_None;
3299 {
3300 if (temp1)
3301 delete arg1;
3302 }
3303 return resultobj;
3304 fail:
3305 {
3306 if (temp1)
3307 delete arg1;
3308 }
3309 return NULL;
3310 }
3311
3312
3313 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3314 PyObject *resultobj;
3315 wxString *arg1 = 0 ;
3316 wxString result;
3317 bool temp1 = false ;
3318 PyObject * obj0 = 0 ;
3319 char *kwnames[] = {
3320 (char *) "name", NULL
3321 };
3322
3323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3324 {
3325 arg1 = wxString_in_helper(obj0);
3326 if (arg1 == NULL) SWIG_fail;
3327 temp1 = true;
3328 }
3329 {
3330 PyThreadState* __tstate = wxPyBeginAllowThreads();
3331 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3332
3333 wxPyEndAllowThreads(__tstate);
3334 if (PyErr_Occurred()) SWIG_fail;
3335 }
3336 {
3337 #if wxUSE_UNICODE
3338 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3339 #else
3340 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3341 #endif
3342 }
3343 {
3344 if (temp1)
3345 delete arg1;
3346 }
3347 return resultobj;
3348 fail:
3349 {
3350 if (temp1)
3351 delete arg1;
3352 }
3353 return NULL;
3354 }
3355
3356
3357 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3358 PyObject *resultobj;
3359 wxString *arg1 = 0 ;
3360 int result;
3361 bool temp1 = false ;
3362 PyObject * obj0 = 0 ;
3363 char *kwnames[] = {
3364 (char *) "name", NULL
3365 };
3366
3367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3368 {
3369 arg1 = wxString_in_helper(obj0);
3370 if (arg1 == NULL) SWIG_fail;
3371 temp1 = true;
3372 }
3373 {
3374 PyThreadState* __tstate = wxPyBeginAllowThreads();
3375 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3376
3377 wxPyEndAllowThreads(__tstate);
3378 if (PyErr_Occurred()) SWIG_fail;
3379 }
3380 {
3381 resultobj = SWIG_From_int((int)(result));
3382 }
3383 {
3384 if (temp1)
3385 delete arg1;
3386 }
3387 return resultobj;
3388 fail:
3389 {
3390 if (temp1)
3391 delete arg1;
3392 }
3393 return NULL;
3394 }
3395
3396
3397 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3398 PyObject *resultobj;
3399 wxString *arg1 = 0 ;
3400 bool result;
3401 bool temp1 = false ;
3402 PyObject * obj0 = 0 ;
3403 char *kwnames[] = {
3404 (char *) "name", NULL
3405 };
3406
3407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3408 {
3409 arg1 = wxString_in_helper(obj0);
3410 if (arg1 == NULL) SWIG_fail;
3411 temp1 = true;
3412 }
3413 {
3414 PyThreadState* __tstate = wxPyBeginAllowThreads();
3415 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3416
3417 wxPyEndAllowThreads(__tstate);
3418 if (PyErr_Occurred()) SWIG_fail;
3419 }
3420 {
3421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3422 }
3423 {
3424 if (temp1)
3425 delete arg1;
3426 }
3427 return resultobj;
3428 fail:
3429 {
3430 if (temp1)
3431 delete arg1;
3432 }
3433 return NULL;
3434 }
3435
3436
3437 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3438 PyObject *resultobj;
3439 wxString *arg1 = 0 ;
3440 bool result;
3441 bool temp1 = false ;
3442 PyObject * obj0 = 0 ;
3443 char *kwnames[] = {
3444 (char *) "name", NULL
3445 };
3446
3447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3448 {
3449 arg1 = wxString_in_helper(obj0);
3450 if (arg1 == NULL) SWIG_fail;
3451 temp1 = true;
3452 }
3453 {
3454 PyThreadState* __tstate = wxPyBeginAllowThreads();
3455 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3456
3457 wxPyEndAllowThreads(__tstate);
3458 if (PyErr_Occurred()) SWIG_fail;
3459 }
3460 {
3461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3462 }
3463 {
3464 if (temp1)
3465 delete arg1;
3466 }
3467 return resultobj;
3468 fail:
3469 {
3470 if (temp1)
3471 delete arg1;
3472 }
3473 return NULL;
3474 }
3475
3476
3477 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3478 PyObject *obj;
3479 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3480 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3481 Py_INCREF(obj);
3482 return Py_BuildValue((char *)"");
3483 }
3484 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3485 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3486 return 1;
3487 }
3488
3489
3490 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3491 PyObject *pyobj;
3492
3493 {
3494 #if wxUSE_UNICODE
3495 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3496 #else
3497 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3498 #endif
3499 }
3500 return pyobj;
3501 }
3502
3503
3504 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3505 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3506 return 1;
3507 }
3508
3509
3510 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3511 PyObject *pyobj;
3512
3513 {
3514 #if wxUSE_UNICODE
3515 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3516 #else
3517 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3518 #endif
3519 }
3520 return pyobj;
3521 }
3522
3523
3524 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3525 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3526 return 1;
3527 }
3528
3529
3530 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3531 PyObject *pyobj;
3532
3533 {
3534 #if wxUSE_UNICODE
3535 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3536 #else
3537 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3538 #endif
3539 }
3540 return pyobj;
3541 }
3542
3543
3544 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3545 PyObject *resultobj;
3546 long result;
3547 char *kwnames[] = {
3548 NULL
3549 };
3550
3551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3552 {
3553 PyThreadState* __tstate = wxPyBeginAllowThreads();
3554 result = (long)wxNewId();
3555
3556 wxPyEndAllowThreads(__tstate);
3557 if (PyErr_Occurred()) SWIG_fail;
3558 }
3559 {
3560 resultobj = SWIG_From_long((long)(result));
3561 }
3562 return resultobj;
3563 fail:
3564 return NULL;
3565 }
3566
3567
3568 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3569 PyObject *resultobj;
3570 long arg1 ;
3571 PyObject * obj0 = 0 ;
3572 char *kwnames[] = {
3573 (char *) "id", NULL
3574 };
3575
3576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3577 {
3578 arg1 = (long)(SWIG_As_long(obj0));
3579 if (SWIG_arg_fail(1)) SWIG_fail;
3580 }
3581 {
3582 PyThreadState* __tstate = wxPyBeginAllowThreads();
3583 wxRegisterId(arg1);
3584
3585 wxPyEndAllowThreads(__tstate);
3586 if (PyErr_Occurred()) SWIG_fail;
3587 }
3588 Py_INCREF(Py_None); resultobj = Py_None;
3589 return resultobj;
3590 fail:
3591 return NULL;
3592 }
3593
3594
3595 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3596 PyObject *resultobj;
3597 long result;
3598 char *kwnames[] = {
3599 NULL
3600 };
3601
3602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3603 {
3604 PyThreadState* __tstate = wxPyBeginAllowThreads();
3605 result = (long)wxGetCurrentId();
3606
3607 wxPyEndAllowThreads(__tstate);
3608 if (PyErr_Occurred()) SWIG_fail;
3609 }
3610 {
3611 resultobj = SWIG_From_long((long)(result));
3612 }
3613 return resultobj;
3614 fail:
3615 return NULL;
3616 }
3617
3618
3619 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3620 PyObject *resultobj;
3621 int arg1 ;
3622 bool result;
3623 PyObject * obj0 = 0 ;
3624 char *kwnames[] = {
3625 (char *) "id", NULL
3626 };
3627
3628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3629 {
3630 arg1 = (int)(SWIG_As_int(obj0));
3631 if (SWIG_arg_fail(1)) SWIG_fail;
3632 }
3633 {
3634 PyThreadState* __tstate = wxPyBeginAllowThreads();
3635 result = (bool)wxIsStockID(arg1);
3636
3637 wxPyEndAllowThreads(__tstate);
3638 if (PyErr_Occurred()) SWIG_fail;
3639 }
3640 {
3641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3642 }
3643 return resultobj;
3644 fail:
3645 return NULL;
3646 }
3647
3648
3649 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3650 PyObject *resultobj;
3651 int arg1 ;
3652 wxString *arg2 = 0 ;
3653 bool result;
3654 bool temp2 = false ;
3655 PyObject * obj0 = 0 ;
3656 PyObject * obj1 = 0 ;
3657 char *kwnames[] = {
3658 (char *) "id",(char *) "label", NULL
3659 };
3660
3661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3662 {
3663 arg1 = (int)(SWIG_As_int(obj0));
3664 if (SWIG_arg_fail(1)) SWIG_fail;
3665 }
3666 {
3667 arg2 = wxString_in_helper(obj1);
3668 if (arg2 == NULL) SWIG_fail;
3669 temp2 = true;
3670 }
3671 {
3672 PyThreadState* __tstate = wxPyBeginAllowThreads();
3673 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3674
3675 wxPyEndAllowThreads(__tstate);
3676 if (PyErr_Occurred()) SWIG_fail;
3677 }
3678 {
3679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3680 }
3681 {
3682 if (temp2)
3683 delete arg2;
3684 }
3685 return resultobj;
3686 fail:
3687 {
3688 if (temp2)
3689 delete arg2;
3690 }
3691 return NULL;
3692 }
3693
3694
3695 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3696 PyObject *resultobj;
3697 int arg1 ;
3698 bool arg2 = (bool) true ;
3699 wxString arg3 = (wxString) wxPyEmptyString ;
3700 wxString result;
3701 PyObject * obj0 = 0 ;
3702 PyObject * obj1 = 0 ;
3703 PyObject * obj2 = 0 ;
3704 char *kwnames[] = {
3705 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3706 };
3707
3708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3709 {
3710 arg1 = (int)(SWIG_As_int(obj0));
3711 if (SWIG_arg_fail(1)) SWIG_fail;
3712 }
3713 if (obj1) {
3714 {
3715 arg2 = (bool)(SWIG_As_bool(obj1));
3716 if (SWIG_arg_fail(2)) SWIG_fail;
3717 }
3718 }
3719 if (obj2) {
3720 {
3721 wxString* sptr = wxString_in_helper(obj2);
3722 if (sptr == NULL) SWIG_fail;
3723 arg3 = *sptr;
3724 delete sptr;
3725 }
3726 }
3727 {
3728 PyThreadState* __tstate = wxPyBeginAllowThreads();
3729 result = wxGetStockLabel(arg1,arg2,arg3);
3730
3731 wxPyEndAllowThreads(__tstate);
3732 if (PyErr_Occurred()) SWIG_fail;
3733 }
3734 {
3735 #if wxUSE_UNICODE
3736 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3737 #else
3738 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3739 #endif
3740 }
3741 return resultobj;
3742 fail:
3743 return NULL;
3744 }
3745
3746
3747 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3748 PyObject *resultobj;
3749 char *kwnames[] = {
3750 NULL
3751 };
3752
3753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3754 {
3755 if (!wxPyCheckForApp()) SWIG_fail;
3756 PyThreadState* __tstate = wxPyBeginAllowThreads();
3757 wxBell();
3758
3759 wxPyEndAllowThreads(__tstate);
3760 if (PyErr_Occurred()) SWIG_fail;
3761 }
3762 Py_INCREF(Py_None); resultobj = Py_None;
3763 return resultobj;
3764 fail:
3765 return NULL;
3766 }
3767
3768
3769 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3770 PyObject *resultobj;
3771 char *kwnames[] = {
3772 NULL
3773 };
3774
3775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3776 {
3777 if (!wxPyCheckForApp()) SWIG_fail;
3778 PyThreadState* __tstate = wxPyBeginAllowThreads();
3779 wxEndBusyCursor();
3780
3781 wxPyEndAllowThreads(__tstate);
3782 if (PyErr_Occurred()) SWIG_fail;
3783 }
3784 Py_INCREF(Py_None); resultobj = Py_None;
3785 return resultobj;
3786 fail:
3787 return NULL;
3788 }
3789
3790
3791 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3792 PyObject *resultobj;
3793 bool arg1 = (bool) true ;
3794 long result;
3795 PyObject * obj0 = 0 ;
3796 char *kwnames[] = {
3797 (char *) "resetTimer", NULL
3798 };
3799
3800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3801 if (obj0) {
3802 {
3803 arg1 = (bool)(SWIG_As_bool(obj0));
3804 if (SWIG_arg_fail(1)) SWIG_fail;
3805 }
3806 }
3807 {
3808 PyThreadState* __tstate = wxPyBeginAllowThreads();
3809 result = (long)wxGetElapsedTime(arg1);
3810
3811 wxPyEndAllowThreads(__tstate);
3812 if (PyErr_Occurred()) SWIG_fail;
3813 }
3814 {
3815 resultobj = SWIG_From_long((long)(result));
3816 }
3817 return resultobj;
3818 fail:
3819 return NULL;
3820 }
3821
3822
3823 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3824 PyObject *resultobj;
3825 int *arg1 = (int *) 0 ;
3826 int *arg2 = (int *) 0 ;
3827 int temp1 ;
3828 int res1 = 0 ;
3829 int temp2 ;
3830 int res2 = 0 ;
3831 char *kwnames[] = {
3832 NULL
3833 };
3834
3835 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3836 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3838 {
3839 if (!wxPyCheckForApp()) SWIG_fail;
3840 PyThreadState* __tstate = wxPyBeginAllowThreads();
3841 wxGetMousePosition(arg1,arg2);
3842
3843 wxPyEndAllowThreads(__tstate);
3844 if (PyErr_Occurred()) SWIG_fail;
3845 }
3846 Py_INCREF(Py_None); resultobj = Py_None;
3847 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3848 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3849 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3850 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3851 return resultobj;
3852 fail:
3853 return NULL;
3854 }
3855
3856
3857 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3858 PyObject *resultobj;
3859 bool result;
3860 char *kwnames[] = {
3861 NULL
3862 };
3863
3864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3865 {
3866 PyThreadState* __tstate = wxPyBeginAllowThreads();
3867 result = (bool)wxIsBusy();
3868
3869 wxPyEndAllowThreads(__tstate);
3870 if (PyErr_Occurred()) SWIG_fail;
3871 }
3872 {
3873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3874 }
3875 return resultobj;
3876 fail:
3877 return NULL;
3878 }
3879
3880
3881 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3882 PyObject *resultobj;
3883 wxString result;
3884 char *kwnames[] = {
3885 NULL
3886 };
3887
3888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3889 {
3890 PyThreadState* __tstate = wxPyBeginAllowThreads();
3891 result = wxNow();
3892
3893 wxPyEndAllowThreads(__tstate);
3894 if (PyErr_Occurred()) SWIG_fail;
3895 }
3896 {
3897 #if wxUSE_UNICODE
3898 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3899 #else
3900 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3901 #endif
3902 }
3903 return resultobj;
3904 fail:
3905 return NULL;
3906 }
3907
3908
3909 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3910 PyObject *resultobj;
3911 wxString const &arg1_defvalue = wxPyEmptyString ;
3912 wxString *arg1 = (wxString *) &arg1_defvalue ;
3913 bool result;
3914 bool temp1 = false ;
3915 PyObject * obj0 = 0 ;
3916 char *kwnames[] = {
3917 (char *) "command", NULL
3918 };
3919
3920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3921 if (obj0) {
3922 {
3923 arg1 = wxString_in_helper(obj0);
3924 if (arg1 == NULL) SWIG_fail;
3925 temp1 = true;
3926 }
3927 }
3928 {
3929 PyThreadState* __tstate = wxPyBeginAllowThreads();
3930 result = (bool)wxShell((wxString const &)*arg1);
3931
3932 wxPyEndAllowThreads(__tstate);
3933 if (PyErr_Occurred()) SWIG_fail;
3934 }
3935 {
3936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3937 }
3938 {
3939 if (temp1)
3940 delete arg1;
3941 }
3942 return resultobj;
3943 fail:
3944 {
3945 if (temp1)
3946 delete arg1;
3947 }
3948 return NULL;
3949 }
3950
3951
3952 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3953 PyObject *resultobj;
3954 char *kwnames[] = {
3955 NULL
3956 };
3957
3958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3959 {
3960 PyThreadState* __tstate = wxPyBeginAllowThreads();
3961 wxStartTimer();
3962
3963 wxPyEndAllowThreads(__tstate);
3964 if (PyErr_Occurred()) SWIG_fail;
3965 }
3966 Py_INCREF(Py_None); resultobj = Py_None;
3967 return resultobj;
3968 fail:
3969 return NULL;
3970 }
3971
3972
3973 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3974 PyObject *resultobj;
3975 int *arg1 = (int *) 0 ;
3976 int *arg2 = (int *) 0 ;
3977 int result;
3978 int temp1 ;
3979 int res1 = 0 ;
3980 int temp2 ;
3981 int res2 = 0 ;
3982 char *kwnames[] = {
3983 NULL
3984 };
3985
3986 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3987 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3989 {
3990 PyThreadState* __tstate = wxPyBeginAllowThreads();
3991 result = (int)wxGetOsVersion(arg1,arg2);
3992
3993 wxPyEndAllowThreads(__tstate);
3994 if (PyErr_Occurred()) SWIG_fail;
3995 }
3996 {
3997 resultobj = SWIG_From_int((int)(result));
3998 }
3999 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4000 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4001 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4002 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4003 return resultobj;
4004 fail:
4005 return NULL;
4006 }
4007
4008
4009 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4010 PyObject *resultobj;
4011 wxString result;
4012 char *kwnames[] = {
4013 NULL
4014 };
4015
4016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4017 {
4018 PyThreadState* __tstate = wxPyBeginAllowThreads();
4019 result = wxGetOsDescription();
4020
4021 wxPyEndAllowThreads(__tstate);
4022 if (PyErr_Occurred()) SWIG_fail;
4023 }
4024 {
4025 #if wxUSE_UNICODE
4026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4027 #else
4028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4029 #endif
4030 }
4031 return resultobj;
4032 fail:
4033 return NULL;
4034 }
4035
4036
4037 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4038 PyObject *resultobj;
4039 long result;
4040 char *kwnames[] = {
4041 NULL
4042 };
4043
4044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4045 {
4046 PyThreadState* __tstate = wxPyBeginAllowThreads();
4047 result = (long)wxGetFreeMemory();
4048
4049 wxPyEndAllowThreads(__tstate);
4050 if (PyErr_Occurred()) SWIG_fail;
4051 }
4052 {
4053 resultobj = SWIG_From_long((long)(result));
4054 }
4055 return resultobj;
4056 fail:
4057 return NULL;
4058 }
4059
4060
4061 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4062 PyObject *resultobj;
4063 wxShutdownFlags arg1 ;
4064 bool result;
4065 PyObject * obj0 = 0 ;
4066 char *kwnames[] = {
4067 (char *) "wFlags", NULL
4068 };
4069
4070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4071 {
4072 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4073 if (SWIG_arg_fail(1)) SWIG_fail;
4074 }
4075 {
4076 if (!wxPyCheckForApp()) SWIG_fail;
4077 PyThreadState* __tstate = wxPyBeginAllowThreads();
4078 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4079
4080 wxPyEndAllowThreads(__tstate);
4081 if (PyErr_Occurred()) SWIG_fail;
4082 }
4083 {
4084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4085 }
4086 return resultobj;
4087 fail:
4088 return NULL;
4089 }
4090
4091
4092 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4093 PyObject *resultobj;
4094 int arg1 ;
4095 PyObject * obj0 = 0 ;
4096 char *kwnames[] = {
4097 (char *) "secs", NULL
4098 };
4099
4100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4101 {
4102 arg1 = (int)(SWIG_As_int(obj0));
4103 if (SWIG_arg_fail(1)) SWIG_fail;
4104 }
4105 {
4106 PyThreadState* __tstate = wxPyBeginAllowThreads();
4107 wxSleep(arg1);
4108
4109 wxPyEndAllowThreads(__tstate);
4110 if (PyErr_Occurred()) SWIG_fail;
4111 }
4112 Py_INCREF(Py_None); resultobj = Py_None;
4113 return resultobj;
4114 fail:
4115 return NULL;
4116 }
4117
4118
4119 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4120 PyObject *resultobj;
4121 unsigned long arg1 ;
4122 PyObject * obj0 = 0 ;
4123 char *kwnames[] = {
4124 (char *) "milliseconds", NULL
4125 };
4126
4127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4128 {
4129 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4130 if (SWIG_arg_fail(1)) SWIG_fail;
4131 }
4132 {
4133 PyThreadState* __tstate = wxPyBeginAllowThreads();
4134 wxMilliSleep(arg1);
4135
4136 wxPyEndAllowThreads(__tstate);
4137 if (PyErr_Occurred()) SWIG_fail;
4138 }
4139 Py_INCREF(Py_None); resultobj = Py_None;
4140 return resultobj;
4141 fail:
4142 return NULL;
4143 }
4144
4145
4146 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4147 PyObject *resultobj;
4148 unsigned long arg1 ;
4149 PyObject * obj0 = 0 ;
4150 char *kwnames[] = {
4151 (char *) "microseconds", NULL
4152 };
4153
4154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4155 {
4156 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4157 if (SWIG_arg_fail(1)) SWIG_fail;
4158 }
4159 {
4160 PyThreadState* __tstate = wxPyBeginAllowThreads();
4161 wxMicroSleep(arg1);
4162
4163 wxPyEndAllowThreads(__tstate);
4164 if (PyErr_Occurred()) SWIG_fail;
4165 }
4166 Py_INCREF(Py_None); resultobj = Py_None;
4167 return resultobj;
4168 fail:
4169 return NULL;
4170 }
4171
4172
4173 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4174 PyObject *resultobj;
4175 bool arg1 ;
4176 PyObject * obj0 = 0 ;
4177 char *kwnames[] = {
4178 (char *) "enable", NULL
4179 };
4180
4181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4182 {
4183 arg1 = (bool)(SWIG_As_bool(obj0));
4184 if (SWIG_arg_fail(1)) SWIG_fail;
4185 }
4186 {
4187 PyThreadState* __tstate = wxPyBeginAllowThreads();
4188 wxEnableTopLevelWindows(arg1);
4189
4190 wxPyEndAllowThreads(__tstate);
4191 if (PyErr_Occurred()) SWIG_fail;
4192 }
4193 Py_INCREF(Py_None); resultobj = Py_None;
4194 return resultobj;
4195 fail:
4196 return NULL;
4197 }
4198
4199
4200 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4201 PyObject *resultobj;
4202 wxString *arg1 = 0 ;
4203 wxString result;
4204 bool temp1 = false ;
4205 PyObject * obj0 = 0 ;
4206 char *kwnames[] = {
4207 (char *) "in", NULL
4208 };
4209
4210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4211 {
4212 arg1 = wxString_in_helper(obj0);
4213 if (arg1 == NULL) SWIG_fail;
4214 temp1 = true;
4215 }
4216 {
4217 PyThreadState* __tstate = wxPyBeginAllowThreads();
4218 result = wxStripMenuCodes((wxString const &)*arg1);
4219
4220 wxPyEndAllowThreads(__tstate);
4221 if (PyErr_Occurred()) SWIG_fail;
4222 }
4223 {
4224 #if wxUSE_UNICODE
4225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4226 #else
4227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4228 #endif
4229 }
4230 {
4231 if (temp1)
4232 delete arg1;
4233 }
4234 return resultobj;
4235 fail:
4236 {
4237 if (temp1)
4238 delete arg1;
4239 }
4240 return NULL;
4241 }
4242
4243
4244 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4245 PyObject *resultobj;
4246 wxString result;
4247 char *kwnames[] = {
4248 NULL
4249 };
4250
4251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4252 {
4253 PyThreadState* __tstate = wxPyBeginAllowThreads();
4254 result = wxGetEmailAddress();
4255
4256 wxPyEndAllowThreads(__tstate);
4257 if (PyErr_Occurred()) SWIG_fail;
4258 }
4259 {
4260 #if wxUSE_UNICODE
4261 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4262 #else
4263 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4264 #endif
4265 }
4266 return resultobj;
4267 fail:
4268 return NULL;
4269 }
4270
4271
4272 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4273 PyObject *resultobj;
4274 wxString result;
4275 char *kwnames[] = {
4276 NULL
4277 };
4278
4279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4280 {
4281 PyThreadState* __tstate = wxPyBeginAllowThreads();
4282 result = wxGetHostName();
4283
4284 wxPyEndAllowThreads(__tstate);
4285 if (PyErr_Occurred()) SWIG_fail;
4286 }
4287 {
4288 #if wxUSE_UNICODE
4289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4290 #else
4291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4292 #endif
4293 }
4294 return resultobj;
4295 fail:
4296 return NULL;
4297 }
4298
4299
4300 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4301 PyObject *resultobj;
4302 wxString result;
4303 char *kwnames[] = {
4304 NULL
4305 };
4306
4307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4308 {
4309 PyThreadState* __tstate = wxPyBeginAllowThreads();
4310 result = wxGetFullHostName();
4311
4312 wxPyEndAllowThreads(__tstate);
4313 if (PyErr_Occurred()) SWIG_fail;
4314 }
4315 {
4316 #if wxUSE_UNICODE
4317 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4318 #else
4319 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4320 #endif
4321 }
4322 return resultobj;
4323 fail:
4324 return NULL;
4325 }
4326
4327
4328 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4329 PyObject *resultobj;
4330 wxString result;
4331 char *kwnames[] = {
4332 NULL
4333 };
4334
4335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4336 {
4337 PyThreadState* __tstate = wxPyBeginAllowThreads();
4338 result = wxGetUserId();
4339
4340 wxPyEndAllowThreads(__tstate);
4341 if (PyErr_Occurred()) SWIG_fail;
4342 }
4343 {
4344 #if wxUSE_UNICODE
4345 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4346 #else
4347 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4348 #endif
4349 }
4350 return resultobj;
4351 fail:
4352 return NULL;
4353 }
4354
4355
4356 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4357 PyObject *resultobj;
4358 wxString result;
4359 char *kwnames[] = {
4360 NULL
4361 };
4362
4363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4364 {
4365 PyThreadState* __tstate = wxPyBeginAllowThreads();
4366 result = wxGetUserName();
4367
4368 wxPyEndAllowThreads(__tstate);
4369 if (PyErr_Occurred()) SWIG_fail;
4370 }
4371 {
4372 #if wxUSE_UNICODE
4373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4374 #else
4375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4376 #endif
4377 }
4378 return resultobj;
4379 fail:
4380 return NULL;
4381 }
4382
4383
4384 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4385 PyObject *resultobj;
4386 wxString result;
4387 char *kwnames[] = {
4388 NULL
4389 };
4390
4391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4392 {
4393 PyThreadState* __tstate = wxPyBeginAllowThreads();
4394 result = wxGetHomeDir();
4395
4396 wxPyEndAllowThreads(__tstate);
4397 if (PyErr_Occurred()) SWIG_fail;
4398 }
4399 {
4400 #if wxUSE_UNICODE
4401 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4402 #else
4403 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4404 #endif
4405 }
4406 return resultobj;
4407 fail:
4408 return NULL;
4409 }
4410
4411
4412 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4413 PyObject *resultobj;
4414 wxString const &arg1_defvalue = wxPyEmptyString ;
4415 wxString *arg1 = (wxString *) &arg1_defvalue ;
4416 wxString result;
4417 bool temp1 = false ;
4418 PyObject * obj0 = 0 ;
4419 char *kwnames[] = {
4420 (char *) "user", NULL
4421 };
4422
4423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4424 if (obj0) {
4425 {
4426 arg1 = wxString_in_helper(obj0);
4427 if (arg1 == NULL) SWIG_fail;
4428 temp1 = true;
4429 }
4430 }
4431 {
4432 PyThreadState* __tstate = wxPyBeginAllowThreads();
4433 result = wxGetUserHome((wxString const &)*arg1);
4434
4435 wxPyEndAllowThreads(__tstate);
4436 if (PyErr_Occurred()) SWIG_fail;
4437 }
4438 {
4439 #if wxUSE_UNICODE
4440 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4441 #else
4442 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4443 #endif
4444 }
4445 {
4446 if (temp1)
4447 delete arg1;
4448 }
4449 return resultobj;
4450 fail:
4451 {
4452 if (temp1)
4453 delete arg1;
4454 }
4455 return NULL;
4456 }
4457
4458
4459 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4460 PyObject *resultobj;
4461 unsigned long result;
4462 char *kwnames[] = {
4463 NULL
4464 };
4465
4466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4467 {
4468 PyThreadState* __tstate = wxPyBeginAllowThreads();
4469 result = (unsigned long)wxGetProcessId();
4470
4471 wxPyEndAllowThreads(__tstate);
4472 if (PyErr_Occurred()) SWIG_fail;
4473 }
4474 {
4475 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4476 }
4477 return resultobj;
4478 fail:
4479 return NULL;
4480 }
4481
4482
4483 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4484 PyObject *resultobj;
4485 char *kwnames[] = {
4486 NULL
4487 };
4488
4489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4490 {
4491 PyThreadState* __tstate = wxPyBeginAllowThreads();
4492 wxTrap();
4493
4494 wxPyEndAllowThreads(__tstate);
4495 if (PyErr_Occurred()) SWIG_fail;
4496 }
4497 Py_INCREF(Py_None); resultobj = Py_None;
4498 return resultobj;
4499 fail:
4500 return NULL;
4501 }
4502
4503
4504 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4505 PyObject *resultobj;
4506 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4507 wxString *arg1 = (wxString *) &arg1_defvalue ;
4508 wxString const &arg2_defvalue = wxPyEmptyString ;
4509 wxString *arg2 = (wxString *) &arg2_defvalue ;
4510 wxString const &arg3_defvalue = wxPyEmptyString ;
4511 wxString *arg3 = (wxString *) &arg3_defvalue ;
4512 wxString const &arg4_defvalue = wxPyEmptyString ;
4513 wxString *arg4 = (wxString *) &arg4_defvalue ;
4514 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4515 wxString *arg5 = (wxString *) &arg5_defvalue ;
4516 int arg6 = (int) 0 ;
4517 wxWindow *arg7 = (wxWindow *) NULL ;
4518 int arg8 = (int) -1 ;
4519 int arg9 = (int) -1 ;
4520 wxString result;
4521 bool temp1 = false ;
4522 bool temp2 = false ;
4523 bool temp3 = false ;
4524 bool temp4 = false ;
4525 bool temp5 = false ;
4526 PyObject * obj0 = 0 ;
4527 PyObject * obj1 = 0 ;
4528 PyObject * obj2 = 0 ;
4529 PyObject * obj3 = 0 ;
4530 PyObject * obj4 = 0 ;
4531 PyObject * obj5 = 0 ;
4532 PyObject * obj6 = 0 ;
4533 PyObject * obj7 = 0 ;
4534 PyObject * obj8 = 0 ;
4535 char *kwnames[] = {
4536 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4537 };
4538
4539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4540 if (obj0) {
4541 {
4542 arg1 = wxString_in_helper(obj0);
4543 if (arg1 == NULL) SWIG_fail;
4544 temp1 = true;
4545 }
4546 }
4547 if (obj1) {
4548 {
4549 arg2 = wxString_in_helper(obj1);
4550 if (arg2 == NULL) SWIG_fail;
4551 temp2 = true;
4552 }
4553 }
4554 if (obj2) {
4555 {
4556 arg3 = wxString_in_helper(obj2);
4557 if (arg3 == NULL) SWIG_fail;
4558 temp3 = true;
4559 }
4560 }
4561 if (obj3) {
4562 {
4563 arg4 = wxString_in_helper(obj3);
4564 if (arg4 == NULL) SWIG_fail;
4565 temp4 = true;
4566 }
4567 }
4568 if (obj4) {
4569 {
4570 arg5 = wxString_in_helper(obj4);
4571 if (arg5 == NULL) SWIG_fail;
4572 temp5 = true;
4573 }
4574 }
4575 if (obj5) {
4576 {
4577 arg6 = (int)(SWIG_As_int(obj5));
4578 if (SWIG_arg_fail(6)) SWIG_fail;
4579 }
4580 }
4581 if (obj6) {
4582 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4583 if (SWIG_arg_fail(7)) SWIG_fail;
4584 }
4585 if (obj7) {
4586 {
4587 arg8 = (int)(SWIG_As_int(obj7));
4588 if (SWIG_arg_fail(8)) SWIG_fail;
4589 }
4590 }
4591 if (obj8) {
4592 {
4593 arg9 = (int)(SWIG_As_int(obj8));
4594 if (SWIG_arg_fail(9)) SWIG_fail;
4595 }
4596 }
4597 {
4598 if (!wxPyCheckForApp()) SWIG_fail;
4599 PyThreadState* __tstate = wxPyBeginAllowThreads();
4600 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4601
4602 wxPyEndAllowThreads(__tstate);
4603 if (PyErr_Occurred()) SWIG_fail;
4604 }
4605 {
4606 #if wxUSE_UNICODE
4607 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4608 #else
4609 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4610 #endif
4611 }
4612 {
4613 if (temp1)
4614 delete arg1;
4615 }
4616 {
4617 if (temp2)
4618 delete arg2;
4619 }
4620 {
4621 if (temp3)
4622 delete arg3;
4623 }
4624 {
4625 if (temp4)
4626 delete arg4;
4627 }
4628 {
4629 if (temp5)
4630 delete arg5;
4631 }
4632 return resultobj;
4633 fail:
4634 {
4635 if (temp1)
4636 delete arg1;
4637 }
4638 {
4639 if (temp2)
4640 delete arg2;
4641 }
4642 {
4643 if (temp3)
4644 delete arg3;
4645 }
4646 {
4647 if (temp4)
4648 delete arg4;
4649 }
4650 {
4651 if (temp5)
4652 delete arg5;
4653 }
4654 return NULL;
4655 }
4656
4657
4658 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4659 PyObject *resultobj;
4660 wxString *arg1 = 0 ;
4661 wxString *arg2 = 0 ;
4662 wxString const &arg3_defvalue = wxPyEmptyString ;
4663 wxString *arg3 = (wxString *) &arg3_defvalue ;
4664 wxWindow *arg4 = (wxWindow *) NULL ;
4665 wxString result;
4666 bool temp1 = false ;
4667 bool temp2 = false ;
4668 bool temp3 = false ;
4669 PyObject * obj0 = 0 ;
4670 PyObject * obj1 = 0 ;
4671 PyObject * obj2 = 0 ;
4672 PyObject * obj3 = 0 ;
4673 char *kwnames[] = {
4674 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4675 };
4676
4677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4678 {
4679 arg1 = wxString_in_helper(obj0);
4680 if (arg1 == NULL) SWIG_fail;
4681 temp1 = true;
4682 }
4683 {
4684 arg2 = wxString_in_helper(obj1);
4685 if (arg2 == NULL) SWIG_fail;
4686 temp2 = true;
4687 }
4688 if (obj2) {
4689 {
4690 arg3 = wxString_in_helper(obj2);
4691 if (arg3 == NULL) SWIG_fail;
4692 temp3 = true;
4693 }
4694 }
4695 if (obj3) {
4696 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4697 if (SWIG_arg_fail(4)) SWIG_fail;
4698 }
4699 {
4700 if (!wxPyCheckForApp()) SWIG_fail;
4701 PyThreadState* __tstate = wxPyBeginAllowThreads();
4702 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4703
4704 wxPyEndAllowThreads(__tstate);
4705 if (PyErr_Occurred()) SWIG_fail;
4706 }
4707 {
4708 #if wxUSE_UNICODE
4709 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4710 #else
4711 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4712 #endif
4713 }
4714 {
4715 if (temp1)
4716 delete arg1;
4717 }
4718 {
4719 if (temp2)
4720 delete arg2;
4721 }
4722 {
4723 if (temp3)
4724 delete arg3;
4725 }
4726 return resultobj;
4727 fail:
4728 {
4729 if (temp1)
4730 delete arg1;
4731 }
4732 {
4733 if (temp2)
4734 delete arg2;
4735 }
4736 {
4737 if (temp3)
4738 delete arg3;
4739 }
4740 return NULL;
4741 }
4742
4743
4744 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4745 PyObject *resultobj;
4746 wxString *arg1 = 0 ;
4747 wxString *arg2 = 0 ;
4748 wxString const &arg3_defvalue = wxPyEmptyString ;
4749 wxString *arg3 = (wxString *) &arg3_defvalue ;
4750 wxWindow *arg4 = (wxWindow *) NULL ;
4751 wxString result;
4752 bool temp1 = false ;
4753 bool temp2 = false ;
4754 bool temp3 = false ;
4755 PyObject * obj0 = 0 ;
4756 PyObject * obj1 = 0 ;
4757 PyObject * obj2 = 0 ;
4758 PyObject * obj3 = 0 ;
4759 char *kwnames[] = {
4760 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4761 };
4762
4763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4764 {
4765 arg1 = wxString_in_helper(obj0);
4766 if (arg1 == NULL) SWIG_fail;
4767 temp1 = true;
4768 }
4769 {
4770 arg2 = wxString_in_helper(obj1);
4771 if (arg2 == NULL) SWIG_fail;
4772 temp2 = true;
4773 }
4774 if (obj2) {
4775 {
4776 arg3 = wxString_in_helper(obj2);
4777 if (arg3 == NULL) SWIG_fail;
4778 temp3 = true;
4779 }
4780 }
4781 if (obj3) {
4782 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4783 if (SWIG_arg_fail(4)) SWIG_fail;
4784 }
4785 {
4786 if (!wxPyCheckForApp()) SWIG_fail;
4787 PyThreadState* __tstate = wxPyBeginAllowThreads();
4788 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4789
4790 wxPyEndAllowThreads(__tstate);
4791 if (PyErr_Occurred()) SWIG_fail;
4792 }
4793 {
4794 #if wxUSE_UNICODE
4795 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4796 #else
4797 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4798 #endif
4799 }
4800 {
4801 if (temp1)
4802 delete arg1;
4803 }
4804 {
4805 if (temp2)
4806 delete arg2;
4807 }
4808 {
4809 if (temp3)
4810 delete arg3;
4811 }
4812 return resultobj;
4813 fail:
4814 {
4815 if (temp1)
4816 delete arg1;
4817 }
4818 {
4819 if (temp2)
4820 delete arg2;
4821 }
4822 {
4823 if (temp3)
4824 delete arg3;
4825 }
4826 return NULL;
4827 }
4828
4829
4830 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4831 PyObject *resultobj;
4832 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4833 wxString *arg1 = (wxString *) &arg1_defvalue ;
4834 wxString const &arg2_defvalue = wxPyEmptyString ;
4835 wxString *arg2 = (wxString *) &arg2_defvalue ;
4836 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4837 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4838 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4839 wxWindow *arg5 = (wxWindow *) NULL ;
4840 wxString result;
4841 bool temp1 = false ;
4842 bool temp2 = false ;
4843 wxPoint temp4 ;
4844 PyObject * obj0 = 0 ;
4845 PyObject * obj1 = 0 ;
4846 PyObject * obj2 = 0 ;
4847 PyObject * obj3 = 0 ;
4848 PyObject * obj4 = 0 ;
4849 char *kwnames[] = {
4850 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4851 };
4852
4853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4854 if (obj0) {
4855 {
4856 arg1 = wxString_in_helper(obj0);
4857 if (arg1 == NULL) SWIG_fail;
4858 temp1 = true;
4859 }
4860 }
4861 if (obj1) {
4862 {
4863 arg2 = wxString_in_helper(obj1);
4864 if (arg2 == NULL) SWIG_fail;
4865 temp2 = true;
4866 }
4867 }
4868 if (obj2) {
4869 {
4870 arg3 = (long)(SWIG_As_long(obj2));
4871 if (SWIG_arg_fail(3)) SWIG_fail;
4872 }
4873 }
4874 if (obj3) {
4875 {
4876 arg4 = &temp4;
4877 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4878 }
4879 }
4880 if (obj4) {
4881 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4882 if (SWIG_arg_fail(5)) SWIG_fail;
4883 }
4884 {
4885 if (!wxPyCheckForApp()) SWIG_fail;
4886 PyThreadState* __tstate = wxPyBeginAllowThreads();
4887 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4888
4889 wxPyEndAllowThreads(__tstate);
4890 if (PyErr_Occurred()) SWIG_fail;
4891 }
4892 {
4893 #if wxUSE_UNICODE
4894 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4895 #else
4896 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4897 #endif
4898 }
4899 {
4900 if (temp1)
4901 delete arg1;
4902 }
4903 {
4904 if (temp2)
4905 delete arg2;
4906 }
4907 return resultobj;
4908 fail:
4909 {
4910 if (temp1)
4911 delete arg1;
4912 }
4913 {
4914 if (temp2)
4915 delete arg2;
4916 }
4917 return NULL;
4918 }
4919
4920
4921 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4922 PyObject *resultobj;
4923 wxString *arg1 = 0 ;
4924 wxString const &arg2_defvalue = wxPyEmptyString ;
4925 wxString *arg2 = (wxString *) &arg2_defvalue ;
4926 wxString const &arg3_defvalue = wxPyEmptyString ;
4927 wxString *arg3 = (wxString *) &arg3_defvalue ;
4928 wxWindow *arg4 = (wxWindow *) NULL ;
4929 int arg5 = (int) -1 ;
4930 int arg6 = (int) -1 ;
4931 bool arg7 = (bool) true ;
4932 wxString result;
4933 bool temp1 = false ;
4934 bool temp2 = false ;
4935 bool temp3 = false ;
4936 PyObject * obj0 = 0 ;
4937 PyObject * obj1 = 0 ;
4938 PyObject * obj2 = 0 ;
4939 PyObject * obj3 = 0 ;
4940 PyObject * obj4 = 0 ;
4941 PyObject * obj5 = 0 ;
4942 PyObject * obj6 = 0 ;
4943 char *kwnames[] = {
4944 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4945 };
4946
4947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4948 {
4949 arg1 = wxString_in_helper(obj0);
4950 if (arg1 == NULL) SWIG_fail;
4951 temp1 = true;
4952 }
4953 if (obj1) {
4954 {
4955 arg2 = wxString_in_helper(obj1);
4956 if (arg2 == NULL) SWIG_fail;
4957 temp2 = true;
4958 }
4959 }
4960 if (obj2) {
4961 {
4962 arg3 = wxString_in_helper(obj2);
4963 if (arg3 == NULL) SWIG_fail;
4964 temp3 = true;
4965 }
4966 }
4967 if (obj3) {
4968 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4969 if (SWIG_arg_fail(4)) SWIG_fail;
4970 }
4971 if (obj4) {
4972 {
4973 arg5 = (int)(SWIG_As_int(obj4));
4974 if (SWIG_arg_fail(5)) SWIG_fail;
4975 }
4976 }
4977 if (obj5) {
4978 {
4979 arg6 = (int)(SWIG_As_int(obj5));
4980 if (SWIG_arg_fail(6)) SWIG_fail;
4981 }
4982 }
4983 if (obj6) {
4984 {
4985 arg7 = (bool)(SWIG_As_bool(obj6));
4986 if (SWIG_arg_fail(7)) SWIG_fail;
4987 }
4988 }
4989 {
4990 if (!wxPyCheckForApp()) SWIG_fail;
4991 PyThreadState* __tstate = wxPyBeginAllowThreads();
4992 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4993
4994 wxPyEndAllowThreads(__tstate);
4995 if (PyErr_Occurred()) SWIG_fail;
4996 }
4997 {
4998 #if wxUSE_UNICODE
4999 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5000 #else
5001 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5002 #endif
5003 }
5004 {
5005 if (temp1)
5006 delete arg1;
5007 }
5008 {
5009 if (temp2)
5010 delete arg2;
5011 }
5012 {
5013 if (temp3)
5014 delete arg3;
5015 }
5016 return resultobj;
5017 fail:
5018 {
5019 if (temp1)
5020 delete arg1;
5021 }
5022 {
5023 if (temp2)
5024 delete arg2;
5025 }
5026 {
5027 if (temp3)
5028 delete arg3;
5029 }
5030 return NULL;
5031 }
5032
5033
5034 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5035 PyObject *resultobj;
5036 wxString *arg1 = 0 ;
5037 wxString const &arg2_defvalue = wxPyEmptyString ;
5038 wxString *arg2 = (wxString *) &arg2_defvalue ;
5039 wxString const &arg3_defvalue = wxPyEmptyString ;
5040 wxString *arg3 = (wxString *) &arg3_defvalue ;
5041 wxWindow *arg4 = (wxWindow *) NULL ;
5042 wxString result;
5043 bool temp1 = false ;
5044 bool temp2 = false ;
5045 bool temp3 = false ;
5046 PyObject * obj0 = 0 ;
5047 PyObject * obj1 = 0 ;
5048 PyObject * obj2 = 0 ;
5049 PyObject * obj3 = 0 ;
5050 char *kwnames[] = {
5051 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5052 };
5053
5054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5055 {
5056 arg1 = wxString_in_helper(obj0);
5057 if (arg1 == NULL) SWIG_fail;
5058 temp1 = true;
5059 }
5060 if (obj1) {
5061 {
5062 arg2 = wxString_in_helper(obj1);
5063 if (arg2 == NULL) SWIG_fail;
5064 temp2 = true;
5065 }
5066 }
5067 if (obj2) {
5068 {
5069 arg3 = wxString_in_helper(obj2);
5070 if (arg3 == NULL) SWIG_fail;
5071 temp3 = true;
5072 }
5073 }
5074 if (obj3) {
5075 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5076 if (SWIG_arg_fail(4)) SWIG_fail;
5077 }
5078 {
5079 if (!wxPyCheckForApp()) SWIG_fail;
5080 PyThreadState* __tstate = wxPyBeginAllowThreads();
5081 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5082
5083 wxPyEndAllowThreads(__tstate);
5084 if (PyErr_Occurred()) SWIG_fail;
5085 }
5086 {
5087 #if wxUSE_UNICODE
5088 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5089 #else
5090 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5091 #endif
5092 }
5093 {
5094 if (temp1)
5095 delete arg1;
5096 }
5097 {
5098 if (temp2)
5099 delete arg2;
5100 }
5101 {
5102 if (temp3)
5103 delete arg3;
5104 }
5105 return resultobj;
5106 fail:
5107 {
5108 if (temp1)
5109 delete arg1;
5110 }
5111 {
5112 if (temp2)
5113 delete arg2;
5114 }
5115 {
5116 if (temp3)
5117 delete arg3;
5118 }
5119 return NULL;
5120 }
5121
5122
5123 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5124 PyObject *resultobj;
5125 wxString *arg1 = 0 ;
5126 wxString *arg2 = 0 ;
5127 int arg3 ;
5128 wxString *arg4 = (wxString *) 0 ;
5129 wxWindow *arg5 = (wxWindow *) NULL ;
5130 int arg6 = (int) -1 ;
5131 int arg7 = (int) -1 ;
5132 bool arg8 = (bool) true ;
5133 int arg9 = (int) 150 ;
5134 int arg10 = (int) 200 ;
5135 wxString result;
5136 bool temp1 = false ;
5137 bool temp2 = false ;
5138 PyObject * obj0 = 0 ;
5139 PyObject * obj1 = 0 ;
5140 PyObject * obj2 = 0 ;
5141 PyObject * obj3 = 0 ;
5142 PyObject * obj4 = 0 ;
5143 PyObject * obj5 = 0 ;
5144 PyObject * obj6 = 0 ;
5145 PyObject * obj7 = 0 ;
5146 PyObject * obj8 = 0 ;
5147 char *kwnames[] = {
5148 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5149 };
5150
5151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5152 {
5153 arg1 = wxString_in_helper(obj0);
5154 if (arg1 == NULL) SWIG_fail;
5155 temp1 = true;
5156 }
5157 {
5158 arg2 = wxString_in_helper(obj1);
5159 if (arg2 == NULL) SWIG_fail;
5160 temp2 = true;
5161 }
5162 {
5163 arg3 = PyList_Size(obj2);
5164 arg4 = wxString_LIST_helper(obj2);
5165 if (arg4 == NULL) SWIG_fail;
5166 }
5167 if (obj3) {
5168 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5169 if (SWIG_arg_fail(5)) SWIG_fail;
5170 }
5171 if (obj4) {
5172 {
5173 arg6 = (int)(SWIG_As_int(obj4));
5174 if (SWIG_arg_fail(6)) SWIG_fail;
5175 }
5176 }
5177 if (obj5) {
5178 {
5179 arg7 = (int)(SWIG_As_int(obj5));
5180 if (SWIG_arg_fail(7)) SWIG_fail;
5181 }
5182 }
5183 if (obj6) {
5184 {
5185 arg8 = (bool)(SWIG_As_bool(obj6));
5186 if (SWIG_arg_fail(8)) SWIG_fail;
5187 }
5188 }
5189 if (obj7) {
5190 {
5191 arg9 = (int)(SWIG_As_int(obj7));
5192 if (SWIG_arg_fail(9)) SWIG_fail;
5193 }
5194 }
5195 if (obj8) {
5196 {
5197 arg10 = (int)(SWIG_As_int(obj8));
5198 if (SWIG_arg_fail(10)) SWIG_fail;
5199 }
5200 }
5201 {
5202 if (!wxPyCheckForApp()) SWIG_fail;
5203 PyThreadState* __tstate = wxPyBeginAllowThreads();
5204 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5205
5206 wxPyEndAllowThreads(__tstate);
5207 if (PyErr_Occurred()) SWIG_fail;
5208 }
5209 {
5210 #if wxUSE_UNICODE
5211 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5212 #else
5213 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5214 #endif
5215 }
5216 {
5217 if (temp1)
5218 delete arg1;
5219 }
5220 {
5221 if (temp2)
5222 delete arg2;
5223 }
5224 {
5225 if (arg4) delete [] arg4;
5226 }
5227 return resultobj;
5228 fail:
5229 {
5230 if (temp1)
5231 delete arg1;
5232 }
5233 {
5234 if (temp2)
5235 delete arg2;
5236 }
5237 {
5238 if (arg4) delete [] arg4;
5239 }
5240 return NULL;
5241 }
5242
5243
5244 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5245 PyObject *resultobj;
5246 wxString *arg1 = 0 ;
5247 wxString *arg2 = 0 ;
5248 int arg3 ;
5249 wxString *arg4 = (wxString *) 0 ;
5250 wxWindow *arg5 = (wxWindow *) NULL ;
5251 int arg6 = (int) -1 ;
5252 int arg7 = (int) -1 ;
5253 bool arg8 = (bool) true ;
5254 int arg9 = (int) 150 ;
5255 int arg10 = (int) 200 ;
5256 int result;
5257 bool temp1 = false ;
5258 bool temp2 = false ;
5259 PyObject * obj0 = 0 ;
5260 PyObject * obj1 = 0 ;
5261 PyObject * obj2 = 0 ;
5262 PyObject * obj3 = 0 ;
5263 PyObject * obj4 = 0 ;
5264 PyObject * obj5 = 0 ;
5265 PyObject * obj6 = 0 ;
5266 PyObject * obj7 = 0 ;
5267 PyObject * obj8 = 0 ;
5268 char *kwnames[] = {
5269 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5270 };
5271
5272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5273 {
5274 arg1 = wxString_in_helper(obj0);
5275 if (arg1 == NULL) SWIG_fail;
5276 temp1 = true;
5277 }
5278 {
5279 arg2 = wxString_in_helper(obj1);
5280 if (arg2 == NULL) SWIG_fail;
5281 temp2 = true;
5282 }
5283 {
5284 arg3 = PyList_Size(obj2);
5285 arg4 = wxString_LIST_helper(obj2);
5286 if (arg4 == NULL) SWIG_fail;
5287 }
5288 if (obj3) {
5289 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5290 if (SWIG_arg_fail(5)) SWIG_fail;
5291 }
5292 if (obj4) {
5293 {
5294 arg6 = (int)(SWIG_As_int(obj4));
5295 if (SWIG_arg_fail(6)) SWIG_fail;
5296 }
5297 }
5298 if (obj5) {
5299 {
5300 arg7 = (int)(SWIG_As_int(obj5));
5301 if (SWIG_arg_fail(7)) SWIG_fail;
5302 }
5303 }
5304 if (obj6) {
5305 {
5306 arg8 = (bool)(SWIG_As_bool(obj6));
5307 if (SWIG_arg_fail(8)) SWIG_fail;
5308 }
5309 }
5310 if (obj7) {
5311 {
5312 arg9 = (int)(SWIG_As_int(obj7));
5313 if (SWIG_arg_fail(9)) SWIG_fail;
5314 }
5315 }
5316 if (obj8) {
5317 {
5318 arg10 = (int)(SWIG_As_int(obj8));
5319 if (SWIG_arg_fail(10)) SWIG_fail;
5320 }
5321 }
5322 {
5323 if (!wxPyCheckForApp()) SWIG_fail;
5324 PyThreadState* __tstate = wxPyBeginAllowThreads();
5325 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5326
5327 wxPyEndAllowThreads(__tstate);
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 {
5331 resultobj = SWIG_From_int((int)(result));
5332 }
5333 {
5334 if (temp1)
5335 delete arg1;
5336 }
5337 {
5338 if (temp2)
5339 delete arg2;
5340 }
5341 {
5342 if (arg4) delete [] arg4;
5343 }
5344 return resultobj;
5345 fail:
5346 {
5347 if (temp1)
5348 delete arg1;
5349 }
5350 {
5351 if (temp2)
5352 delete arg2;
5353 }
5354 {
5355 if (arg4) delete [] arg4;
5356 }
5357 return NULL;
5358 }
5359
5360
5361 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5362 PyObject *resultobj;
5363 wxString *arg1 = 0 ;
5364 wxString const &arg2_defvalue = wxPyEmptyString ;
5365 wxString *arg2 = (wxString *) &arg2_defvalue ;
5366 int arg3 = (int) wxOK|wxCENTRE ;
5367 wxWindow *arg4 = (wxWindow *) NULL ;
5368 int arg5 = (int) -1 ;
5369 int arg6 = (int) -1 ;
5370 int result;
5371 bool temp1 = false ;
5372 bool temp2 = false ;
5373 PyObject * obj0 = 0 ;
5374 PyObject * obj1 = 0 ;
5375 PyObject * obj2 = 0 ;
5376 PyObject * obj3 = 0 ;
5377 PyObject * obj4 = 0 ;
5378 PyObject * obj5 = 0 ;
5379 char *kwnames[] = {
5380 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5381 };
5382
5383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5384 {
5385 arg1 = wxString_in_helper(obj0);
5386 if (arg1 == NULL) SWIG_fail;
5387 temp1 = true;
5388 }
5389 if (obj1) {
5390 {
5391 arg2 = wxString_in_helper(obj1);
5392 if (arg2 == NULL) SWIG_fail;
5393 temp2 = true;
5394 }
5395 }
5396 if (obj2) {
5397 {
5398 arg3 = (int)(SWIG_As_int(obj2));
5399 if (SWIG_arg_fail(3)) SWIG_fail;
5400 }
5401 }
5402 if (obj3) {
5403 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5404 if (SWIG_arg_fail(4)) SWIG_fail;
5405 }
5406 if (obj4) {
5407 {
5408 arg5 = (int)(SWIG_As_int(obj4));
5409 if (SWIG_arg_fail(5)) SWIG_fail;
5410 }
5411 }
5412 if (obj5) {
5413 {
5414 arg6 = (int)(SWIG_As_int(obj5));
5415 if (SWIG_arg_fail(6)) SWIG_fail;
5416 }
5417 }
5418 {
5419 if (!wxPyCheckForApp()) SWIG_fail;
5420 PyThreadState* __tstate = wxPyBeginAllowThreads();
5421 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5422
5423 wxPyEndAllowThreads(__tstate);
5424 if (PyErr_Occurred()) SWIG_fail;
5425 }
5426 {
5427 resultobj = SWIG_From_int((int)(result));
5428 }
5429 {
5430 if (temp1)
5431 delete arg1;
5432 }
5433 {
5434 if (temp2)
5435 delete arg2;
5436 }
5437 return resultobj;
5438 fail:
5439 {
5440 if (temp1)
5441 delete arg1;
5442 }
5443 {
5444 if (temp2)
5445 delete arg2;
5446 }
5447 return NULL;
5448 }
5449
5450
5451 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5452 PyObject *resultobj;
5453 wxString *arg1 = 0 ;
5454 wxString *arg2 = 0 ;
5455 wxString *arg3 = 0 ;
5456 long arg4 ;
5457 long arg5 = (long) 0 ;
5458 long arg6 = (long) 100 ;
5459 wxWindow *arg7 = (wxWindow *) NULL ;
5460 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5461 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5462 long result;
5463 bool temp1 = false ;
5464 bool temp2 = false ;
5465 bool temp3 = false ;
5466 wxPoint temp8 ;
5467 PyObject * obj0 = 0 ;
5468 PyObject * obj1 = 0 ;
5469 PyObject * obj2 = 0 ;
5470 PyObject * obj3 = 0 ;
5471 PyObject * obj4 = 0 ;
5472 PyObject * obj5 = 0 ;
5473 PyObject * obj6 = 0 ;
5474 PyObject * obj7 = 0 ;
5475 char *kwnames[] = {
5476 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5477 };
5478
5479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5480 {
5481 arg1 = wxString_in_helper(obj0);
5482 if (arg1 == NULL) SWIG_fail;
5483 temp1 = true;
5484 }
5485 {
5486 arg2 = wxString_in_helper(obj1);
5487 if (arg2 == NULL) SWIG_fail;
5488 temp2 = true;
5489 }
5490 {
5491 arg3 = wxString_in_helper(obj2);
5492 if (arg3 == NULL) SWIG_fail;
5493 temp3 = true;
5494 }
5495 {
5496 arg4 = (long)(SWIG_As_long(obj3));
5497 if (SWIG_arg_fail(4)) SWIG_fail;
5498 }
5499 if (obj4) {
5500 {
5501 arg5 = (long)(SWIG_As_long(obj4));
5502 if (SWIG_arg_fail(5)) SWIG_fail;
5503 }
5504 }
5505 if (obj5) {
5506 {
5507 arg6 = (long)(SWIG_As_long(obj5));
5508 if (SWIG_arg_fail(6)) SWIG_fail;
5509 }
5510 }
5511 if (obj6) {
5512 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5513 if (SWIG_arg_fail(7)) SWIG_fail;
5514 }
5515 if (obj7) {
5516 {
5517 arg8 = &temp8;
5518 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5519 }
5520 }
5521 {
5522 if (!wxPyCheckForApp()) SWIG_fail;
5523 PyThreadState* __tstate = wxPyBeginAllowThreads();
5524 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5525
5526 wxPyEndAllowThreads(__tstate);
5527 if (PyErr_Occurred()) SWIG_fail;
5528 }
5529 {
5530 resultobj = SWIG_From_long((long)(result));
5531 }
5532 {
5533 if (temp1)
5534 delete arg1;
5535 }
5536 {
5537 if (temp2)
5538 delete arg2;
5539 }
5540 {
5541 if (temp3)
5542 delete arg3;
5543 }
5544 return resultobj;
5545 fail:
5546 {
5547 if (temp1)
5548 delete arg1;
5549 }
5550 {
5551 if (temp2)
5552 delete arg2;
5553 }
5554 {
5555 if (temp3)
5556 delete arg3;
5557 }
5558 return NULL;
5559 }
5560
5561
5562 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5563 PyObject *resultobj;
5564 bool result;
5565 char *kwnames[] = {
5566 NULL
5567 };
5568
5569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5570 {
5571 if (!wxPyCheckForApp()) SWIG_fail;
5572 PyThreadState* __tstate = wxPyBeginAllowThreads();
5573 result = (bool)wxColourDisplay();
5574
5575 wxPyEndAllowThreads(__tstate);
5576 if (PyErr_Occurred()) SWIG_fail;
5577 }
5578 {
5579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5580 }
5581 return resultobj;
5582 fail:
5583 return NULL;
5584 }
5585
5586
5587 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5588 PyObject *resultobj;
5589 int result;
5590 char *kwnames[] = {
5591 NULL
5592 };
5593
5594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5595 {
5596 if (!wxPyCheckForApp()) SWIG_fail;
5597 PyThreadState* __tstate = wxPyBeginAllowThreads();
5598 result = (int)wxDisplayDepth();
5599
5600 wxPyEndAllowThreads(__tstate);
5601 if (PyErr_Occurred()) SWIG_fail;
5602 }
5603 {
5604 resultobj = SWIG_From_int((int)(result));
5605 }
5606 return resultobj;
5607 fail:
5608 return NULL;
5609 }
5610
5611
5612 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5613 PyObject *resultobj;
5614 int result;
5615 char *kwnames[] = {
5616 NULL
5617 };
5618
5619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5620 {
5621 if (!wxPyCheckForApp()) SWIG_fail;
5622 PyThreadState* __tstate = wxPyBeginAllowThreads();
5623 result = (int)wxGetDisplayDepth();
5624
5625 wxPyEndAllowThreads(__tstate);
5626 if (PyErr_Occurred()) SWIG_fail;
5627 }
5628 {
5629 resultobj = SWIG_From_int((int)(result));
5630 }
5631 return resultobj;
5632 fail:
5633 return NULL;
5634 }
5635
5636
5637 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5638 PyObject *resultobj;
5639 int *arg1 = (int *) 0 ;
5640 int *arg2 = (int *) 0 ;
5641 int temp1 ;
5642 int res1 = 0 ;
5643 int temp2 ;
5644 int res2 = 0 ;
5645 char *kwnames[] = {
5646 NULL
5647 };
5648
5649 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5650 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5652 {
5653 if (!wxPyCheckForApp()) SWIG_fail;
5654 PyThreadState* __tstate = wxPyBeginAllowThreads();
5655 wxDisplaySize(arg1,arg2);
5656
5657 wxPyEndAllowThreads(__tstate);
5658 if (PyErr_Occurred()) SWIG_fail;
5659 }
5660 Py_INCREF(Py_None); resultobj = Py_None;
5661 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5662 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5663 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5664 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5665 return resultobj;
5666 fail:
5667 return NULL;
5668 }
5669
5670
5671 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5672 PyObject *resultobj;
5673 wxSize result;
5674 char *kwnames[] = {
5675 NULL
5676 };
5677
5678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5679 {
5680 if (!wxPyCheckForApp()) SWIG_fail;
5681 PyThreadState* __tstate = wxPyBeginAllowThreads();
5682 result = wxGetDisplaySize();
5683
5684 wxPyEndAllowThreads(__tstate);
5685 if (PyErr_Occurred()) SWIG_fail;
5686 }
5687 {
5688 wxSize * resultptr;
5689 resultptr = new wxSize((wxSize &)(result));
5690 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5691 }
5692 return resultobj;
5693 fail:
5694 return NULL;
5695 }
5696
5697
5698 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5699 PyObject *resultobj;
5700 int *arg1 = (int *) 0 ;
5701 int *arg2 = (int *) 0 ;
5702 int temp1 ;
5703 int res1 = 0 ;
5704 int temp2 ;
5705 int res2 = 0 ;
5706 char *kwnames[] = {
5707 NULL
5708 };
5709
5710 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5711 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5713 {
5714 if (!wxPyCheckForApp()) SWIG_fail;
5715 PyThreadState* __tstate = wxPyBeginAllowThreads();
5716 wxDisplaySizeMM(arg1,arg2);
5717
5718 wxPyEndAllowThreads(__tstate);
5719 if (PyErr_Occurred()) SWIG_fail;
5720 }
5721 Py_INCREF(Py_None); resultobj = Py_None;
5722 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5723 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5724 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5725 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5726 return resultobj;
5727 fail:
5728 return NULL;
5729 }
5730
5731
5732 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5733 PyObject *resultobj;
5734 wxSize result;
5735 char *kwnames[] = {
5736 NULL
5737 };
5738
5739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5740 {
5741 if (!wxPyCheckForApp()) SWIG_fail;
5742 PyThreadState* __tstate = wxPyBeginAllowThreads();
5743 result = wxGetDisplaySizeMM();
5744
5745 wxPyEndAllowThreads(__tstate);
5746 if (PyErr_Occurred()) SWIG_fail;
5747 }
5748 {
5749 wxSize * resultptr;
5750 resultptr = new wxSize((wxSize &)(result));
5751 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5752 }
5753 return resultobj;
5754 fail:
5755 return NULL;
5756 }
5757
5758
5759 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5760 PyObject *resultobj;
5761 int *arg1 = (int *) 0 ;
5762 int *arg2 = (int *) 0 ;
5763 int *arg3 = (int *) 0 ;
5764 int *arg4 = (int *) 0 ;
5765 int temp1 ;
5766 int res1 = 0 ;
5767 int temp2 ;
5768 int res2 = 0 ;
5769 int temp3 ;
5770 int res3 = 0 ;
5771 int temp4 ;
5772 int res4 = 0 ;
5773 char *kwnames[] = {
5774 NULL
5775 };
5776
5777 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5778 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5779 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5780 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5782 {
5783 if (!wxPyCheckForApp()) SWIG_fail;
5784 PyThreadState* __tstate = wxPyBeginAllowThreads();
5785 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5786
5787 wxPyEndAllowThreads(__tstate);
5788 if (PyErr_Occurred()) SWIG_fail;
5789 }
5790 Py_INCREF(Py_None); resultobj = Py_None;
5791 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5792 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5793 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5794 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5795 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5796 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5797 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5798 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5799 return resultobj;
5800 fail:
5801 return NULL;
5802 }
5803
5804
5805 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5806 PyObject *resultobj;
5807 wxRect result;
5808 char *kwnames[] = {
5809 NULL
5810 };
5811
5812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5813 {
5814 if (!wxPyCheckForApp()) SWIG_fail;
5815 PyThreadState* __tstate = wxPyBeginAllowThreads();
5816 result = wxGetClientDisplayRect();
5817
5818 wxPyEndAllowThreads(__tstate);
5819 if (PyErr_Occurred()) SWIG_fail;
5820 }
5821 {
5822 wxRect * resultptr;
5823 resultptr = new wxRect((wxRect &)(result));
5824 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5825 }
5826 return resultobj;
5827 fail:
5828 return NULL;
5829 }
5830
5831
5832 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5833 PyObject *resultobj;
5834 wxCursor *arg1 = 0 ;
5835 PyObject * obj0 = 0 ;
5836 char *kwnames[] = {
5837 (char *) "cursor", NULL
5838 };
5839
5840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5841 {
5842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5843 if (SWIG_arg_fail(1)) SWIG_fail;
5844 if (arg1 == NULL) {
5845 SWIG_null_ref("wxCursor");
5846 }
5847 if (SWIG_arg_fail(1)) SWIG_fail;
5848 }
5849 {
5850 if (!wxPyCheckForApp()) SWIG_fail;
5851 PyThreadState* __tstate = wxPyBeginAllowThreads();
5852 wxSetCursor(*arg1);
5853
5854 wxPyEndAllowThreads(__tstate);
5855 if (PyErr_Occurred()) SWIG_fail;
5856 }
5857 Py_INCREF(Py_None); resultobj = Py_None;
5858 return resultobj;
5859 fail:
5860 return NULL;
5861 }
5862
5863
5864 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5865 PyObject *resultobj;
5866 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5867 PyObject * obj0 = 0 ;
5868 char *kwnames[] = {
5869 (char *) "cursor", NULL
5870 };
5871
5872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5873 if (obj0) {
5874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5875 if (SWIG_arg_fail(1)) SWIG_fail;
5876 }
5877 {
5878 if (!wxPyCheckForApp()) SWIG_fail;
5879 PyThreadState* __tstate = wxPyBeginAllowThreads();
5880 wxBeginBusyCursor(arg1);
5881
5882 wxPyEndAllowThreads(__tstate);
5883 if (PyErr_Occurred()) SWIG_fail;
5884 }
5885 Py_INCREF(Py_None); resultobj = Py_None;
5886 return resultobj;
5887 fail:
5888 return NULL;
5889 }
5890
5891
5892 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5893 PyObject *resultobj;
5894 wxWindow *result;
5895 char *kwnames[] = {
5896 NULL
5897 };
5898
5899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5900 {
5901 if (!wxPyCheckForApp()) SWIG_fail;
5902 PyThreadState* __tstate = wxPyBeginAllowThreads();
5903 result = (wxWindow *)wxGetActiveWindow();
5904
5905 wxPyEndAllowThreads(__tstate);
5906 if (PyErr_Occurred()) SWIG_fail;
5907 }
5908 {
5909 resultobj = wxPyMake_wxObject(result, 0);
5910 }
5911 return resultobj;
5912 fail:
5913 return NULL;
5914 }
5915
5916
5917 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5918 PyObject *resultobj;
5919 wxPoint *arg1 = 0 ;
5920 wxWindow *result;
5921 wxPoint temp1 ;
5922 PyObject * obj0 = 0 ;
5923 char *kwnames[] = {
5924 (char *) "pt", NULL
5925 };
5926
5927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5928 {
5929 arg1 = &temp1;
5930 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5931 }
5932 {
5933 if (!wxPyCheckForApp()) SWIG_fail;
5934 PyThreadState* __tstate = wxPyBeginAllowThreads();
5935 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5936
5937 wxPyEndAllowThreads(__tstate);
5938 if (PyErr_Occurred()) SWIG_fail;
5939 }
5940 {
5941 resultobj = wxPyMake_wxObject(result, 0);
5942 }
5943 return resultobj;
5944 fail:
5945 return NULL;
5946 }
5947
5948
5949 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5950 PyObject *resultobj;
5951 wxPoint *arg1 = 0 ;
5952 wxWindow *result;
5953 wxPoint temp1 ;
5954 PyObject * obj0 = 0 ;
5955 char *kwnames[] = {
5956 (char *) "pt", NULL
5957 };
5958
5959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5960 {
5961 arg1 = &temp1;
5962 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5963 }
5964 {
5965 if (!wxPyCheckForApp()) SWIG_fail;
5966 PyThreadState* __tstate = wxPyBeginAllowThreads();
5967 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5968
5969 wxPyEndAllowThreads(__tstate);
5970 if (PyErr_Occurred()) SWIG_fail;
5971 }
5972 {
5973 resultobj = wxPyMake_wxObject(result, 0);
5974 }
5975 return resultobj;
5976 fail:
5977 return NULL;
5978 }
5979
5980
5981 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5982 PyObject *resultobj;
5983 wxWindow *arg1 = (wxWindow *) 0 ;
5984 wxWindow *result;
5985 PyObject * obj0 = 0 ;
5986 char *kwnames[] = {
5987 (char *) "win", NULL
5988 };
5989
5990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5992 if (SWIG_arg_fail(1)) SWIG_fail;
5993 {
5994 if (!wxPyCheckForApp()) SWIG_fail;
5995 PyThreadState* __tstate = wxPyBeginAllowThreads();
5996 result = (wxWindow *)wxGetTopLevelParent(arg1);
5997
5998 wxPyEndAllowThreads(__tstate);
5999 if (PyErr_Occurred()) SWIG_fail;
6000 }
6001 {
6002 resultobj = wxPyMake_wxObject(result, 0);
6003 }
6004 return resultobj;
6005 fail:
6006 return NULL;
6007 }
6008
6009
6010 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6011 PyObject *resultobj;
6012 wxKeyCode arg1 ;
6013 bool result;
6014 PyObject * obj0 = 0 ;
6015 char *kwnames[] = {
6016 (char *) "key", NULL
6017 };
6018
6019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6020 {
6021 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6022 if (SWIG_arg_fail(1)) SWIG_fail;
6023 }
6024 {
6025 if (!wxPyCheckForApp()) SWIG_fail;
6026 PyThreadState* __tstate = wxPyBeginAllowThreads();
6027 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6028
6029 wxPyEndAllowThreads(__tstate);
6030 if (PyErr_Occurred()) SWIG_fail;
6031 }
6032 {
6033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6034 }
6035 return resultobj;
6036 fail:
6037 return NULL;
6038 }
6039
6040
6041 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6042 PyObject *resultobj;
6043 char *kwnames[] = {
6044 NULL
6045 };
6046
6047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6048 {
6049 if (!wxPyCheckForApp()) SWIG_fail;
6050 PyThreadState* __tstate = wxPyBeginAllowThreads();
6051 wxWakeUpMainThread();
6052
6053 wxPyEndAllowThreads(__tstate);
6054 if (PyErr_Occurred()) SWIG_fail;
6055 }
6056 Py_INCREF(Py_None); resultobj = Py_None;
6057 return resultobj;
6058 fail:
6059 return NULL;
6060 }
6061
6062
6063 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6064 PyObject *resultobj;
6065 char *kwnames[] = {
6066 NULL
6067 };
6068
6069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6070 {
6071 if (!wxPyCheckForApp()) SWIG_fail;
6072 PyThreadState* __tstate = wxPyBeginAllowThreads();
6073 wxMutexGuiEnter();
6074
6075 wxPyEndAllowThreads(__tstate);
6076 if (PyErr_Occurred()) SWIG_fail;
6077 }
6078 Py_INCREF(Py_None); resultobj = Py_None;
6079 return resultobj;
6080 fail:
6081 return NULL;
6082 }
6083
6084
6085 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6086 PyObject *resultobj;
6087 char *kwnames[] = {
6088 NULL
6089 };
6090
6091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6092 {
6093 if (!wxPyCheckForApp()) SWIG_fail;
6094 PyThreadState* __tstate = wxPyBeginAllowThreads();
6095 wxMutexGuiLeave();
6096
6097 wxPyEndAllowThreads(__tstate);
6098 if (PyErr_Occurred()) SWIG_fail;
6099 }
6100 Py_INCREF(Py_None); resultobj = Py_None;
6101 return resultobj;
6102 fail:
6103 return NULL;
6104 }
6105
6106
6107 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6108 PyObject *resultobj;
6109 wxMutexGuiLocker *result;
6110 char *kwnames[] = {
6111 NULL
6112 };
6113
6114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6115 {
6116 if (!wxPyCheckForApp()) SWIG_fail;
6117 PyThreadState* __tstate = wxPyBeginAllowThreads();
6118 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6119
6120 wxPyEndAllowThreads(__tstate);
6121 if (PyErr_Occurred()) SWIG_fail;
6122 }
6123 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6124 return resultobj;
6125 fail:
6126 return NULL;
6127 }
6128
6129
6130 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6131 PyObject *resultobj;
6132 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6133 PyObject * obj0 = 0 ;
6134 char *kwnames[] = {
6135 (char *) "self", NULL
6136 };
6137
6138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6140 if (SWIG_arg_fail(1)) SWIG_fail;
6141 {
6142 PyThreadState* __tstate = wxPyBeginAllowThreads();
6143 delete arg1;
6144
6145 wxPyEndAllowThreads(__tstate);
6146 if (PyErr_Occurred()) SWIG_fail;
6147 }
6148 Py_INCREF(Py_None); resultobj = Py_None;
6149 return resultobj;
6150 fail:
6151 return NULL;
6152 }
6153
6154
6155 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6156 PyObject *obj;
6157 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6158 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6159 Py_INCREF(obj);
6160 return Py_BuildValue((char *)"");
6161 }
6162 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6163 PyObject *resultobj;
6164 bool result;
6165 char *kwnames[] = {
6166 NULL
6167 };
6168
6169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6170 {
6171 PyThreadState* __tstate = wxPyBeginAllowThreads();
6172 result = (bool)wxThread_IsMain();
6173
6174 wxPyEndAllowThreads(__tstate);
6175 if (PyErr_Occurred()) SWIG_fail;
6176 }
6177 {
6178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6179 }
6180 return resultobj;
6181 fail:
6182 return NULL;
6183 }
6184
6185
6186 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6187 PyObject *resultobj;
6188 wxString *arg1 = 0 ;
6189 wxToolTip *result;
6190 bool temp1 = false ;
6191 PyObject * obj0 = 0 ;
6192 char *kwnames[] = {
6193 (char *) "tip", NULL
6194 };
6195
6196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6197 {
6198 arg1 = wxString_in_helper(obj0);
6199 if (arg1 == NULL) SWIG_fail;
6200 temp1 = true;
6201 }
6202 {
6203 if (!wxPyCheckForApp()) SWIG_fail;
6204 PyThreadState* __tstate = wxPyBeginAllowThreads();
6205 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6206
6207 wxPyEndAllowThreads(__tstate);
6208 if (PyErr_Occurred()) SWIG_fail;
6209 }
6210 {
6211 resultobj = wxPyMake_wxObject(result, 1);
6212 }
6213 {
6214 if (temp1)
6215 delete arg1;
6216 }
6217 return resultobj;
6218 fail:
6219 {
6220 if (temp1)
6221 delete arg1;
6222 }
6223 return NULL;
6224 }
6225
6226
6227 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6228 PyObject *resultobj;
6229 wxToolTip *arg1 = (wxToolTip *) 0 ;
6230 wxString *arg2 = 0 ;
6231 bool temp2 = false ;
6232 PyObject * obj0 = 0 ;
6233 PyObject * obj1 = 0 ;
6234 char *kwnames[] = {
6235 (char *) "self",(char *) "tip", NULL
6236 };
6237
6238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6240 if (SWIG_arg_fail(1)) SWIG_fail;
6241 {
6242 arg2 = wxString_in_helper(obj1);
6243 if (arg2 == NULL) SWIG_fail;
6244 temp2 = true;
6245 }
6246 {
6247 PyThreadState* __tstate = wxPyBeginAllowThreads();
6248 (arg1)->SetTip((wxString const &)*arg2);
6249
6250 wxPyEndAllowThreads(__tstate);
6251 if (PyErr_Occurred()) SWIG_fail;
6252 }
6253 Py_INCREF(Py_None); resultobj = Py_None;
6254 {
6255 if (temp2)
6256 delete arg2;
6257 }
6258 return resultobj;
6259 fail:
6260 {
6261 if (temp2)
6262 delete arg2;
6263 }
6264 return NULL;
6265 }
6266
6267
6268 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6269 PyObject *resultobj;
6270 wxToolTip *arg1 = (wxToolTip *) 0 ;
6271 wxString result;
6272 PyObject * obj0 = 0 ;
6273 char *kwnames[] = {
6274 (char *) "self", NULL
6275 };
6276
6277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6279 if (SWIG_arg_fail(1)) SWIG_fail;
6280 {
6281 PyThreadState* __tstate = wxPyBeginAllowThreads();
6282 result = (arg1)->GetTip();
6283
6284 wxPyEndAllowThreads(__tstate);
6285 if (PyErr_Occurred()) SWIG_fail;
6286 }
6287 {
6288 #if wxUSE_UNICODE
6289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6290 #else
6291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6292 #endif
6293 }
6294 return resultobj;
6295 fail:
6296 return NULL;
6297 }
6298
6299
6300 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6301 PyObject *resultobj;
6302 wxToolTip *arg1 = (wxToolTip *) 0 ;
6303 wxWindow *result;
6304 PyObject * obj0 = 0 ;
6305 char *kwnames[] = {
6306 (char *) "self", NULL
6307 };
6308
6309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6311 if (SWIG_arg_fail(1)) SWIG_fail;
6312 {
6313 PyThreadState* __tstate = wxPyBeginAllowThreads();
6314 result = (wxWindow *)(arg1)->GetWindow();
6315
6316 wxPyEndAllowThreads(__tstate);
6317 if (PyErr_Occurred()) SWIG_fail;
6318 }
6319 {
6320 resultobj = wxPyMake_wxObject(result, 0);
6321 }
6322 return resultobj;
6323 fail:
6324 return NULL;
6325 }
6326
6327
6328 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6329 PyObject *resultobj;
6330 bool arg1 ;
6331 PyObject * obj0 = 0 ;
6332 char *kwnames[] = {
6333 (char *) "flag", NULL
6334 };
6335
6336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6337 {
6338 arg1 = (bool)(SWIG_As_bool(obj0));
6339 if (SWIG_arg_fail(1)) SWIG_fail;
6340 }
6341 {
6342 PyThreadState* __tstate = wxPyBeginAllowThreads();
6343 wxToolTip::Enable(arg1);
6344
6345 wxPyEndAllowThreads(__tstate);
6346 if (PyErr_Occurred()) SWIG_fail;
6347 }
6348 Py_INCREF(Py_None); resultobj = Py_None;
6349 return resultobj;
6350 fail:
6351 return NULL;
6352 }
6353
6354
6355 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6356 PyObject *resultobj;
6357 long arg1 ;
6358 PyObject * obj0 = 0 ;
6359 char *kwnames[] = {
6360 (char *) "milliseconds", NULL
6361 };
6362
6363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6364 {
6365 arg1 = (long)(SWIG_As_long(obj0));
6366 if (SWIG_arg_fail(1)) SWIG_fail;
6367 }
6368 {
6369 PyThreadState* __tstate = wxPyBeginAllowThreads();
6370 wxToolTip::SetDelay(arg1);
6371
6372 wxPyEndAllowThreads(__tstate);
6373 if (PyErr_Occurred()) SWIG_fail;
6374 }
6375 Py_INCREF(Py_None); resultobj = Py_None;
6376 return resultobj;
6377 fail:
6378 return NULL;
6379 }
6380
6381
6382 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6383 PyObject *obj;
6384 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6385 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6386 Py_INCREF(obj);
6387 return Py_BuildValue((char *)"");
6388 }
6389 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6390 PyObject *resultobj;
6391 wxWindow *arg1 = (wxWindow *) 0 ;
6392 wxSize *arg2 = 0 ;
6393 wxCaret *result;
6394 wxSize temp2 ;
6395 PyObject * obj0 = 0 ;
6396 PyObject * obj1 = 0 ;
6397 char *kwnames[] = {
6398 (char *) "window",(char *) "size", NULL
6399 };
6400
6401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6403 if (SWIG_arg_fail(1)) SWIG_fail;
6404 {
6405 arg2 = &temp2;
6406 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6407 }
6408 {
6409 if (!wxPyCheckForApp()) SWIG_fail;
6410 PyThreadState* __tstate = wxPyBeginAllowThreads();
6411 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6412
6413 wxPyEndAllowThreads(__tstate);
6414 if (PyErr_Occurred()) SWIG_fail;
6415 }
6416 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6417 return resultobj;
6418 fail:
6419 return NULL;
6420 }
6421
6422
6423 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6424 PyObject *resultobj;
6425 wxCaret *arg1 = (wxCaret *) 0 ;
6426 PyObject * obj0 = 0 ;
6427 char *kwnames[] = {
6428 (char *) "self", NULL
6429 };
6430
6431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6433 if (SWIG_arg_fail(1)) SWIG_fail;
6434 {
6435 PyThreadState* __tstate = wxPyBeginAllowThreads();
6436 wxCaret_Destroy(arg1);
6437
6438 wxPyEndAllowThreads(__tstate);
6439 if (PyErr_Occurred()) SWIG_fail;
6440 }
6441 Py_INCREF(Py_None); resultobj = Py_None;
6442 return resultobj;
6443 fail:
6444 return NULL;
6445 }
6446
6447
6448 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6449 PyObject *resultobj;
6450 wxCaret *arg1 = (wxCaret *) 0 ;
6451 bool result;
6452 PyObject * obj0 = 0 ;
6453 char *kwnames[] = {
6454 (char *) "self", NULL
6455 };
6456
6457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6459 if (SWIG_arg_fail(1)) SWIG_fail;
6460 {
6461 PyThreadState* __tstate = wxPyBeginAllowThreads();
6462 result = (bool)(arg1)->IsOk();
6463
6464 wxPyEndAllowThreads(__tstate);
6465 if (PyErr_Occurred()) SWIG_fail;
6466 }
6467 {
6468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6469 }
6470 return resultobj;
6471 fail:
6472 return NULL;
6473 }
6474
6475
6476 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6477 PyObject *resultobj;
6478 wxCaret *arg1 = (wxCaret *) 0 ;
6479 bool result;
6480 PyObject * obj0 = 0 ;
6481 char *kwnames[] = {
6482 (char *) "self", NULL
6483 };
6484
6485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6487 if (SWIG_arg_fail(1)) SWIG_fail;
6488 {
6489 PyThreadState* __tstate = wxPyBeginAllowThreads();
6490 result = (bool)(arg1)->IsVisible();
6491
6492 wxPyEndAllowThreads(__tstate);
6493 if (PyErr_Occurred()) SWIG_fail;
6494 }
6495 {
6496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6497 }
6498 return resultobj;
6499 fail:
6500 return NULL;
6501 }
6502
6503
6504 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6505 PyObject *resultobj;
6506 wxCaret *arg1 = (wxCaret *) 0 ;
6507 wxPoint result;
6508 PyObject * obj0 = 0 ;
6509 char *kwnames[] = {
6510 (char *) "self", NULL
6511 };
6512
6513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6515 if (SWIG_arg_fail(1)) SWIG_fail;
6516 {
6517 PyThreadState* __tstate = wxPyBeginAllowThreads();
6518 result = (arg1)->GetPosition();
6519
6520 wxPyEndAllowThreads(__tstate);
6521 if (PyErr_Occurred()) SWIG_fail;
6522 }
6523 {
6524 wxPoint * resultptr;
6525 resultptr = new wxPoint((wxPoint &)(result));
6526 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6527 }
6528 return resultobj;
6529 fail:
6530 return NULL;
6531 }
6532
6533
6534 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6535 PyObject *resultobj;
6536 wxCaret *arg1 = (wxCaret *) 0 ;
6537 int *arg2 = (int *) 0 ;
6538 int *arg3 = (int *) 0 ;
6539 int temp2 ;
6540 int res2 = 0 ;
6541 int temp3 ;
6542 int res3 = 0 ;
6543 PyObject * obj0 = 0 ;
6544 char *kwnames[] = {
6545 (char *) "self", NULL
6546 };
6547
6548 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6549 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6552 if (SWIG_arg_fail(1)) SWIG_fail;
6553 {
6554 PyThreadState* __tstate = wxPyBeginAllowThreads();
6555 (arg1)->GetPosition(arg2,arg3);
6556
6557 wxPyEndAllowThreads(__tstate);
6558 if (PyErr_Occurred()) SWIG_fail;
6559 }
6560 Py_INCREF(Py_None); resultobj = Py_None;
6561 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6562 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6563 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6564 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6565 return resultobj;
6566 fail:
6567 return NULL;
6568 }
6569
6570
6571 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6572 PyObject *resultobj;
6573 wxCaret *arg1 = (wxCaret *) 0 ;
6574 wxSize result;
6575 PyObject * obj0 = 0 ;
6576 char *kwnames[] = {
6577 (char *) "self", NULL
6578 };
6579
6580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6582 if (SWIG_arg_fail(1)) SWIG_fail;
6583 {
6584 PyThreadState* __tstate = wxPyBeginAllowThreads();
6585 result = (arg1)->GetSize();
6586
6587 wxPyEndAllowThreads(__tstate);
6588 if (PyErr_Occurred()) SWIG_fail;
6589 }
6590 {
6591 wxSize * resultptr;
6592 resultptr = new wxSize((wxSize &)(result));
6593 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6594 }
6595 return resultobj;
6596 fail:
6597 return NULL;
6598 }
6599
6600
6601 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6602 PyObject *resultobj;
6603 wxCaret *arg1 = (wxCaret *) 0 ;
6604 int *arg2 = (int *) 0 ;
6605 int *arg3 = (int *) 0 ;
6606 int temp2 ;
6607 int res2 = 0 ;
6608 int temp3 ;
6609 int res3 = 0 ;
6610 PyObject * obj0 = 0 ;
6611 char *kwnames[] = {
6612 (char *) "self", NULL
6613 };
6614
6615 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6616 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6619 if (SWIG_arg_fail(1)) SWIG_fail;
6620 {
6621 PyThreadState* __tstate = wxPyBeginAllowThreads();
6622 (arg1)->GetSize(arg2,arg3);
6623
6624 wxPyEndAllowThreads(__tstate);
6625 if (PyErr_Occurred()) SWIG_fail;
6626 }
6627 Py_INCREF(Py_None); resultobj = Py_None;
6628 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6629 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6630 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6631 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6632 return resultobj;
6633 fail:
6634 return NULL;
6635 }
6636
6637
6638 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6639 PyObject *resultobj;
6640 wxCaret *arg1 = (wxCaret *) 0 ;
6641 wxWindow *result;
6642 PyObject * obj0 = 0 ;
6643 char *kwnames[] = {
6644 (char *) "self", NULL
6645 };
6646
6647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6649 if (SWIG_arg_fail(1)) SWIG_fail;
6650 {
6651 PyThreadState* __tstate = wxPyBeginAllowThreads();
6652 result = (wxWindow *)(arg1)->GetWindow();
6653
6654 wxPyEndAllowThreads(__tstate);
6655 if (PyErr_Occurred()) SWIG_fail;
6656 }
6657 {
6658 resultobj = wxPyMake_wxObject(result, 0);
6659 }
6660 return resultobj;
6661 fail:
6662 return NULL;
6663 }
6664
6665
6666 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6667 PyObject *resultobj;
6668 wxCaret *arg1 = (wxCaret *) 0 ;
6669 int arg2 ;
6670 int arg3 ;
6671 PyObject * obj0 = 0 ;
6672 PyObject * obj1 = 0 ;
6673 PyObject * obj2 = 0 ;
6674 char *kwnames[] = {
6675 (char *) "self",(char *) "x",(char *) "y", NULL
6676 };
6677
6678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6680 if (SWIG_arg_fail(1)) SWIG_fail;
6681 {
6682 arg2 = (int)(SWIG_As_int(obj1));
6683 if (SWIG_arg_fail(2)) SWIG_fail;
6684 }
6685 {
6686 arg3 = (int)(SWIG_As_int(obj2));
6687 if (SWIG_arg_fail(3)) SWIG_fail;
6688 }
6689 {
6690 PyThreadState* __tstate = wxPyBeginAllowThreads();
6691 (arg1)->Move(arg2,arg3);
6692
6693 wxPyEndAllowThreads(__tstate);
6694 if (PyErr_Occurred()) SWIG_fail;
6695 }
6696 Py_INCREF(Py_None); resultobj = Py_None;
6697 return resultobj;
6698 fail:
6699 return NULL;
6700 }
6701
6702
6703 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6704 PyObject *resultobj;
6705 wxCaret *arg1 = (wxCaret *) 0 ;
6706 wxPoint *arg2 = 0 ;
6707 wxPoint temp2 ;
6708 PyObject * obj0 = 0 ;
6709 PyObject * obj1 = 0 ;
6710 char *kwnames[] = {
6711 (char *) "self",(char *) "pt", NULL
6712 };
6713
6714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6716 if (SWIG_arg_fail(1)) SWIG_fail;
6717 {
6718 arg2 = &temp2;
6719 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6720 }
6721 {
6722 PyThreadState* __tstate = wxPyBeginAllowThreads();
6723 (arg1)->Move((wxPoint const &)*arg2);
6724
6725 wxPyEndAllowThreads(__tstate);
6726 if (PyErr_Occurred()) SWIG_fail;
6727 }
6728 Py_INCREF(Py_None); resultobj = Py_None;
6729 return resultobj;
6730 fail:
6731 return NULL;
6732 }
6733
6734
6735 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6736 PyObject *resultobj;
6737 wxCaret *arg1 = (wxCaret *) 0 ;
6738 int arg2 ;
6739 int arg3 ;
6740 PyObject * obj0 = 0 ;
6741 PyObject * obj1 = 0 ;
6742 PyObject * obj2 = 0 ;
6743 char *kwnames[] = {
6744 (char *) "self",(char *) "width",(char *) "height", NULL
6745 };
6746
6747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6749 if (SWIG_arg_fail(1)) SWIG_fail;
6750 {
6751 arg2 = (int)(SWIG_As_int(obj1));
6752 if (SWIG_arg_fail(2)) SWIG_fail;
6753 }
6754 {
6755 arg3 = (int)(SWIG_As_int(obj2));
6756 if (SWIG_arg_fail(3)) SWIG_fail;
6757 }
6758 {
6759 PyThreadState* __tstate = wxPyBeginAllowThreads();
6760 (arg1)->SetSize(arg2,arg3);
6761
6762 wxPyEndAllowThreads(__tstate);
6763 if (PyErr_Occurred()) SWIG_fail;
6764 }
6765 Py_INCREF(Py_None); resultobj = Py_None;
6766 return resultobj;
6767 fail:
6768 return NULL;
6769 }
6770
6771
6772 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6773 PyObject *resultobj;
6774 wxCaret *arg1 = (wxCaret *) 0 ;
6775 wxSize *arg2 = 0 ;
6776 wxSize temp2 ;
6777 PyObject * obj0 = 0 ;
6778 PyObject * obj1 = 0 ;
6779 char *kwnames[] = {
6780 (char *) "self",(char *) "size", NULL
6781 };
6782
6783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6785 if (SWIG_arg_fail(1)) SWIG_fail;
6786 {
6787 arg2 = &temp2;
6788 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6789 }
6790 {
6791 PyThreadState* __tstate = wxPyBeginAllowThreads();
6792 (arg1)->SetSize((wxSize const &)*arg2);
6793
6794 wxPyEndAllowThreads(__tstate);
6795 if (PyErr_Occurred()) SWIG_fail;
6796 }
6797 Py_INCREF(Py_None); resultobj = Py_None;
6798 return resultobj;
6799 fail:
6800 return NULL;
6801 }
6802
6803
6804 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6805 PyObject *resultobj;
6806 wxCaret *arg1 = (wxCaret *) 0 ;
6807 int arg2 = (int) true ;
6808 PyObject * obj0 = 0 ;
6809 PyObject * obj1 = 0 ;
6810 char *kwnames[] = {
6811 (char *) "self",(char *) "show", NULL
6812 };
6813
6814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6816 if (SWIG_arg_fail(1)) SWIG_fail;
6817 if (obj1) {
6818 {
6819 arg2 = (int)(SWIG_As_int(obj1));
6820 if (SWIG_arg_fail(2)) SWIG_fail;
6821 }
6822 }
6823 {
6824 PyThreadState* __tstate = wxPyBeginAllowThreads();
6825 (arg1)->Show(arg2);
6826
6827 wxPyEndAllowThreads(__tstate);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 Py_INCREF(Py_None); resultobj = Py_None;
6831 return resultobj;
6832 fail:
6833 return NULL;
6834 }
6835
6836
6837 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6838 PyObject *resultobj;
6839 wxCaret *arg1 = (wxCaret *) 0 ;
6840 PyObject * obj0 = 0 ;
6841 char *kwnames[] = {
6842 (char *) "self", NULL
6843 };
6844
6845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6847 if (SWIG_arg_fail(1)) SWIG_fail;
6848 {
6849 PyThreadState* __tstate = wxPyBeginAllowThreads();
6850 (arg1)->Hide();
6851
6852 wxPyEndAllowThreads(__tstate);
6853 if (PyErr_Occurred()) SWIG_fail;
6854 }
6855 Py_INCREF(Py_None); resultobj = Py_None;
6856 return resultobj;
6857 fail:
6858 return NULL;
6859 }
6860
6861
6862 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6863 PyObject *resultobj;
6864 int result;
6865 char *kwnames[] = {
6866 NULL
6867 };
6868
6869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6870 {
6871 PyThreadState* __tstate = wxPyBeginAllowThreads();
6872 result = (int)wxCaret::GetBlinkTime();
6873
6874 wxPyEndAllowThreads(__tstate);
6875 if (PyErr_Occurred()) SWIG_fail;
6876 }
6877 {
6878 resultobj = SWIG_From_int((int)(result));
6879 }
6880 return resultobj;
6881 fail:
6882 return NULL;
6883 }
6884
6885
6886 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6887 PyObject *resultobj;
6888 int arg1 ;
6889 PyObject * obj0 = 0 ;
6890 char *kwnames[] = {
6891 (char *) "milliseconds", NULL
6892 };
6893
6894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6895 {
6896 arg1 = (int)(SWIG_As_int(obj0));
6897 if (SWIG_arg_fail(1)) SWIG_fail;
6898 }
6899 {
6900 PyThreadState* __tstate = wxPyBeginAllowThreads();
6901 wxCaret::SetBlinkTime(arg1);
6902
6903 wxPyEndAllowThreads(__tstate);
6904 if (PyErr_Occurred()) SWIG_fail;
6905 }
6906 Py_INCREF(Py_None); resultobj = Py_None;
6907 return resultobj;
6908 fail:
6909 return NULL;
6910 }
6911
6912
6913 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6914 PyObject *obj;
6915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6916 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6917 Py_INCREF(obj);
6918 return Py_BuildValue((char *)"");
6919 }
6920 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6921 PyObject *resultobj;
6922 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6923 wxBusyCursor *result;
6924 PyObject * obj0 = 0 ;
6925 char *kwnames[] = {
6926 (char *) "cursor", NULL
6927 };
6928
6929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6930 if (obj0) {
6931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6932 if (SWIG_arg_fail(1)) SWIG_fail;
6933 }
6934 {
6935 if (!wxPyCheckForApp()) SWIG_fail;
6936 PyThreadState* __tstate = wxPyBeginAllowThreads();
6937 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6938
6939 wxPyEndAllowThreads(__tstate);
6940 if (PyErr_Occurred()) SWIG_fail;
6941 }
6942 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6943 return resultobj;
6944 fail:
6945 return NULL;
6946 }
6947
6948
6949 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6950 PyObject *resultobj;
6951 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6952 PyObject * obj0 = 0 ;
6953 char *kwnames[] = {
6954 (char *) "self", NULL
6955 };
6956
6957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6959 if (SWIG_arg_fail(1)) SWIG_fail;
6960 {
6961 PyThreadState* __tstate = wxPyBeginAllowThreads();
6962 delete arg1;
6963
6964 wxPyEndAllowThreads(__tstate);
6965 if (PyErr_Occurred()) SWIG_fail;
6966 }
6967 Py_INCREF(Py_None); resultobj = Py_None;
6968 return resultobj;
6969 fail:
6970 return NULL;
6971 }
6972
6973
6974 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6975 PyObject *obj;
6976 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6977 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6978 Py_INCREF(obj);
6979 return Py_BuildValue((char *)"");
6980 }
6981 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6982 PyObject *resultobj;
6983 wxWindow *arg1 = (wxWindow *) NULL ;
6984 wxWindowDisabler *result;
6985 PyObject * obj0 = 0 ;
6986 char *kwnames[] = {
6987 (char *) "winToSkip", NULL
6988 };
6989
6990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6991 if (obj0) {
6992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6993 if (SWIG_arg_fail(1)) SWIG_fail;
6994 }
6995 {
6996 if (!wxPyCheckForApp()) SWIG_fail;
6997 PyThreadState* __tstate = wxPyBeginAllowThreads();
6998 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6999
7000 wxPyEndAllowThreads(__tstate);
7001 if (PyErr_Occurred()) SWIG_fail;
7002 }
7003 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7004 return resultobj;
7005 fail:
7006 return NULL;
7007 }
7008
7009
7010 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7011 PyObject *resultobj;
7012 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7013 PyObject * obj0 = 0 ;
7014 char *kwnames[] = {
7015 (char *) "self", NULL
7016 };
7017
7018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7020 if (SWIG_arg_fail(1)) SWIG_fail;
7021 {
7022 PyThreadState* __tstate = wxPyBeginAllowThreads();
7023 delete arg1;
7024
7025 wxPyEndAllowThreads(__tstate);
7026 if (PyErr_Occurred()) SWIG_fail;
7027 }
7028 Py_INCREF(Py_None); resultobj = Py_None;
7029 return resultobj;
7030 fail:
7031 return NULL;
7032 }
7033
7034
7035 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7036 PyObject *obj;
7037 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7038 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7039 Py_INCREF(obj);
7040 return Py_BuildValue((char *)"");
7041 }
7042 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7043 PyObject *resultobj;
7044 wxString *arg1 = 0 ;
7045 wxBusyInfo *result;
7046 bool temp1 = false ;
7047 PyObject * obj0 = 0 ;
7048 char *kwnames[] = {
7049 (char *) "message", NULL
7050 };
7051
7052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7053 {
7054 arg1 = wxString_in_helper(obj0);
7055 if (arg1 == NULL) SWIG_fail;
7056 temp1 = true;
7057 }
7058 {
7059 if (!wxPyCheckForApp()) SWIG_fail;
7060 PyThreadState* __tstate = wxPyBeginAllowThreads();
7061 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7062
7063 wxPyEndAllowThreads(__tstate);
7064 if (PyErr_Occurred()) SWIG_fail;
7065 }
7066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7067 {
7068 if (temp1)
7069 delete arg1;
7070 }
7071 return resultobj;
7072 fail:
7073 {
7074 if (temp1)
7075 delete arg1;
7076 }
7077 return NULL;
7078 }
7079
7080
7081 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7082 PyObject *resultobj;
7083 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7084 PyObject * obj0 = 0 ;
7085 char *kwnames[] = {
7086 (char *) "self", NULL
7087 };
7088
7089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7091 if (SWIG_arg_fail(1)) SWIG_fail;
7092 {
7093 PyThreadState* __tstate = wxPyBeginAllowThreads();
7094 delete arg1;
7095
7096 wxPyEndAllowThreads(__tstate);
7097 if (PyErr_Occurred()) SWIG_fail;
7098 }
7099 Py_INCREF(Py_None); resultobj = Py_None;
7100 return resultobj;
7101 fail:
7102 return NULL;
7103 }
7104
7105
7106 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7107 PyObject *obj;
7108 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7109 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7110 Py_INCREF(obj);
7111 return Py_BuildValue((char *)"");
7112 }
7113 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7114 PyObject *resultobj;
7115 wxStopWatch *result;
7116 char *kwnames[] = {
7117 NULL
7118 };
7119
7120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7121 {
7122 PyThreadState* __tstate = wxPyBeginAllowThreads();
7123 result = (wxStopWatch *)new wxStopWatch();
7124
7125 wxPyEndAllowThreads(__tstate);
7126 if (PyErr_Occurred()) SWIG_fail;
7127 }
7128 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7129 return resultobj;
7130 fail:
7131 return NULL;
7132 }
7133
7134
7135 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7136 PyObject *resultobj;
7137 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7138 long arg2 = (long) 0 ;
7139 PyObject * obj0 = 0 ;
7140 PyObject * obj1 = 0 ;
7141 char *kwnames[] = {
7142 (char *) "self",(char *) "t0", NULL
7143 };
7144
7145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7147 if (SWIG_arg_fail(1)) SWIG_fail;
7148 if (obj1) {
7149 {
7150 arg2 = (long)(SWIG_As_long(obj1));
7151 if (SWIG_arg_fail(2)) SWIG_fail;
7152 }
7153 }
7154 {
7155 PyThreadState* __tstate = wxPyBeginAllowThreads();
7156 (arg1)->Start(arg2);
7157
7158 wxPyEndAllowThreads(__tstate);
7159 if (PyErr_Occurred()) SWIG_fail;
7160 }
7161 Py_INCREF(Py_None); resultobj = Py_None;
7162 return resultobj;
7163 fail:
7164 return NULL;
7165 }
7166
7167
7168 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7169 PyObject *resultobj;
7170 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7171 PyObject * obj0 = 0 ;
7172 char *kwnames[] = {
7173 (char *) "self", NULL
7174 };
7175
7176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7178 if (SWIG_arg_fail(1)) SWIG_fail;
7179 {
7180 PyThreadState* __tstate = wxPyBeginAllowThreads();
7181 (arg1)->Pause();
7182
7183 wxPyEndAllowThreads(__tstate);
7184 if (PyErr_Occurred()) SWIG_fail;
7185 }
7186 Py_INCREF(Py_None); resultobj = Py_None;
7187 return resultobj;
7188 fail:
7189 return NULL;
7190 }
7191
7192
7193 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7194 PyObject *resultobj;
7195 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7196 PyObject * obj0 = 0 ;
7197 char *kwnames[] = {
7198 (char *) "self", NULL
7199 };
7200
7201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7203 if (SWIG_arg_fail(1)) SWIG_fail;
7204 {
7205 PyThreadState* __tstate = wxPyBeginAllowThreads();
7206 (arg1)->Resume();
7207
7208 wxPyEndAllowThreads(__tstate);
7209 if (PyErr_Occurred()) SWIG_fail;
7210 }
7211 Py_INCREF(Py_None); resultobj = Py_None;
7212 return resultobj;
7213 fail:
7214 return NULL;
7215 }
7216
7217
7218 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7219 PyObject *resultobj;
7220 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7221 long result;
7222 PyObject * obj0 = 0 ;
7223 char *kwnames[] = {
7224 (char *) "self", NULL
7225 };
7226
7227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7229 if (SWIG_arg_fail(1)) SWIG_fail;
7230 {
7231 PyThreadState* __tstate = wxPyBeginAllowThreads();
7232 result = (long)((wxStopWatch const *)arg1)->Time();
7233
7234 wxPyEndAllowThreads(__tstate);
7235 if (PyErr_Occurred()) SWIG_fail;
7236 }
7237 {
7238 resultobj = SWIG_From_long((long)(result));
7239 }
7240 return resultobj;
7241 fail:
7242 return NULL;
7243 }
7244
7245
7246 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7247 PyObject *obj;
7248 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7249 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7250 Py_INCREF(obj);
7251 return Py_BuildValue((char *)"");
7252 }
7253 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7254 PyObject *resultobj;
7255 int arg1 = (int) 9 ;
7256 int arg2 = (int) wxID_FILE1 ;
7257 wxFileHistory *result;
7258 PyObject * obj0 = 0 ;
7259 PyObject * obj1 = 0 ;
7260 char *kwnames[] = {
7261 (char *) "maxFiles",(char *) "idBase", NULL
7262 };
7263
7264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7265 if (obj0) {
7266 {
7267 arg1 = (int)(SWIG_As_int(obj0));
7268 if (SWIG_arg_fail(1)) SWIG_fail;
7269 }
7270 }
7271 if (obj1) {
7272 {
7273 arg2 = (int)(SWIG_As_int(obj1));
7274 if (SWIG_arg_fail(2)) SWIG_fail;
7275 }
7276 }
7277 {
7278 PyThreadState* __tstate = wxPyBeginAllowThreads();
7279 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7280
7281 wxPyEndAllowThreads(__tstate);
7282 if (PyErr_Occurred()) SWIG_fail;
7283 }
7284 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7285 return resultobj;
7286 fail:
7287 return NULL;
7288 }
7289
7290
7291 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7292 PyObject *resultobj;
7293 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7294 PyObject * obj0 = 0 ;
7295 char *kwnames[] = {
7296 (char *) "self", NULL
7297 };
7298
7299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7301 if (SWIG_arg_fail(1)) SWIG_fail;
7302 {
7303 PyThreadState* __tstate = wxPyBeginAllowThreads();
7304 delete arg1;
7305
7306 wxPyEndAllowThreads(__tstate);
7307 if (PyErr_Occurred()) SWIG_fail;
7308 }
7309 Py_INCREF(Py_None); resultobj = Py_None;
7310 return resultobj;
7311 fail:
7312 return NULL;
7313 }
7314
7315
7316 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7317 PyObject *resultobj;
7318 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7319 wxString *arg2 = 0 ;
7320 bool temp2 = false ;
7321 PyObject * obj0 = 0 ;
7322 PyObject * obj1 = 0 ;
7323 char *kwnames[] = {
7324 (char *) "self",(char *) "file", NULL
7325 };
7326
7327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7329 if (SWIG_arg_fail(1)) SWIG_fail;
7330 {
7331 arg2 = wxString_in_helper(obj1);
7332 if (arg2 == NULL) SWIG_fail;
7333 temp2 = true;
7334 }
7335 {
7336 PyThreadState* __tstate = wxPyBeginAllowThreads();
7337 (arg1)->AddFileToHistory((wxString const &)*arg2);
7338
7339 wxPyEndAllowThreads(__tstate);
7340 if (PyErr_Occurred()) SWIG_fail;
7341 }
7342 Py_INCREF(Py_None); resultobj = Py_None;
7343 {
7344 if (temp2)
7345 delete arg2;
7346 }
7347 return resultobj;
7348 fail:
7349 {
7350 if (temp2)
7351 delete arg2;
7352 }
7353 return NULL;
7354 }
7355
7356
7357 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7358 PyObject *resultobj;
7359 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7360 int arg2 ;
7361 PyObject * obj0 = 0 ;
7362 PyObject * obj1 = 0 ;
7363 char *kwnames[] = {
7364 (char *) "self",(char *) "i", NULL
7365 };
7366
7367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7369 if (SWIG_arg_fail(1)) SWIG_fail;
7370 {
7371 arg2 = (int)(SWIG_As_int(obj1));
7372 if (SWIG_arg_fail(2)) SWIG_fail;
7373 }
7374 {
7375 PyThreadState* __tstate = wxPyBeginAllowThreads();
7376 (arg1)->RemoveFileFromHistory(arg2);
7377
7378 wxPyEndAllowThreads(__tstate);
7379 if (PyErr_Occurred()) SWIG_fail;
7380 }
7381 Py_INCREF(Py_None); resultobj = Py_None;
7382 return resultobj;
7383 fail:
7384 return NULL;
7385 }
7386
7387
7388 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7389 PyObject *resultobj;
7390 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7391 int result;
7392 PyObject * obj0 = 0 ;
7393 char *kwnames[] = {
7394 (char *) "self", NULL
7395 };
7396
7397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7399 if (SWIG_arg_fail(1)) SWIG_fail;
7400 {
7401 PyThreadState* __tstate = wxPyBeginAllowThreads();
7402 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7403
7404 wxPyEndAllowThreads(__tstate);
7405 if (PyErr_Occurred()) SWIG_fail;
7406 }
7407 {
7408 resultobj = SWIG_From_int((int)(result));
7409 }
7410 return resultobj;
7411 fail:
7412 return NULL;
7413 }
7414
7415
7416 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7417 PyObject *resultobj;
7418 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7419 wxMenu *arg2 = (wxMenu *) 0 ;
7420 PyObject * obj0 = 0 ;
7421 PyObject * obj1 = 0 ;
7422 char *kwnames[] = {
7423 (char *) "self",(char *) "menu", NULL
7424 };
7425
7426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7428 if (SWIG_arg_fail(1)) SWIG_fail;
7429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7430 if (SWIG_arg_fail(2)) SWIG_fail;
7431 {
7432 PyThreadState* __tstate = wxPyBeginAllowThreads();
7433 (arg1)->UseMenu(arg2);
7434
7435 wxPyEndAllowThreads(__tstate);
7436 if (PyErr_Occurred()) SWIG_fail;
7437 }
7438 Py_INCREF(Py_None); resultobj = Py_None;
7439 return resultobj;
7440 fail:
7441 return NULL;
7442 }
7443
7444
7445 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7446 PyObject *resultobj;
7447 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7448 wxMenu *arg2 = (wxMenu *) 0 ;
7449 PyObject * obj0 = 0 ;
7450 PyObject * obj1 = 0 ;
7451 char *kwnames[] = {
7452 (char *) "self",(char *) "menu", NULL
7453 };
7454
7455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7457 if (SWIG_arg_fail(1)) SWIG_fail;
7458 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7459 if (SWIG_arg_fail(2)) SWIG_fail;
7460 {
7461 PyThreadState* __tstate = wxPyBeginAllowThreads();
7462 (arg1)->RemoveMenu(arg2);
7463
7464 wxPyEndAllowThreads(__tstate);
7465 if (PyErr_Occurred()) SWIG_fail;
7466 }
7467 Py_INCREF(Py_None); resultobj = Py_None;
7468 return resultobj;
7469 fail:
7470 return NULL;
7471 }
7472
7473
7474 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7475 PyObject *resultobj;
7476 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7477 wxConfigBase *arg2 = 0 ;
7478 PyObject * obj0 = 0 ;
7479 PyObject * obj1 = 0 ;
7480 char *kwnames[] = {
7481 (char *) "self",(char *) "config", NULL
7482 };
7483
7484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7486 if (SWIG_arg_fail(1)) SWIG_fail;
7487 {
7488 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7489 if (SWIG_arg_fail(2)) SWIG_fail;
7490 if (arg2 == NULL) {
7491 SWIG_null_ref("wxConfigBase");
7492 }
7493 if (SWIG_arg_fail(2)) SWIG_fail;
7494 }
7495 {
7496 PyThreadState* __tstate = wxPyBeginAllowThreads();
7497 (arg1)->Load(*arg2);
7498
7499 wxPyEndAllowThreads(__tstate);
7500 if (PyErr_Occurred()) SWIG_fail;
7501 }
7502 Py_INCREF(Py_None); resultobj = Py_None;
7503 return resultobj;
7504 fail:
7505 return NULL;
7506 }
7507
7508
7509 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7510 PyObject *resultobj;
7511 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7512 wxConfigBase *arg2 = 0 ;
7513 PyObject * obj0 = 0 ;
7514 PyObject * obj1 = 0 ;
7515 char *kwnames[] = {
7516 (char *) "self",(char *) "config", NULL
7517 };
7518
7519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7521 if (SWIG_arg_fail(1)) SWIG_fail;
7522 {
7523 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7524 if (SWIG_arg_fail(2)) SWIG_fail;
7525 if (arg2 == NULL) {
7526 SWIG_null_ref("wxConfigBase");
7527 }
7528 if (SWIG_arg_fail(2)) SWIG_fail;
7529 }
7530 {
7531 PyThreadState* __tstate = wxPyBeginAllowThreads();
7532 (arg1)->Save(*arg2);
7533
7534 wxPyEndAllowThreads(__tstate);
7535 if (PyErr_Occurred()) SWIG_fail;
7536 }
7537 Py_INCREF(Py_None); resultobj = Py_None;
7538 return resultobj;
7539 fail:
7540 return NULL;
7541 }
7542
7543
7544 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7545 PyObject *resultobj;
7546 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7547 PyObject * obj0 = 0 ;
7548 char *kwnames[] = {
7549 (char *) "self", NULL
7550 };
7551
7552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7554 if (SWIG_arg_fail(1)) SWIG_fail;
7555 {
7556 PyThreadState* __tstate = wxPyBeginAllowThreads();
7557 (arg1)->AddFilesToMenu();
7558
7559 wxPyEndAllowThreads(__tstate);
7560 if (PyErr_Occurred()) SWIG_fail;
7561 }
7562 Py_INCREF(Py_None); resultobj = Py_None;
7563 return resultobj;
7564 fail:
7565 return NULL;
7566 }
7567
7568
7569 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7570 PyObject *resultobj;
7571 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7572 wxMenu *arg2 = (wxMenu *) 0 ;
7573 PyObject * obj0 = 0 ;
7574 PyObject * obj1 = 0 ;
7575 char *kwnames[] = {
7576 (char *) "self",(char *) "menu", NULL
7577 };
7578
7579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7581 if (SWIG_arg_fail(1)) SWIG_fail;
7582 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7583 if (SWIG_arg_fail(2)) SWIG_fail;
7584 {
7585 PyThreadState* __tstate = wxPyBeginAllowThreads();
7586 (arg1)->AddFilesToMenu(arg2);
7587
7588 wxPyEndAllowThreads(__tstate);
7589 if (PyErr_Occurred()) SWIG_fail;
7590 }
7591 Py_INCREF(Py_None); resultobj = Py_None;
7592 return resultobj;
7593 fail:
7594 return NULL;
7595 }
7596
7597
7598 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7599 PyObject *resultobj;
7600 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7601 int arg2 ;
7602 wxString result;
7603 PyObject * obj0 = 0 ;
7604 PyObject * obj1 = 0 ;
7605 char *kwnames[] = {
7606 (char *) "self",(char *) "i", NULL
7607 };
7608
7609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7611 if (SWIG_arg_fail(1)) SWIG_fail;
7612 {
7613 arg2 = (int)(SWIG_As_int(obj1));
7614 if (SWIG_arg_fail(2)) SWIG_fail;
7615 }
7616 {
7617 PyThreadState* __tstate = wxPyBeginAllowThreads();
7618 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7619
7620 wxPyEndAllowThreads(__tstate);
7621 if (PyErr_Occurred()) SWIG_fail;
7622 }
7623 {
7624 #if wxUSE_UNICODE
7625 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7626 #else
7627 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7628 #endif
7629 }
7630 return resultobj;
7631 fail:
7632 return NULL;
7633 }
7634
7635
7636 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7637 PyObject *resultobj;
7638 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7639 int result;
7640 PyObject * obj0 = 0 ;
7641 char *kwnames[] = {
7642 (char *) "self", NULL
7643 };
7644
7645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7647 if (SWIG_arg_fail(1)) SWIG_fail;
7648 {
7649 PyThreadState* __tstate = wxPyBeginAllowThreads();
7650 result = (int)((wxFileHistory const *)arg1)->GetCount();
7651
7652 wxPyEndAllowThreads(__tstate);
7653 if (PyErr_Occurred()) SWIG_fail;
7654 }
7655 {
7656 resultobj = SWIG_From_int((int)(result));
7657 }
7658 return resultobj;
7659 fail:
7660 return NULL;
7661 }
7662
7663
7664 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7665 PyObject *obj;
7666 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7667 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7668 Py_INCREF(obj);
7669 return Py_BuildValue((char *)"");
7670 }
7671 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7672 PyObject *resultobj;
7673 wxString *arg1 = 0 ;
7674 wxString const &arg2_defvalue = wxPyEmptyString ;
7675 wxString *arg2 = (wxString *) &arg2_defvalue ;
7676 wxSingleInstanceChecker *result;
7677 bool temp1 = false ;
7678 bool temp2 = false ;
7679 PyObject * obj0 = 0 ;
7680 PyObject * obj1 = 0 ;
7681 char *kwnames[] = {
7682 (char *) "name",(char *) "path", NULL
7683 };
7684
7685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7686 {
7687 arg1 = wxString_in_helper(obj0);
7688 if (arg1 == NULL) SWIG_fail;
7689 temp1 = true;
7690 }
7691 if (obj1) {
7692 {
7693 arg2 = wxString_in_helper(obj1);
7694 if (arg2 == NULL) SWIG_fail;
7695 temp2 = true;
7696 }
7697 }
7698 {
7699 PyThreadState* __tstate = wxPyBeginAllowThreads();
7700 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7701
7702 wxPyEndAllowThreads(__tstate);
7703 if (PyErr_Occurred()) SWIG_fail;
7704 }
7705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7706 {
7707 if (temp1)
7708 delete arg1;
7709 }
7710 {
7711 if (temp2)
7712 delete arg2;
7713 }
7714 return resultobj;
7715 fail:
7716 {
7717 if (temp1)
7718 delete arg1;
7719 }
7720 {
7721 if (temp2)
7722 delete arg2;
7723 }
7724 return NULL;
7725 }
7726
7727
7728 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7729 PyObject *resultobj;
7730 wxSingleInstanceChecker *result;
7731 char *kwnames[] = {
7732 NULL
7733 };
7734
7735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7736 {
7737 PyThreadState* __tstate = wxPyBeginAllowThreads();
7738 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7739
7740 wxPyEndAllowThreads(__tstate);
7741 if (PyErr_Occurred()) SWIG_fail;
7742 }
7743 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7744 return resultobj;
7745 fail:
7746 return NULL;
7747 }
7748
7749
7750 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7751 PyObject *resultobj;
7752 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7753 PyObject * obj0 = 0 ;
7754 char *kwnames[] = {
7755 (char *) "self", NULL
7756 };
7757
7758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7760 if (SWIG_arg_fail(1)) SWIG_fail;
7761 {
7762 PyThreadState* __tstate = wxPyBeginAllowThreads();
7763 delete arg1;
7764
7765 wxPyEndAllowThreads(__tstate);
7766 if (PyErr_Occurred()) SWIG_fail;
7767 }
7768 Py_INCREF(Py_None); resultobj = Py_None;
7769 return resultobj;
7770 fail:
7771 return NULL;
7772 }
7773
7774
7775 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7776 PyObject *resultobj;
7777 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7778 wxString *arg2 = 0 ;
7779 wxString const &arg3_defvalue = wxPyEmptyString ;
7780 wxString *arg3 = (wxString *) &arg3_defvalue ;
7781 bool result;
7782 bool temp2 = false ;
7783 bool temp3 = false ;
7784 PyObject * obj0 = 0 ;
7785 PyObject * obj1 = 0 ;
7786 PyObject * obj2 = 0 ;
7787 char *kwnames[] = {
7788 (char *) "self",(char *) "name",(char *) "path", NULL
7789 };
7790
7791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7793 if (SWIG_arg_fail(1)) SWIG_fail;
7794 {
7795 arg2 = wxString_in_helper(obj1);
7796 if (arg2 == NULL) SWIG_fail;
7797 temp2 = true;
7798 }
7799 if (obj2) {
7800 {
7801 arg3 = wxString_in_helper(obj2);
7802 if (arg3 == NULL) SWIG_fail;
7803 temp3 = true;
7804 }
7805 }
7806 {
7807 PyThreadState* __tstate = wxPyBeginAllowThreads();
7808 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7809
7810 wxPyEndAllowThreads(__tstate);
7811 if (PyErr_Occurred()) SWIG_fail;
7812 }
7813 {
7814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7815 }
7816 {
7817 if (temp2)
7818 delete arg2;
7819 }
7820 {
7821 if (temp3)
7822 delete arg3;
7823 }
7824 return resultobj;
7825 fail:
7826 {
7827 if (temp2)
7828 delete arg2;
7829 }
7830 {
7831 if (temp3)
7832 delete arg3;
7833 }
7834 return NULL;
7835 }
7836
7837
7838 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7839 PyObject *resultobj;
7840 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7841 bool result;
7842 PyObject * obj0 = 0 ;
7843 char *kwnames[] = {
7844 (char *) "self", NULL
7845 };
7846
7847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7849 if (SWIG_arg_fail(1)) SWIG_fail;
7850 {
7851 PyThreadState* __tstate = wxPyBeginAllowThreads();
7852 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7853
7854 wxPyEndAllowThreads(__tstate);
7855 if (PyErr_Occurred()) SWIG_fail;
7856 }
7857 {
7858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7859 }
7860 return resultobj;
7861 fail:
7862 return NULL;
7863 }
7864
7865
7866 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7867 PyObject *obj;
7868 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7869 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7870 Py_INCREF(obj);
7871 return Py_BuildValue((char *)"");
7872 }
7873 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7874 PyObject *resultobj;
7875 wxWindow *arg1 = (wxWindow *) 0 ;
7876 wxDC *arg2 = 0 ;
7877 bool result;
7878 PyObject * obj0 = 0 ;
7879 PyObject * obj1 = 0 ;
7880 char *kwnames[] = {
7881 (char *) "window",(char *) "dc", NULL
7882 };
7883
7884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7886 if (SWIG_arg_fail(1)) SWIG_fail;
7887 {
7888 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7889 if (SWIG_arg_fail(2)) SWIG_fail;
7890 if (arg2 == NULL) {
7891 SWIG_null_ref("wxDC");
7892 }
7893 if (SWIG_arg_fail(2)) SWIG_fail;
7894 }
7895 {
7896 PyThreadState* __tstate = wxPyBeginAllowThreads();
7897 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7898
7899 wxPyEndAllowThreads(__tstate);
7900 if (PyErr_Occurred()) SWIG_fail;
7901 }
7902 {
7903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7904 }
7905 return resultobj;
7906 fail:
7907 return NULL;
7908 }
7909
7910
7911 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7912 PyObject *resultobj;
7913 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7914 PyObject * obj0 = 0 ;
7915 char *kwnames[] = {
7916 (char *) "self", NULL
7917 };
7918
7919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7921 if (SWIG_arg_fail(1)) SWIG_fail;
7922 {
7923 PyThreadState* __tstate = wxPyBeginAllowThreads();
7924 delete arg1;
7925
7926 wxPyEndAllowThreads(__tstate);
7927 if (PyErr_Occurred()) SWIG_fail;
7928 }
7929 Py_INCREF(Py_None); resultobj = Py_None;
7930 return resultobj;
7931 fail:
7932 return NULL;
7933 }
7934
7935
7936 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7937 PyObject *resultobj;
7938 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7939 wxString result;
7940 PyObject * obj0 = 0 ;
7941 char *kwnames[] = {
7942 (char *) "self", NULL
7943 };
7944
7945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7947 if (SWIG_arg_fail(1)) SWIG_fail;
7948 {
7949 PyThreadState* __tstate = wxPyBeginAllowThreads();
7950 result = (arg1)->GetTip();
7951
7952 wxPyEndAllowThreads(__tstate);
7953 if (PyErr_Occurred()) SWIG_fail;
7954 }
7955 {
7956 #if wxUSE_UNICODE
7957 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7958 #else
7959 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7960 #endif
7961 }
7962 return resultobj;
7963 fail:
7964 return NULL;
7965 }
7966
7967
7968 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7969 PyObject *resultobj;
7970 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7971 size_t result;
7972 PyObject * obj0 = 0 ;
7973 char *kwnames[] = {
7974 (char *) "self", NULL
7975 };
7976
7977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7979 if (SWIG_arg_fail(1)) SWIG_fail;
7980 {
7981 PyThreadState* __tstate = wxPyBeginAllowThreads();
7982 result = (size_t)(arg1)->GetCurrentTip();
7983
7984 wxPyEndAllowThreads(__tstate);
7985 if (PyErr_Occurred()) SWIG_fail;
7986 }
7987 {
7988 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7989 }
7990 return resultobj;
7991 fail:
7992 return NULL;
7993 }
7994
7995
7996 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7997 PyObject *resultobj;
7998 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7999 wxString *arg2 = 0 ;
8000 wxString result;
8001 bool temp2 = false ;
8002 PyObject * obj0 = 0 ;
8003 PyObject * obj1 = 0 ;
8004 char *kwnames[] = {
8005 (char *) "self",(char *) "tip", NULL
8006 };
8007
8008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8010 if (SWIG_arg_fail(1)) SWIG_fail;
8011 {
8012 arg2 = wxString_in_helper(obj1);
8013 if (arg2 == NULL) SWIG_fail;
8014 temp2 = true;
8015 }
8016 {
8017 PyThreadState* __tstate = wxPyBeginAllowThreads();
8018 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8019
8020 wxPyEndAllowThreads(__tstate);
8021 if (PyErr_Occurred()) SWIG_fail;
8022 }
8023 {
8024 #if wxUSE_UNICODE
8025 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8026 #else
8027 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8028 #endif
8029 }
8030 {
8031 if (temp2)
8032 delete arg2;
8033 }
8034 return resultobj;
8035 fail:
8036 {
8037 if (temp2)
8038 delete arg2;
8039 }
8040 return NULL;
8041 }
8042
8043
8044 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8045 PyObject *obj;
8046 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8047 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8048 Py_INCREF(obj);
8049 return Py_BuildValue((char *)"");
8050 }
8051 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8052 PyObject *resultobj;
8053 size_t arg1 ;
8054 wxPyTipProvider *result;
8055 PyObject * obj0 = 0 ;
8056 char *kwnames[] = {
8057 (char *) "currentTip", NULL
8058 };
8059
8060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8061 {
8062 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8063 if (SWIG_arg_fail(1)) SWIG_fail;
8064 }
8065 {
8066 PyThreadState* __tstate = wxPyBeginAllowThreads();
8067 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8068
8069 wxPyEndAllowThreads(__tstate);
8070 if (PyErr_Occurred()) SWIG_fail;
8071 }
8072 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8073 return resultobj;
8074 fail:
8075 return NULL;
8076 }
8077
8078
8079 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8080 PyObject *resultobj;
8081 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8082 PyObject *arg2 = (PyObject *) 0 ;
8083 PyObject *arg3 = (PyObject *) 0 ;
8084 PyObject * obj0 = 0 ;
8085 PyObject * obj1 = 0 ;
8086 PyObject * obj2 = 0 ;
8087 char *kwnames[] = {
8088 (char *) "self",(char *) "self",(char *) "_class", NULL
8089 };
8090
8091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8093 if (SWIG_arg_fail(1)) SWIG_fail;
8094 arg2 = obj1;
8095 arg3 = obj2;
8096 {
8097 PyThreadState* __tstate = wxPyBeginAllowThreads();
8098 (arg1)->_setCallbackInfo(arg2,arg3);
8099
8100 wxPyEndAllowThreads(__tstate);
8101 if (PyErr_Occurred()) SWIG_fail;
8102 }
8103 Py_INCREF(Py_None); resultobj = Py_None;
8104 return resultobj;
8105 fail:
8106 return NULL;
8107 }
8108
8109
8110 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8111 PyObject *obj;
8112 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8113 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8114 Py_INCREF(obj);
8115 return Py_BuildValue((char *)"");
8116 }
8117 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8118 PyObject *resultobj;
8119 wxWindow *arg1 = (wxWindow *) 0 ;
8120 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8121 bool arg3 = (bool) true ;
8122 bool result;
8123 PyObject * obj0 = 0 ;
8124 PyObject * obj1 = 0 ;
8125 PyObject * obj2 = 0 ;
8126 char *kwnames[] = {
8127 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8128 };
8129
8130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8132 if (SWIG_arg_fail(1)) SWIG_fail;
8133 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8134 if (SWIG_arg_fail(2)) SWIG_fail;
8135 if (obj2) {
8136 {
8137 arg3 = (bool)(SWIG_As_bool(obj2));
8138 if (SWIG_arg_fail(3)) SWIG_fail;
8139 }
8140 }
8141 {
8142 if (!wxPyCheckForApp()) SWIG_fail;
8143 PyThreadState* __tstate = wxPyBeginAllowThreads();
8144 result = (bool)wxShowTip(arg1,arg2,arg3);
8145
8146 wxPyEndAllowThreads(__tstate);
8147 if (PyErr_Occurred()) SWIG_fail;
8148 }
8149 {
8150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8151 }
8152 return resultobj;
8153 fail:
8154 return NULL;
8155 }
8156
8157
8158 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8159 PyObject *resultobj;
8160 wxString *arg1 = 0 ;
8161 size_t arg2 ;
8162 wxTipProvider *result;
8163 bool temp1 = false ;
8164 PyObject * obj0 = 0 ;
8165 PyObject * obj1 = 0 ;
8166 char *kwnames[] = {
8167 (char *) "filename",(char *) "currentTip", NULL
8168 };
8169
8170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8171 {
8172 arg1 = wxString_in_helper(obj0);
8173 if (arg1 == NULL) SWIG_fail;
8174 temp1 = true;
8175 }
8176 {
8177 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8178 if (SWIG_arg_fail(2)) SWIG_fail;
8179 }
8180 {
8181 if (!wxPyCheckForApp()) SWIG_fail;
8182 PyThreadState* __tstate = wxPyBeginAllowThreads();
8183 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8184
8185 wxPyEndAllowThreads(__tstate);
8186 if (PyErr_Occurred()) SWIG_fail;
8187 }
8188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8189 {
8190 if (temp1)
8191 delete arg1;
8192 }
8193 return resultobj;
8194 fail:
8195 {
8196 if (temp1)
8197 delete arg1;
8198 }
8199 return NULL;
8200 }
8201
8202
8203 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8204 PyObject *resultobj;
8205 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8206 int arg2 = (int) -1 ;
8207 wxPyTimer *result;
8208 PyObject * obj0 = 0 ;
8209 PyObject * obj1 = 0 ;
8210 char *kwnames[] = {
8211 (char *) "owner",(char *) "id", NULL
8212 };
8213
8214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8215 if (obj0) {
8216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8217 if (SWIG_arg_fail(1)) SWIG_fail;
8218 }
8219 if (obj1) {
8220 {
8221 arg2 = (int)(SWIG_As_int(obj1));
8222 if (SWIG_arg_fail(2)) SWIG_fail;
8223 }
8224 }
8225 {
8226 if (!wxPyCheckForApp()) SWIG_fail;
8227 PyThreadState* __tstate = wxPyBeginAllowThreads();
8228 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8229
8230 wxPyEndAllowThreads(__tstate);
8231 if (PyErr_Occurred()) SWIG_fail;
8232 }
8233 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8234 return resultobj;
8235 fail:
8236 return NULL;
8237 }
8238
8239
8240 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8241 PyObject *resultobj;
8242 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8243 PyObject * obj0 = 0 ;
8244 char *kwnames[] = {
8245 (char *) "self", NULL
8246 };
8247
8248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8250 if (SWIG_arg_fail(1)) SWIG_fail;
8251 {
8252 PyThreadState* __tstate = wxPyBeginAllowThreads();
8253 delete arg1;
8254
8255 wxPyEndAllowThreads(__tstate);
8256 if (PyErr_Occurred()) SWIG_fail;
8257 }
8258 Py_INCREF(Py_None); resultobj = Py_None;
8259 return resultobj;
8260 fail:
8261 return NULL;
8262 }
8263
8264
8265 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8266 PyObject *resultobj;
8267 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8268 PyObject *arg2 = (PyObject *) 0 ;
8269 PyObject *arg3 = (PyObject *) 0 ;
8270 int arg4 = (int) 1 ;
8271 PyObject * obj0 = 0 ;
8272 PyObject * obj1 = 0 ;
8273 PyObject * obj2 = 0 ;
8274 PyObject * obj3 = 0 ;
8275 char *kwnames[] = {
8276 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8277 };
8278
8279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8281 if (SWIG_arg_fail(1)) SWIG_fail;
8282 arg2 = obj1;
8283 arg3 = obj2;
8284 if (obj3) {
8285 {
8286 arg4 = (int)(SWIG_As_int(obj3));
8287 if (SWIG_arg_fail(4)) SWIG_fail;
8288 }
8289 }
8290 {
8291 PyThreadState* __tstate = wxPyBeginAllowThreads();
8292 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8293
8294 wxPyEndAllowThreads(__tstate);
8295 if (PyErr_Occurred()) SWIG_fail;
8296 }
8297 Py_INCREF(Py_None); resultobj = Py_None;
8298 return resultobj;
8299 fail:
8300 return NULL;
8301 }
8302
8303
8304 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8305 PyObject *resultobj;
8306 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8307 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8308 int arg3 = (int) -1 ;
8309 PyObject * obj0 = 0 ;
8310 PyObject * obj1 = 0 ;
8311 PyObject * obj2 = 0 ;
8312 char *kwnames[] = {
8313 (char *) "self",(char *) "owner",(char *) "id", NULL
8314 };
8315
8316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8318 if (SWIG_arg_fail(1)) SWIG_fail;
8319 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8320 if (SWIG_arg_fail(2)) SWIG_fail;
8321 if (obj2) {
8322 {
8323 arg3 = (int)(SWIG_As_int(obj2));
8324 if (SWIG_arg_fail(3)) SWIG_fail;
8325 }
8326 }
8327 {
8328 PyThreadState* __tstate = wxPyBeginAllowThreads();
8329 (arg1)->SetOwner(arg2,arg3);
8330
8331 wxPyEndAllowThreads(__tstate);
8332 if (PyErr_Occurred()) SWIG_fail;
8333 }
8334 Py_INCREF(Py_None); resultobj = Py_None;
8335 return resultobj;
8336 fail:
8337 return NULL;
8338 }
8339
8340
8341 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8342 PyObject *resultobj;
8343 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8344 wxEvtHandler *result;
8345 PyObject * obj0 = 0 ;
8346 char *kwnames[] = {
8347 (char *) "self", NULL
8348 };
8349
8350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8352 if (SWIG_arg_fail(1)) SWIG_fail;
8353 {
8354 PyThreadState* __tstate = wxPyBeginAllowThreads();
8355 result = (wxEvtHandler *)(arg1)->GetOwner();
8356
8357 wxPyEndAllowThreads(__tstate);
8358 if (PyErr_Occurred()) SWIG_fail;
8359 }
8360 {
8361 resultobj = wxPyMake_wxObject(result, 0);
8362 }
8363 return resultobj;
8364 fail:
8365 return NULL;
8366 }
8367
8368
8369 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8370 PyObject *resultobj;
8371 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8372 int arg2 = (int) -1 ;
8373 bool arg3 = (bool) false ;
8374 bool result;
8375 PyObject * obj0 = 0 ;
8376 PyObject * obj1 = 0 ;
8377 PyObject * obj2 = 0 ;
8378 char *kwnames[] = {
8379 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8380 };
8381
8382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8384 if (SWIG_arg_fail(1)) SWIG_fail;
8385 if (obj1) {
8386 {
8387 arg2 = (int)(SWIG_As_int(obj1));
8388 if (SWIG_arg_fail(2)) SWIG_fail;
8389 }
8390 }
8391 if (obj2) {
8392 {
8393 arg3 = (bool)(SWIG_As_bool(obj2));
8394 if (SWIG_arg_fail(3)) SWIG_fail;
8395 }
8396 }
8397 {
8398 PyThreadState* __tstate = wxPyBeginAllowThreads();
8399 result = (bool)(arg1)->Start(arg2,arg3);
8400
8401 wxPyEndAllowThreads(__tstate);
8402 if (PyErr_Occurred()) SWIG_fail;
8403 }
8404 {
8405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8406 }
8407 return resultobj;
8408 fail:
8409 return NULL;
8410 }
8411
8412
8413 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8414 PyObject *resultobj;
8415 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8416 PyObject * obj0 = 0 ;
8417 char *kwnames[] = {
8418 (char *) "self", NULL
8419 };
8420
8421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8423 if (SWIG_arg_fail(1)) SWIG_fail;
8424 {
8425 PyThreadState* __tstate = wxPyBeginAllowThreads();
8426 (arg1)->Stop();
8427
8428 wxPyEndAllowThreads(__tstate);
8429 if (PyErr_Occurred()) SWIG_fail;
8430 }
8431 Py_INCREF(Py_None); resultobj = Py_None;
8432 return resultobj;
8433 fail:
8434 return NULL;
8435 }
8436
8437
8438 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8439 PyObject *resultobj;
8440 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8441 bool result;
8442 PyObject * obj0 = 0 ;
8443 char *kwnames[] = {
8444 (char *) "self", NULL
8445 };
8446
8447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8449 if (SWIG_arg_fail(1)) SWIG_fail;
8450 {
8451 PyThreadState* __tstate = wxPyBeginAllowThreads();
8452 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8453
8454 wxPyEndAllowThreads(__tstate);
8455 if (PyErr_Occurred()) SWIG_fail;
8456 }
8457 {
8458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8459 }
8460 return resultobj;
8461 fail:
8462 return NULL;
8463 }
8464
8465
8466 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8467 PyObject *resultobj;
8468 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8469 int result;
8470 PyObject * obj0 = 0 ;
8471 char *kwnames[] = {
8472 (char *) "self", NULL
8473 };
8474
8475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8477 if (SWIG_arg_fail(1)) SWIG_fail;
8478 {
8479 PyThreadState* __tstate = wxPyBeginAllowThreads();
8480 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8481
8482 wxPyEndAllowThreads(__tstate);
8483 if (PyErr_Occurred()) SWIG_fail;
8484 }
8485 {
8486 resultobj = SWIG_From_int((int)(result));
8487 }
8488 return resultobj;
8489 fail:
8490 return NULL;
8491 }
8492
8493
8494 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8495 PyObject *resultobj;
8496 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8497 bool result;
8498 PyObject * obj0 = 0 ;
8499 char *kwnames[] = {
8500 (char *) "self", NULL
8501 };
8502
8503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8505 if (SWIG_arg_fail(1)) SWIG_fail;
8506 {
8507 PyThreadState* __tstate = wxPyBeginAllowThreads();
8508 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8509
8510 wxPyEndAllowThreads(__tstate);
8511 if (PyErr_Occurred()) SWIG_fail;
8512 }
8513 {
8514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8515 }
8516 return resultobj;
8517 fail:
8518 return NULL;
8519 }
8520
8521
8522 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8523 PyObject *resultobj;
8524 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8525 int result;
8526 PyObject * obj0 = 0 ;
8527 char *kwnames[] = {
8528 (char *) "self", NULL
8529 };
8530
8531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8533 if (SWIG_arg_fail(1)) SWIG_fail;
8534 {
8535 PyThreadState* __tstate = wxPyBeginAllowThreads();
8536 result = (int)((wxPyTimer const *)arg1)->GetId();
8537
8538 wxPyEndAllowThreads(__tstate);
8539 if (PyErr_Occurred()) SWIG_fail;
8540 }
8541 {
8542 resultobj = SWIG_From_int((int)(result));
8543 }
8544 return resultobj;
8545 fail:
8546 return NULL;
8547 }
8548
8549
8550 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8551 PyObject *obj;
8552 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8553 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8554 Py_INCREF(obj);
8555 return Py_BuildValue((char *)"");
8556 }
8557 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8558 PyObject *resultobj;
8559 int arg1 = (int) 0 ;
8560 int arg2 = (int) 0 ;
8561 wxTimerEvent *result;
8562 PyObject * obj0 = 0 ;
8563 PyObject * obj1 = 0 ;
8564 char *kwnames[] = {
8565 (char *) "timerid",(char *) "interval", NULL
8566 };
8567
8568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8569 if (obj0) {
8570 {
8571 arg1 = (int)(SWIG_As_int(obj0));
8572 if (SWIG_arg_fail(1)) SWIG_fail;
8573 }
8574 }
8575 if (obj1) {
8576 {
8577 arg2 = (int)(SWIG_As_int(obj1));
8578 if (SWIG_arg_fail(2)) SWIG_fail;
8579 }
8580 }
8581 {
8582 PyThreadState* __tstate = wxPyBeginAllowThreads();
8583 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8584
8585 wxPyEndAllowThreads(__tstate);
8586 if (PyErr_Occurred()) SWIG_fail;
8587 }
8588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8589 return resultobj;
8590 fail:
8591 return NULL;
8592 }
8593
8594
8595 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8596 PyObject *resultobj;
8597 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8598 int result;
8599 PyObject * obj0 = 0 ;
8600 char *kwnames[] = {
8601 (char *) "self", NULL
8602 };
8603
8604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8606 if (SWIG_arg_fail(1)) SWIG_fail;
8607 {
8608 PyThreadState* __tstate = wxPyBeginAllowThreads();
8609 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8610
8611 wxPyEndAllowThreads(__tstate);
8612 if (PyErr_Occurred()) SWIG_fail;
8613 }
8614 {
8615 resultobj = SWIG_From_int((int)(result));
8616 }
8617 return resultobj;
8618 fail:
8619 return NULL;
8620 }
8621
8622
8623 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8624 PyObject *obj;
8625 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8626 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8627 Py_INCREF(obj);
8628 return Py_BuildValue((char *)"");
8629 }
8630 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8631 PyObject *resultobj;
8632 wxTimer *arg1 = 0 ;
8633 wxTimerRunner *result;
8634 PyObject * obj0 = 0 ;
8635
8636 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8637 {
8638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8639 if (SWIG_arg_fail(1)) SWIG_fail;
8640 if (arg1 == NULL) {
8641 SWIG_null_ref("wxTimer");
8642 }
8643 if (SWIG_arg_fail(1)) SWIG_fail;
8644 }
8645 {
8646 if (!wxPyCheckForApp()) SWIG_fail;
8647 PyThreadState* __tstate = wxPyBeginAllowThreads();
8648 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8649
8650 wxPyEndAllowThreads(__tstate);
8651 if (PyErr_Occurred()) SWIG_fail;
8652 }
8653 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8654 return resultobj;
8655 fail:
8656 return NULL;
8657 }
8658
8659
8660 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8661 PyObject *resultobj;
8662 wxTimer *arg1 = 0 ;
8663 int arg2 ;
8664 bool arg3 = (bool) false ;
8665 wxTimerRunner *result;
8666 PyObject * obj0 = 0 ;
8667 PyObject * obj1 = 0 ;
8668 PyObject * obj2 = 0 ;
8669
8670 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8671 {
8672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8673 if (SWIG_arg_fail(1)) SWIG_fail;
8674 if (arg1 == NULL) {
8675 SWIG_null_ref("wxTimer");
8676 }
8677 if (SWIG_arg_fail(1)) SWIG_fail;
8678 }
8679 {
8680 arg2 = (int)(SWIG_As_int(obj1));
8681 if (SWIG_arg_fail(2)) SWIG_fail;
8682 }
8683 if (obj2) {
8684 {
8685 arg3 = (bool)(SWIG_As_bool(obj2));
8686 if (SWIG_arg_fail(3)) SWIG_fail;
8687 }
8688 }
8689 {
8690 if (!wxPyCheckForApp()) SWIG_fail;
8691 PyThreadState* __tstate = wxPyBeginAllowThreads();
8692 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8693
8694 wxPyEndAllowThreads(__tstate);
8695 if (PyErr_Occurred()) SWIG_fail;
8696 }
8697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8698 return resultobj;
8699 fail:
8700 return NULL;
8701 }
8702
8703
8704 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8705 int argc;
8706 PyObject *argv[4];
8707 int ii;
8708
8709 argc = PyObject_Length(args);
8710 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8711 argv[ii] = PyTuple_GetItem(args,ii);
8712 }
8713 if (argc == 1) {
8714 int _v;
8715 {
8716 void *ptr = 0;
8717 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8718 _v = 0;
8719 PyErr_Clear();
8720 } else {
8721 _v = (ptr != 0);
8722 }
8723 }
8724 if (_v) {
8725 return _wrap_new_TimerRunner__SWIG_0(self,args);
8726 }
8727 }
8728 if ((argc >= 2) && (argc <= 3)) {
8729 int _v;
8730 {
8731 void *ptr = 0;
8732 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8733 _v = 0;
8734 PyErr_Clear();
8735 } else {
8736 _v = (ptr != 0);
8737 }
8738 }
8739 if (_v) {
8740 _v = SWIG_Check_int(argv[1]);
8741 if (_v) {
8742 if (argc <= 2) {
8743 return _wrap_new_TimerRunner__SWIG_1(self,args);
8744 }
8745 _v = SWIG_Check_bool(argv[2]);
8746 if (_v) {
8747 return _wrap_new_TimerRunner__SWIG_1(self,args);
8748 }
8749 }
8750 }
8751 }
8752
8753 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8754 return NULL;
8755 }
8756
8757
8758 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8759 PyObject *resultobj;
8760 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8761 PyObject * obj0 = 0 ;
8762 char *kwnames[] = {
8763 (char *) "self", NULL
8764 };
8765
8766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8768 if (SWIG_arg_fail(1)) SWIG_fail;
8769 {
8770 PyThreadState* __tstate = wxPyBeginAllowThreads();
8771 delete arg1;
8772
8773 wxPyEndAllowThreads(__tstate);
8774 if (PyErr_Occurred()) SWIG_fail;
8775 }
8776 Py_INCREF(Py_None); resultobj = Py_None;
8777 return resultobj;
8778 fail:
8779 return NULL;
8780 }
8781
8782
8783 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8784 PyObject *resultobj;
8785 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8786 int arg2 ;
8787 bool arg3 = (bool) false ;
8788 PyObject * obj0 = 0 ;
8789 PyObject * obj1 = 0 ;
8790 PyObject * obj2 = 0 ;
8791 char *kwnames[] = {
8792 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8793 };
8794
8795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8797 if (SWIG_arg_fail(1)) SWIG_fail;
8798 {
8799 arg2 = (int)(SWIG_As_int(obj1));
8800 if (SWIG_arg_fail(2)) SWIG_fail;
8801 }
8802 if (obj2) {
8803 {
8804 arg3 = (bool)(SWIG_As_bool(obj2));
8805 if (SWIG_arg_fail(3)) SWIG_fail;
8806 }
8807 }
8808 {
8809 PyThreadState* __tstate = wxPyBeginAllowThreads();
8810 (arg1)->Start(arg2,arg3);
8811
8812 wxPyEndAllowThreads(__tstate);
8813 if (PyErr_Occurred()) SWIG_fail;
8814 }
8815 Py_INCREF(Py_None); resultobj = Py_None;
8816 return resultobj;
8817 fail:
8818 return NULL;
8819 }
8820
8821
8822 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8823 PyObject *obj;
8824 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8825 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8826 Py_INCREF(obj);
8827 return Py_BuildValue((char *)"");
8828 }
8829 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8830 PyObject *resultobj;
8831 wxLog *result;
8832 char *kwnames[] = {
8833 NULL
8834 };
8835
8836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8837 {
8838 PyThreadState* __tstate = wxPyBeginAllowThreads();
8839 result = (wxLog *)new wxLog();
8840
8841 wxPyEndAllowThreads(__tstate);
8842 if (PyErr_Occurred()) SWIG_fail;
8843 }
8844 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8845 return resultobj;
8846 fail:
8847 return NULL;
8848 }
8849
8850
8851 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8852 PyObject *resultobj;
8853 bool result;
8854 char *kwnames[] = {
8855 NULL
8856 };
8857
8858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8859 {
8860 PyThreadState* __tstate = wxPyBeginAllowThreads();
8861 result = (bool)wxLog::IsEnabled();
8862
8863 wxPyEndAllowThreads(__tstate);
8864 if (PyErr_Occurred()) SWIG_fail;
8865 }
8866 {
8867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8868 }
8869 return resultobj;
8870 fail:
8871 return NULL;
8872 }
8873
8874
8875 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8876 PyObject *resultobj;
8877 bool arg1 = (bool) true ;
8878 bool result;
8879 PyObject * obj0 = 0 ;
8880 char *kwnames[] = {
8881 (char *) "doIt", NULL
8882 };
8883
8884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8885 if (obj0) {
8886 {
8887 arg1 = (bool)(SWIG_As_bool(obj0));
8888 if (SWIG_arg_fail(1)) SWIG_fail;
8889 }
8890 }
8891 {
8892 PyThreadState* __tstate = wxPyBeginAllowThreads();
8893 result = (bool)wxLog::EnableLogging(arg1);
8894
8895 wxPyEndAllowThreads(__tstate);
8896 if (PyErr_Occurred()) SWIG_fail;
8897 }
8898 {
8899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8900 }
8901 return resultobj;
8902 fail:
8903 return NULL;
8904 }
8905
8906
8907 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8908 PyObject *resultobj;
8909 wxLogLevel arg1 ;
8910 wxChar *arg2 = (wxChar *) 0 ;
8911 time_t arg3 ;
8912 PyObject * obj0 = 0 ;
8913 PyObject * obj1 = 0 ;
8914 PyObject * obj2 = 0 ;
8915 char *kwnames[] = {
8916 (char *) "level",(char *) "szString",(char *) "t", NULL
8917 };
8918
8919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8920 {
8921 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8922 if (SWIG_arg_fail(1)) SWIG_fail;
8923 }
8924 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8925 if (SWIG_arg_fail(2)) SWIG_fail;
8926 {
8927 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8928 if (SWIG_arg_fail(3)) SWIG_fail;
8929 }
8930 {
8931 PyThreadState* __tstate = wxPyBeginAllowThreads();
8932 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8933
8934 wxPyEndAllowThreads(__tstate);
8935 if (PyErr_Occurred()) SWIG_fail;
8936 }
8937 Py_INCREF(Py_None); resultobj = Py_None;
8938 return resultobj;
8939 fail:
8940 return NULL;
8941 }
8942
8943
8944 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8945 PyObject *resultobj;
8946 wxLog *arg1 = (wxLog *) 0 ;
8947 PyObject * obj0 = 0 ;
8948 char *kwnames[] = {
8949 (char *) "self", NULL
8950 };
8951
8952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8954 if (SWIG_arg_fail(1)) SWIG_fail;
8955 {
8956 PyThreadState* __tstate = wxPyBeginAllowThreads();
8957 (arg1)->Flush();
8958
8959 wxPyEndAllowThreads(__tstate);
8960 if (PyErr_Occurred()) SWIG_fail;
8961 }
8962 Py_INCREF(Py_None); resultobj = Py_None;
8963 return resultobj;
8964 fail:
8965 return NULL;
8966 }
8967
8968
8969 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8970 PyObject *resultobj;
8971 char *kwnames[] = {
8972 NULL
8973 };
8974
8975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8976 {
8977 PyThreadState* __tstate = wxPyBeginAllowThreads();
8978 wxLog::FlushActive();
8979
8980 wxPyEndAllowThreads(__tstate);
8981 if (PyErr_Occurred()) SWIG_fail;
8982 }
8983 Py_INCREF(Py_None); resultobj = Py_None;
8984 return resultobj;
8985 fail:
8986 return NULL;
8987 }
8988
8989
8990 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8991 PyObject *resultobj;
8992 wxLog *result;
8993 char *kwnames[] = {
8994 NULL
8995 };
8996
8997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8998 {
8999 PyThreadState* __tstate = wxPyBeginAllowThreads();
9000 result = (wxLog *)wxLog::GetActiveTarget();
9001
9002 wxPyEndAllowThreads(__tstate);
9003 if (PyErr_Occurred()) SWIG_fail;
9004 }
9005 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9006 return resultobj;
9007 fail:
9008 return NULL;
9009 }
9010
9011
9012 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9013 PyObject *resultobj;
9014 wxLog *arg1 = (wxLog *) 0 ;
9015 wxLog *result;
9016 PyObject * obj0 = 0 ;
9017 char *kwnames[] = {
9018 (char *) "pLogger", NULL
9019 };
9020
9021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9023 if (SWIG_arg_fail(1)) SWIG_fail;
9024 {
9025 PyThreadState* __tstate = wxPyBeginAllowThreads();
9026 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9027
9028 wxPyEndAllowThreads(__tstate);
9029 if (PyErr_Occurred()) SWIG_fail;
9030 }
9031 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9032 return resultobj;
9033 fail:
9034 return NULL;
9035 }
9036
9037
9038 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9039 PyObject *resultobj;
9040 char *kwnames[] = {
9041 NULL
9042 };
9043
9044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9045 {
9046 PyThreadState* __tstate = wxPyBeginAllowThreads();
9047 wxLog::Suspend();
9048
9049 wxPyEndAllowThreads(__tstate);
9050 if (PyErr_Occurred()) SWIG_fail;
9051 }
9052 Py_INCREF(Py_None); resultobj = Py_None;
9053 return resultobj;
9054 fail:
9055 return NULL;
9056 }
9057
9058
9059 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9060 PyObject *resultobj;
9061 char *kwnames[] = {
9062 NULL
9063 };
9064
9065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9066 {
9067 PyThreadState* __tstate = wxPyBeginAllowThreads();
9068 wxLog::Resume();
9069
9070 wxPyEndAllowThreads(__tstate);
9071 if (PyErr_Occurred()) SWIG_fail;
9072 }
9073 Py_INCREF(Py_None); resultobj = Py_None;
9074 return resultobj;
9075 fail:
9076 return NULL;
9077 }
9078
9079
9080 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9081 PyObject *resultobj;
9082 bool arg1 = (bool) true ;
9083 PyObject * obj0 = 0 ;
9084 char *kwnames[] = {
9085 (char *) "bVerbose", NULL
9086 };
9087
9088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9089 if (obj0) {
9090 {
9091 arg1 = (bool)(SWIG_As_bool(obj0));
9092 if (SWIG_arg_fail(1)) SWIG_fail;
9093 }
9094 }
9095 {
9096 PyThreadState* __tstate = wxPyBeginAllowThreads();
9097 wxLog::SetVerbose(arg1);
9098
9099 wxPyEndAllowThreads(__tstate);
9100 if (PyErr_Occurred()) SWIG_fail;
9101 }
9102 Py_INCREF(Py_None); resultobj = Py_None;
9103 return resultobj;
9104 fail:
9105 return NULL;
9106 }
9107
9108
9109 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9110 PyObject *resultobj;
9111 wxLogLevel arg1 ;
9112 PyObject * obj0 = 0 ;
9113 char *kwnames[] = {
9114 (char *) "logLevel", NULL
9115 };
9116
9117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9118 {
9119 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9120 if (SWIG_arg_fail(1)) SWIG_fail;
9121 }
9122 {
9123 PyThreadState* __tstate = wxPyBeginAllowThreads();
9124 wxLog::SetLogLevel(arg1);
9125
9126 wxPyEndAllowThreads(__tstate);
9127 if (PyErr_Occurred()) SWIG_fail;
9128 }
9129 Py_INCREF(Py_None); resultobj = Py_None;
9130 return resultobj;
9131 fail:
9132 return NULL;
9133 }
9134
9135
9136 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9137 PyObject *resultobj;
9138 char *kwnames[] = {
9139 NULL
9140 };
9141
9142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9143 {
9144 PyThreadState* __tstate = wxPyBeginAllowThreads();
9145 wxLog::DontCreateOnDemand();
9146
9147 wxPyEndAllowThreads(__tstate);
9148 if (PyErr_Occurred()) SWIG_fail;
9149 }
9150 Py_INCREF(Py_None); resultobj = Py_None;
9151 return resultobj;
9152 fail:
9153 return NULL;
9154 }
9155
9156
9157 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9158 PyObject *resultobj;
9159 wxTraceMask arg1 ;
9160 PyObject * obj0 = 0 ;
9161 char *kwnames[] = {
9162 (char *) "ulMask", NULL
9163 };
9164
9165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9166 {
9167 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9168 if (SWIG_arg_fail(1)) SWIG_fail;
9169 }
9170 {
9171 PyThreadState* __tstate = wxPyBeginAllowThreads();
9172 wxLog::SetTraceMask(arg1);
9173
9174 wxPyEndAllowThreads(__tstate);
9175 if (PyErr_Occurred()) SWIG_fail;
9176 }
9177 Py_INCREF(Py_None); resultobj = Py_None;
9178 return resultobj;
9179 fail:
9180 return NULL;
9181 }
9182
9183
9184 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9185 PyObject *resultobj;
9186 wxString *arg1 = 0 ;
9187 bool temp1 = false ;
9188 PyObject * obj0 = 0 ;
9189 char *kwnames[] = {
9190 (char *) "str", NULL
9191 };
9192
9193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9194 {
9195 arg1 = wxString_in_helper(obj0);
9196 if (arg1 == NULL) SWIG_fail;
9197 temp1 = true;
9198 }
9199 {
9200 PyThreadState* __tstate = wxPyBeginAllowThreads();
9201 wxLog::AddTraceMask((wxString const &)*arg1);
9202
9203 wxPyEndAllowThreads(__tstate);
9204 if (PyErr_Occurred()) SWIG_fail;
9205 }
9206 Py_INCREF(Py_None); resultobj = Py_None;
9207 {
9208 if (temp1)
9209 delete arg1;
9210 }
9211 return resultobj;
9212 fail:
9213 {
9214 if (temp1)
9215 delete arg1;
9216 }
9217 return NULL;
9218 }
9219
9220
9221 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9222 PyObject *resultobj;
9223 wxString *arg1 = 0 ;
9224 bool temp1 = false ;
9225 PyObject * obj0 = 0 ;
9226 char *kwnames[] = {
9227 (char *) "str", NULL
9228 };
9229
9230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9231 {
9232 arg1 = wxString_in_helper(obj0);
9233 if (arg1 == NULL) SWIG_fail;
9234 temp1 = true;
9235 }
9236 {
9237 PyThreadState* __tstate = wxPyBeginAllowThreads();
9238 wxLog::RemoveTraceMask((wxString const &)*arg1);
9239
9240 wxPyEndAllowThreads(__tstate);
9241 if (PyErr_Occurred()) SWIG_fail;
9242 }
9243 Py_INCREF(Py_None); resultobj = Py_None;
9244 {
9245 if (temp1)
9246 delete arg1;
9247 }
9248 return resultobj;
9249 fail:
9250 {
9251 if (temp1)
9252 delete arg1;
9253 }
9254 return NULL;
9255 }
9256
9257
9258 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9259 PyObject *resultobj;
9260 char *kwnames[] = {
9261 NULL
9262 };
9263
9264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9265 {
9266 PyThreadState* __tstate = wxPyBeginAllowThreads();
9267 wxLog::ClearTraceMasks();
9268
9269 wxPyEndAllowThreads(__tstate);
9270 if (PyErr_Occurred()) SWIG_fail;
9271 }
9272 Py_INCREF(Py_None); resultobj = Py_None;
9273 return resultobj;
9274 fail:
9275 return NULL;
9276 }
9277
9278
9279 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9280 PyObject *resultobj;
9281 wxArrayString *result;
9282 char *kwnames[] = {
9283 NULL
9284 };
9285
9286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9287 {
9288 PyThreadState* __tstate = wxPyBeginAllowThreads();
9289 {
9290 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9291 result = (wxArrayString *) &_result_ref;
9292 }
9293
9294 wxPyEndAllowThreads(__tstate);
9295 if (PyErr_Occurred()) SWIG_fail;
9296 }
9297 {
9298 resultobj = wxArrayString2PyList_helper(*result);
9299 }
9300 return resultobj;
9301 fail:
9302 return NULL;
9303 }
9304
9305
9306 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9307 PyObject *resultobj;
9308 wxChar *arg1 = (wxChar *) 0 ;
9309 PyObject * obj0 = 0 ;
9310 char *kwnames[] = {
9311 (char *) "ts", NULL
9312 };
9313
9314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9316 if (SWIG_arg_fail(1)) SWIG_fail;
9317 {
9318 PyThreadState* __tstate = wxPyBeginAllowThreads();
9319 wxLog::SetTimestamp((wxChar const *)arg1);
9320
9321 wxPyEndAllowThreads(__tstate);
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 Py_INCREF(Py_None); resultobj = Py_None;
9325 return resultobj;
9326 fail:
9327 return NULL;
9328 }
9329
9330
9331 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9332 PyObject *resultobj;
9333 bool result;
9334 char *kwnames[] = {
9335 NULL
9336 };
9337
9338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9339 {
9340 PyThreadState* __tstate = wxPyBeginAllowThreads();
9341 result = (bool)wxLog::GetVerbose();
9342
9343 wxPyEndAllowThreads(__tstate);
9344 if (PyErr_Occurred()) SWIG_fail;
9345 }
9346 {
9347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9348 }
9349 return resultobj;
9350 fail:
9351 return NULL;
9352 }
9353
9354
9355 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9356 PyObject *resultobj;
9357 wxTraceMask result;
9358 char *kwnames[] = {
9359 NULL
9360 };
9361
9362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9363 {
9364 PyThreadState* __tstate = wxPyBeginAllowThreads();
9365 result = (wxTraceMask)wxLog::GetTraceMask();
9366
9367 wxPyEndAllowThreads(__tstate);
9368 if (PyErr_Occurred()) SWIG_fail;
9369 }
9370 {
9371 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9372 }
9373 return resultobj;
9374 fail:
9375 return NULL;
9376 }
9377
9378
9379 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9380 PyObject *resultobj;
9381 wxChar *arg1 = (wxChar *) 0 ;
9382 bool result;
9383 PyObject * obj0 = 0 ;
9384 char *kwnames[] = {
9385 (char *) "mask", NULL
9386 };
9387
9388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9390 if (SWIG_arg_fail(1)) SWIG_fail;
9391 {
9392 PyThreadState* __tstate = wxPyBeginAllowThreads();
9393 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9394
9395 wxPyEndAllowThreads(__tstate);
9396 if (PyErr_Occurred()) SWIG_fail;
9397 }
9398 {
9399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9400 }
9401 return resultobj;
9402 fail:
9403 return NULL;
9404 }
9405
9406
9407 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9408 PyObject *resultobj;
9409 wxLogLevel result;
9410 char *kwnames[] = {
9411 NULL
9412 };
9413
9414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9415 {
9416 PyThreadState* __tstate = wxPyBeginAllowThreads();
9417 result = (wxLogLevel)wxLog::GetLogLevel();
9418
9419 wxPyEndAllowThreads(__tstate);
9420 if (PyErr_Occurred()) SWIG_fail;
9421 }
9422 {
9423 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9424 }
9425 return resultobj;
9426 fail:
9427 return NULL;
9428 }
9429
9430
9431 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9432 PyObject *resultobj;
9433 wxChar *result;
9434 char *kwnames[] = {
9435 NULL
9436 };
9437
9438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9439 {
9440 PyThreadState* __tstate = wxPyBeginAllowThreads();
9441 result = (wxChar *)wxLog::GetTimestamp();
9442
9443 wxPyEndAllowThreads(__tstate);
9444 if (PyErr_Occurred()) SWIG_fail;
9445 }
9446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9447 return resultobj;
9448 fail:
9449 return NULL;
9450 }
9451
9452
9453 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9454 PyObject *resultobj;
9455 wxString result;
9456 char *kwnames[] = {
9457 NULL
9458 };
9459
9460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9461 {
9462 PyThreadState* __tstate = wxPyBeginAllowThreads();
9463 result = Log_TimeStamp();
9464
9465 wxPyEndAllowThreads(__tstate);
9466 if (PyErr_Occurred()) SWIG_fail;
9467 }
9468 {
9469 #if wxUSE_UNICODE
9470 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9471 #else
9472 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9473 #endif
9474 }
9475 return resultobj;
9476 fail:
9477 return NULL;
9478 }
9479
9480
9481 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9482 PyObject *resultobj;
9483 wxLog *arg1 = (wxLog *) 0 ;
9484 PyObject * obj0 = 0 ;
9485 char *kwnames[] = {
9486 (char *) "self", NULL
9487 };
9488
9489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9491 if (SWIG_arg_fail(1)) SWIG_fail;
9492 {
9493 PyThreadState* __tstate = wxPyBeginAllowThreads();
9494 wxLog_Destroy(arg1);
9495
9496 wxPyEndAllowThreads(__tstate);
9497 if (PyErr_Occurred()) SWIG_fail;
9498 }
9499 Py_INCREF(Py_None); resultobj = Py_None;
9500 return resultobj;
9501 fail:
9502 return NULL;
9503 }
9504
9505
9506 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9507 PyObject *obj;
9508 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9509 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9510 Py_INCREF(obj);
9511 return Py_BuildValue((char *)"");
9512 }
9513 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9514 PyObject *resultobj;
9515 wxLogStderr *result;
9516 char *kwnames[] = {
9517 NULL
9518 };
9519
9520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9521 {
9522 PyThreadState* __tstate = wxPyBeginAllowThreads();
9523 result = (wxLogStderr *)new wxLogStderr();
9524
9525 wxPyEndAllowThreads(__tstate);
9526 if (PyErr_Occurred()) SWIG_fail;
9527 }
9528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9529 return resultobj;
9530 fail:
9531 return NULL;
9532 }
9533
9534
9535 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9536 PyObject *obj;
9537 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9538 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9539 Py_INCREF(obj);
9540 return Py_BuildValue((char *)"");
9541 }
9542 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9543 PyObject *resultobj;
9544 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9545 wxLogTextCtrl *result;
9546 PyObject * obj0 = 0 ;
9547 char *kwnames[] = {
9548 (char *) "pTextCtrl", NULL
9549 };
9550
9551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9553 if (SWIG_arg_fail(1)) SWIG_fail;
9554 {
9555 PyThreadState* __tstate = wxPyBeginAllowThreads();
9556 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9557
9558 wxPyEndAllowThreads(__tstate);
9559 if (PyErr_Occurred()) SWIG_fail;
9560 }
9561 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9562 return resultobj;
9563 fail:
9564 return NULL;
9565 }
9566
9567
9568 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9569 PyObject *obj;
9570 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9571 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9572 Py_INCREF(obj);
9573 return Py_BuildValue((char *)"");
9574 }
9575 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9576 PyObject *resultobj;
9577 wxLogGui *result;
9578 char *kwnames[] = {
9579 NULL
9580 };
9581
9582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9583 {
9584 PyThreadState* __tstate = wxPyBeginAllowThreads();
9585 result = (wxLogGui *)new wxLogGui();
9586
9587 wxPyEndAllowThreads(__tstate);
9588 if (PyErr_Occurred()) SWIG_fail;
9589 }
9590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9591 return resultobj;
9592 fail:
9593 return NULL;
9594 }
9595
9596
9597 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9598 PyObject *obj;
9599 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9600 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9601 Py_INCREF(obj);
9602 return Py_BuildValue((char *)"");
9603 }
9604 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9605 PyObject *resultobj;
9606 wxFrame *arg1 = (wxFrame *) 0 ;
9607 wxString *arg2 = 0 ;
9608 bool arg3 = (bool) true ;
9609 bool arg4 = (bool) true ;
9610 wxLogWindow *result;
9611 bool temp2 = false ;
9612 PyObject * obj0 = 0 ;
9613 PyObject * obj1 = 0 ;
9614 PyObject * obj2 = 0 ;
9615 PyObject * obj3 = 0 ;
9616 char *kwnames[] = {
9617 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9618 };
9619
9620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9622 if (SWIG_arg_fail(1)) SWIG_fail;
9623 {
9624 arg2 = wxString_in_helper(obj1);
9625 if (arg2 == NULL) SWIG_fail;
9626 temp2 = true;
9627 }
9628 if (obj2) {
9629 {
9630 arg3 = (bool)(SWIG_As_bool(obj2));
9631 if (SWIG_arg_fail(3)) SWIG_fail;
9632 }
9633 }
9634 if (obj3) {
9635 {
9636 arg4 = (bool)(SWIG_As_bool(obj3));
9637 if (SWIG_arg_fail(4)) SWIG_fail;
9638 }
9639 }
9640 {
9641 PyThreadState* __tstate = wxPyBeginAllowThreads();
9642 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9643
9644 wxPyEndAllowThreads(__tstate);
9645 if (PyErr_Occurred()) SWIG_fail;
9646 }
9647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9648 {
9649 if (temp2)
9650 delete arg2;
9651 }
9652 return resultobj;
9653 fail:
9654 {
9655 if (temp2)
9656 delete arg2;
9657 }
9658 return NULL;
9659 }
9660
9661
9662 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9663 PyObject *resultobj;
9664 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9665 bool arg2 = (bool) true ;
9666 PyObject * obj0 = 0 ;
9667 PyObject * obj1 = 0 ;
9668 char *kwnames[] = {
9669 (char *) "self",(char *) "bShow", NULL
9670 };
9671
9672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9674 if (SWIG_arg_fail(1)) SWIG_fail;
9675 if (obj1) {
9676 {
9677 arg2 = (bool)(SWIG_As_bool(obj1));
9678 if (SWIG_arg_fail(2)) SWIG_fail;
9679 }
9680 }
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 (arg1)->Show(arg2);
9684
9685 wxPyEndAllowThreads(__tstate);
9686 if (PyErr_Occurred()) SWIG_fail;
9687 }
9688 Py_INCREF(Py_None); resultobj = Py_None;
9689 return resultobj;
9690 fail:
9691 return NULL;
9692 }
9693
9694
9695 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9696 PyObject *resultobj;
9697 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9698 wxFrame *result;
9699 PyObject * obj0 = 0 ;
9700 char *kwnames[] = {
9701 (char *) "self", NULL
9702 };
9703
9704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9706 if (SWIG_arg_fail(1)) SWIG_fail;
9707 {
9708 PyThreadState* __tstate = wxPyBeginAllowThreads();
9709 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9710
9711 wxPyEndAllowThreads(__tstate);
9712 if (PyErr_Occurred()) SWIG_fail;
9713 }
9714 {
9715 resultobj = wxPyMake_wxObject(result, 0);
9716 }
9717 return resultobj;
9718 fail:
9719 return NULL;
9720 }
9721
9722
9723 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9724 PyObject *resultobj;
9725 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9726 wxLog *result;
9727 PyObject * obj0 = 0 ;
9728 char *kwnames[] = {
9729 (char *) "self", NULL
9730 };
9731
9732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9734 if (SWIG_arg_fail(1)) SWIG_fail;
9735 {
9736 PyThreadState* __tstate = wxPyBeginAllowThreads();
9737 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9738
9739 wxPyEndAllowThreads(__tstate);
9740 if (PyErr_Occurred()) SWIG_fail;
9741 }
9742 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9743 return resultobj;
9744 fail:
9745 return NULL;
9746 }
9747
9748
9749 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9750 PyObject *resultobj;
9751 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9752 bool result;
9753 PyObject * obj0 = 0 ;
9754 char *kwnames[] = {
9755 (char *) "self", NULL
9756 };
9757
9758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9760 if (SWIG_arg_fail(1)) SWIG_fail;
9761 {
9762 PyThreadState* __tstate = wxPyBeginAllowThreads();
9763 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9764
9765 wxPyEndAllowThreads(__tstate);
9766 if (PyErr_Occurred()) SWIG_fail;
9767 }
9768 {
9769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9770 }
9771 return resultobj;
9772 fail:
9773 return NULL;
9774 }
9775
9776
9777 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9778 PyObject *resultobj;
9779 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9780 bool arg2 ;
9781 PyObject * obj0 = 0 ;
9782 PyObject * obj1 = 0 ;
9783 char *kwnames[] = {
9784 (char *) "self",(char *) "bDoPass", NULL
9785 };
9786
9787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9789 if (SWIG_arg_fail(1)) SWIG_fail;
9790 {
9791 arg2 = (bool)(SWIG_As_bool(obj1));
9792 if (SWIG_arg_fail(2)) SWIG_fail;
9793 }
9794 {
9795 PyThreadState* __tstate = wxPyBeginAllowThreads();
9796 (arg1)->PassMessages(arg2);
9797
9798 wxPyEndAllowThreads(__tstate);
9799 if (PyErr_Occurred()) SWIG_fail;
9800 }
9801 Py_INCREF(Py_None); resultobj = Py_None;
9802 return resultobj;
9803 fail:
9804 return NULL;
9805 }
9806
9807
9808 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9809 PyObject *obj;
9810 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9811 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9812 Py_INCREF(obj);
9813 return Py_BuildValue((char *)"");
9814 }
9815 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9816 PyObject *resultobj;
9817 wxLog *arg1 = (wxLog *) 0 ;
9818 wxLogChain *result;
9819 PyObject * obj0 = 0 ;
9820 char *kwnames[] = {
9821 (char *) "logger", NULL
9822 };
9823
9824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9826 if (SWIG_arg_fail(1)) SWIG_fail;
9827 {
9828 PyThreadState* __tstate = wxPyBeginAllowThreads();
9829 result = (wxLogChain *)new wxLogChain(arg1);
9830
9831 wxPyEndAllowThreads(__tstate);
9832 if (PyErr_Occurred()) SWIG_fail;
9833 }
9834 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9835 return resultobj;
9836 fail:
9837 return NULL;
9838 }
9839
9840
9841 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9842 PyObject *resultobj;
9843 wxLogChain *arg1 = (wxLogChain *) 0 ;
9844 wxLog *arg2 = (wxLog *) 0 ;
9845 PyObject * obj0 = 0 ;
9846 PyObject * obj1 = 0 ;
9847 char *kwnames[] = {
9848 (char *) "self",(char *) "logger", NULL
9849 };
9850
9851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9853 if (SWIG_arg_fail(1)) SWIG_fail;
9854 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9855 if (SWIG_arg_fail(2)) SWIG_fail;
9856 {
9857 PyThreadState* __tstate = wxPyBeginAllowThreads();
9858 (arg1)->SetLog(arg2);
9859
9860 wxPyEndAllowThreads(__tstate);
9861 if (PyErr_Occurred()) SWIG_fail;
9862 }
9863 Py_INCREF(Py_None); resultobj = Py_None;
9864 return resultobj;
9865 fail:
9866 return NULL;
9867 }
9868
9869
9870 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9871 PyObject *resultobj;
9872 wxLogChain *arg1 = (wxLogChain *) 0 ;
9873 bool arg2 ;
9874 PyObject * obj0 = 0 ;
9875 PyObject * obj1 = 0 ;
9876 char *kwnames[] = {
9877 (char *) "self",(char *) "bDoPass", NULL
9878 };
9879
9880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9882 if (SWIG_arg_fail(1)) SWIG_fail;
9883 {
9884 arg2 = (bool)(SWIG_As_bool(obj1));
9885 if (SWIG_arg_fail(2)) SWIG_fail;
9886 }
9887 {
9888 PyThreadState* __tstate = wxPyBeginAllowThreads();
9889 (arg1)->PassMessages(arg2);
9890
9891 wxPyEndAllowThreads(__tstate);
9892 if (PyErr_Occurred()) SWIG_fail;
9893 }
9894 Py_INCREF(Py_None); resultobj = Py_None;
9895 return resultobj;
9896 fail:
9897 return NULL;
9898 }
9899
9900
9901 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9902 PyObject *resultobj;
9903 wxLogChain *arg1 = (wxLogChain *) 0 ;
9904 bool result;
9905 PyObject * obj0 = 0 ;
9906 char *kwnames[] = {
9907 (char *) "self", NULL
9908 };
9909
9910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9912 if (SWIG_arg_fail(1)) SWIG_fail;
9913 {
9914 PyThreadState* __tstate = wxPyBeginAllowThreads();
9915 result = (bool)(arg1)->IsPassingMessages();
9916
9917 wxPyEndAllowThreads(__tstate);
9918 if (PyErr_Occurred()) SWIG_fail;
9919 }
9920 {
9921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9922 }
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9930 PyObject *resultobj;
9931 wxLogChain *arg1 = (wxLogChain *) 0 ;
9932 wxLog *result;
9933 PyObject * obj0 = 0 ;
9934 char *kwnames[] = {
9935 (char *) "self", NULL
9936 };
9937
9938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9940 if (SWIG_arg_fail(1)) SWIG_fail;
9941 {
9942 PyThreadState* __tstate = wxPyBeginAllowThreads();
9943 result = (wxLog *)(arg1)->GetOldLog();
9944
9945 wxPyEndAllowThreads(__tstate);
9946 if (PyErr_Occurred()) SWIG_fail;
9947 }
9948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9949 return resultobj;
9950 fail:
9951 return NULL;
9952 }
9953
9954
9955 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9956 PyObject *obj;
9957 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9958 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9959 Py_INCREF(obj);
9960 return Py_BuildValue((char *)"");
9961 }
9962 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9963 PyObject *resultobj;
9964 unsigned long result;
9965 char *kwnames[] = {
9966 NULL
9967 };
9968
9969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9970 {
9971 PyThreadState* __tstate = wxPyBeginAllowThreads();
9972 result = (unsigned long)wxSysErrorCode();
9973
9974 wxPyEndAllowThreads(__tstate);
9975 if (PyErr_Occurred()) SWIG_fail;
9976 }
9977 {
9978 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9979 }
9980 return resultobj;
9981 fail:
9982 return NULL;
9983 }
9984
9985
9986 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9987 PyObject *resultobj;
9988 unsigned long arg1 = (unsigned long) 0 ;
9989 wxString result;
9990 PyObject * obj0 = 0 ;
9991 char *kwnames[] = {
9992 (char *) "nErrCode", NULL
9993 };
9994
9995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9996 if (obj0) {
9997 {
9998 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9999 if (SWIG_arg_fail(1)) SWIG_fail;
10000 }
10001 }
10002 {
10003 PyThreadState* __tstate = wxPyBeginAllowThreads();
10004 result = wxSysErrorMsg(arg1);
10005
10006 wxPyEndAllowThreads(__tstate);
10007 if (PyErr_Occurred()) SWIG_fail;
10008 }
10009 {
10010 #if wxUSE_UNICODE
10011 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10012 #else
10013 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10014 #endif
10015 }
10016 return resultobj;
10017 fail:
10018 return NULL;
10019 }
10020
10021
10022 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10023 PyObject *resultobj;
10024 wxString *arg1 = 0 ;
10025 bool temp1 = false ;
10026 PyObject * obj0 = 0 ;
10027 char *kwnames[] = {
10028 (char *) "msg", NULL
10029 };
10030
10031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10032 {
10033 arg1 = wxString_in_helper(obj0);
10034 if (arg1 == NULL) SWIG_fail;
10035 temp1 = true;
10036 }
10037 {
10038 PyThreadState* __tstate = wxPyBeginAllowThreads();
10039 wxPyLogFatalError((wxString const &)*arg1);
10040
10041 wxPyEndAllowThreads(__tstate);
10042 if (PyErr_Occurred()) SWIG_fail;
10043 }
10044 Py_INCREF(Py_None); resultobj = Py_None;
10045 {
10046 if (temp1)
10047 delete arg1;
10048 }
10049 return resultobj;
10050 fail:
10051 {
10052 if (temp1)
10053 delete arg1;
10054 }
10055 return NULL;
10056 }
10057
10058
10059 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10060 PyObject *resultobj;
10061 wxString *arg1 = 0 ;
10062 bool temp1 = false ;
10063 PyObject * obj0 = 0 ;
10064 char *kwnames[] = {
10065 (char *) "msg", NULL
10066 };
10067
10068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10069 {
10070 arg1 = wxString_in_helper(obj0);
10071 if (arg1 == NULL) SWIG_fail;
10072 temp1 = true;
10073 }
10074 {
10075 PyThreadState* __tstate = wxPyBeginAllowThreads();
10076 wxPyLogError((wxString const &)*arg1);
10077
10078 wxPyEndAllowThreads(__tstate);
10079 if (PyErr_Occurred()) SWIG_fail;
10080 }
10081 Py_INCREF(Py_None); resultobj = Py_None;
10082 {
10083 if (temp1)
10084 delete arg1;
10085 }
10086 return resultobj;
10087 fail:
10088 {
10089 if (temp1)
10090 delete arg1;
10091 }
10092 return NULL;
10093 }
10094
10095
10096 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10097 PyObject *resultobj;
10098 wxString *arg1 = 0 ;
10099 bool temp1 = false ;
10100 PyObject * obj0 = 0 ;
10101 char *kwnames[] = {
10102 (char *) "msg", NULL
10103 };
10104
10105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10106 {
10107 arg1 = wxString_in_helper(obj0);
10108 if (arg1 == NULL) SWIG_fail;
10109 temp1 = true;
10110 }
10111 {
10112 PyThreadState* __tstate = wxPyBeginAllowThreads();
10113 wxPyLogWarning((wxString const &)*arg1);
10114
10115 wxPyEndAllowThreads(__tstate);
10116 if (PyErr_Occurred()) SWIG_fail;
10117 }
10118 Py_INCREF(Py_None); resultobj = Py_None;
10119 {
10120 if (temp1)
10121 delete arg1;
10122 }
10123 return resultobj;
10124 fail:
10125 {
10126 if (temp1)
10127 delete arg1;
10128 }
10129 return NULL;
10130 }
10131
10132
10133 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10134 PyObject *resultobj;
10135 wxString *arg1 = 0 ;
10136 bool temp1 = false ;
10137 PyObject * obj0 = 0 ;
10138 char *kwnames[] = {
10139 (char *) "msg", NULL
10140 };
10141
10142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10143 {
10144 arg1 = wxString_in_helper(obj0);
10145 if (arg1 == NULL) SWIG_fail;
10146 temp1 = true;
10147 }
10148 {
10149 PyThreadState* __tstate = wxPyBeginAllowThreads();
10150 wxPyLogMessage((wxString const &)*arg1);
10151
10152 wxPyEndAllowThreads(__tstate);
10153 if (PyErr_Occurred()) SWIG_fail;
10154 }
10155 Py_INCREF(Py_None); resultobj = Py_None;
10156 {
10157 if (temp1)
10158 delete arg1;
10159 }
10160 return resultobj;
10161 fail:
10162 {
10163 if (temp1)
10164 delete arg1;
10165 }
10166 return NULL;
10167 }
10168
10169
10170 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10171 PyObject *resultobj;
10172 wxString *arg1 = 0 ;
10173 bool temp1 = false ;
10174 PyObject * obj0 = 0 ;
10175 char *kwnames[] = {
10176 (char *) "msg", NULL
10177 };
10178
10179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10180 {
10181 arg1 = wxString_in_helper(obj0);
10182 if (arg1 == NULL) SWIG_fail;
10183 temp1 = true;
10184 }
10185 {
10186 PyThreadState* __tstate = wxPyBeginAllowThreads();
10187 wxPyLogInfo((wxString const &)*arg1);
10188
10189 wxPyEndAllowThreads(__tstate);
10190 if (PyErr_Occurred()) SWIG_fail;
10191 }
10192 Py_INCREF(Py_None); resultobj = Py_None;
10193 {
10194 if (temp1)
10195 delete arg1;
10196 }
10197 return resultobj;
10198 fail:
10199 {
10200 if (temp1)
10201 delete arg1;
10202 }
10203 return NULL;
10204 }
10205
10206
10207 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10208 PyObject *resultobj;
10209 wxString *arg1 = 0 ;
10210 bool temp1 = false ;
10211 PyObject * obj0 = 0 ;
10212 char *kwnames[] = {
10213 (char *) "msg", NULL
10214 };
10215
10216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10217 {
10218 arg1 = wxString_in_helper(obj0);
10219 if (arg1 == NULL) SWIG_fail;
10220 temp1 = true;
10221 }
10222 {
10223 PyThreadState* __tstate = wxPyBeginAllowThreads();
10224 wxPyLogDebug((wxString const &)*arg1);
10225
10226 wxPyEndAllowThreads(__tstate);
10227 if (PyErr_Occurred()) SWIG_fail;
10228 }
10229 Py_INCREF(Py_None); resultobj = Py_None;
10230 {
10231 if (temp1)
10232 delete arg1;
10233 }
10234 return resultobj;
10235 fail:
10236 {
10237 if (temp1)
10238 delete arg1;
10239 }
10240 return NULL;
10241 }
10242
10243
10244 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10245 PyObject *resultobj;
10246 wxString *arg1 = 0 ;
10247 bool temp1 = false ;
10248 PyObject * obj0 = 0 ;
10249 char *kwnames[] = {
10250 (char *) "msg", NULL
10251 };
10252
10253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10254 {
10255 arg1 = wxString_in_helper(obj0);
10256 if (arg1 == NULL) SWIG_fail;
10257 temp1 = true;
10258 }
10259 {
10260 PyThreadState* __tstate = wxPyBeginAllowThreads();
10261 wxPyLogVerbose((wxString const &)*arg1);
10262
10263 wxPyEndAllowThreads(__tstate);
10264 if (PyErr_Occurred()) SWIG_fail;
10265 }
10266 Py_INCREF(Py_None); resultobj = Py_None;
10267 {
10268 if (temp1)
10269 delete arg1;
10270 }
10271 return resultobj;
10272 fail:
10273 {
10274 if (temp1)
10275 delete arg1;
10276 }
10277 return NULL;
10278 }
10279
10280
10281 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10282 PyObject *resultobj;
10283 wxString *arg1 = 0 ;
10284 bool temp1 = false ;
10285 PyObject * obj0 = 0 ;
10286 char *kwnames[] = {
10287 (char *) "msg", NULL
10288 };
10289
10290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10291 {
10292 arg1 = wxString_in_helper(obj0);
10293 if (arg1 == NULL) SWIG_fail;
10294 temp1 = true;
10295 }
10296 {
10297 PyThreadState* __tstate = wxPyBeginAllowThreads();
10298 wxPyLogStatus((wxString const &)*arg1);
10299
10300 wxPyEndAllowThreads(__tstate);
10301 if (PyErr_Occurred()) SWIG_fail;
10302 }
10303 Py_INCREF(Py_None); resultobj = Py_None;
10304 {
10305 if (temp1)
10306 delete arg1;
10307 }
10308 return resultobj;
10309 fail:
10310 {
10311 if (temp1)
10312 delete arg1;
10313 }
10314 return NULL;
10315 }
10316
10317
10318 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10319 PyObject *resultobj;
10320 wxFrame *arg1 = (wxFrame *) 0 ;
10321 wxString *arg2 = 0 ;
10322 bool temp2 = false ;
10323 PyObject * obj0 = 0 ;
10324 PyObject * obj1 = 0 ;
10325 char *kwnames[] = {
10326 (char *) "pFrame",(char *) "msg", NULL
10327 };
10328
10329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10331 if (SWIG_arg_fail(1)) SWIG_fail;
10332 {
10333 arg2 = wxString_in_helper(obj1);
10334 if (arg2 == NULL) SWIG_fail;
10335 temp2 = true;
10336 }
10337 {
10338 PyThreadState* __tstate = wxPyBeginAllowThreads();
10339 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10340
10341 wxPyEndAllowThreads(__tstate);
10342 if (PyErr_Occurred()) SWIG_fail;
10343 }
10344 Py_INCREF(Py_None); resultobj = Py_None;
10345 {
10346 if (temp2)
10347 delete arg2;
10348 }
10349 return resultobj;
10350 fail:
10351 {
10352 if (temp2)
10353 delete arg2;
10354 }
10355 return NULL;
10356 }
10357
10358
10359 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10360 PyObject *resultobj;
10361 wxString *arg1 = 0 ;
10362 bool temp1 = false ;
10363 PyObject * obj0 = 0 ;
10364 char *kwnames[] = {
10365 (char *) "msg", NULL
10366 };
10367
10368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10369 {
10370 arg1 = wxString_in_helper(obj0);
10371 if (arg1 == NULL) SWIG_fail;
10372 temp1 = true;
10373 }
10374 {
10375 PyThreadState* __tstate = wxPyBeginAllowThreads();
10376 wxPyLogSysError((wxString const &)*arg1);
10377
10378 wxPyEndAllowThreads(__tstate);
10379 if (PyErr_Occurred()) SWIG_fail;
10380 }
10381 Py_INCREF(Py_None); resultobj = Py_None;
10382 {
10383 if (temp1)
10384 delete arg1;
10385 }
10386 return resultobj;
10387 fail:
10388 {
10389 if (temp1)
10390 delete arg1;
10391 }
10392 return NULL;
10393 }
10394
10395
10396 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10397 PyObject *resultobj;
10398 unsigned long arg1 ;
10399 wxString *arg2 = 0 ;
10400 bool temp2 = false ;
10401 PyObject * obj0 = 0 ;
10402 PyObject * obj1 = 0 ;
10403 char *kwnames[] = {
10404 (char *) "level",(char *) "msg", NULL
10405 };
10406
10407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10408 {
10409 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10410 if (SWIG_arg_fail(1)) SWIG_fail;
10411 }
10412 {
10413 arg2 = wxString_in_helper(obj1);
10414 if (arg2 == NULL) SWIG_fail;
10415 temp2 = true;
10416 }
10417 {
10418 PyThreadState* __tstate = wxPyBeginAllowThreads();
10419 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10420
10421 wxPyEndAllowThreads(__tstate);
10422 if (PyErr_Occurred()) SWIG_fail;
10423 }
10424 Py_INCREF(Py_None); resultobj = Py_None;
10425 {
10426 if (temp2)
10427 delete arg2;
10428 }
10429 return resultobj;
10430 fail:
10431 {
10432 if (temp2)
10433 delete arg2;
10434 }
10435 return NULL;
10436 }
10437
10438
10439 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10440 PyObject *resultobj;
10441 unsigned long arg1 ;
10442 wxString *arg2 = 0 ;
10443 bool temp2 = false ;
10444 PyObject * obj0 = 0 ;
10445 PyObject * obj1 = 0 ;
10446
10447 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10448 {
10449 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10450 if (SWIG_arg_fail(1)) SWIG_fail;
10451 }
10452 {
10453 arg2 = wxString_in_helper(obj1);
10454 if (arg2 == NULL) SWIG_fail;
10455 temp2 = true;
10456 }
10457 {
10458 PyThreadState* __tstate = wxPyBeginAllowThreads();
10459 wxPyLogTrace(arg1,(wxString const &)*arg2);
10460
10461 wxPyEndAllowThreads(__tstate);
10462 if (PyErr_Occurred()) SWIG_fail;
10463 }
10464 Py_INCREF(Py_None); resultobj = Py_None;
10465 {
10466 if (temp2)
10467 delete arg2;
10468 }
10469 return resultobj;
10470 fail:
10471 {
10472 if (temp2)
10473 delete arg2;
10474 }
10475 return NULL;
10476 }
10477
10478
10479 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10480 PyObject *resultobj;
10481 wxString *arg1 = 0 ;
10482 wxString *arg2 = 0 ;
10483 bool temp1 = false ;
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 = wxString_in_helper(obj0);
10491 if (arg1 == NULL) SWIG_fail;
10492 temp1 = true;
10493 }
10494 {
10495 arg2 = wxString_in_helper(obj1);
10496 if (arg2 == NULL) SWIG_fail;
10497 temp2 = true;
10498 }
10499 {
10500 PyThreadState* __tstate = wxPyBeginAllowThreads();
10501 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10502
10503 wxPyEndAllowThreads(__tstate);
10504 if (PyErr_Occurred()) SWIG_fail;
10505 }
10506 Py_INCREF(Py_None); resultobj = Py_None;
10507 {
10508 if (temp1)
10509 delete arg1;
10510 }
10511 {
10512 if (temp2)
10513 delete arg2;
10514 }
10515 return resultobj;
10516 fail:
10517 {
10518 if (temp1)
10519 delete arg1;
10520 }
10521 {
10522 if (temp2)
10523 delete arg2;
10524 }
10525 return NULL;
10526 }
10527
10528
10529 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10530 int argc;
10531 PyObject *argv[3];
10532 int ii;
10533
10534 argc = PyObject_Length(args);
10535 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10536 argv[ii] = PyTuple_GetItem(args,ii);
10537 }
10538 if (argc == 2) {
10539 int _v;
10540 {
10541 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10542 }
10543 if (_v) {
10544 {
10545 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10546 }
10547 if (_v) {
10548 return _wrap_LogTrace__SWIG_1(self,args);
10549 }
10550 }
10551 }
10552 if (argc == 2) {
10553 int _v;
10554 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10555 if (_v) {
10556 {
10557 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10558 }
10559 if (_v) {
10560 return _wrap_LogTrace__SWIG_0(self,args);
10561 }
10562 }
10563 }
10564
10565 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10566 return NULL;
10567 }
10568
10569
10570 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10571 PyObject *resultobj;
10572 wxString *arg1 = 0 ;
10573 wxString *arg2 = 0 ;
10574 bool temp1 = false ;
10575 bool temp2 = false ;
10576 PyObject * obj0 = 0 ;
10577 PyObject * obj1 = 0 ;
10578 char *kwnames[] = {
10579 (char *) "title",(char *) "text", NULL
10580 };
10581
10582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10583 {
10584 arg1 = wxString_in_helper(obj0);
10585 if (arg1 == NULL) SWIG_fail;
10586 temp1 = true;
10587 }
10588 {
10589 arg2 = wxString_in_helper(obj1);
10590 if (arg2 == NULL) SWIG_fail;
10591 temp2 = true;
10592 }
10593 {
10594 PyThreadState* __tstate = wxPyBeginAllowThreads();
10595 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10596
10597 wxPyEndAllowThreads(__tstate);
10598 if (PyErr_Occurred()) SWIG_fail;
10599 }
10600 Py_INCREF(Py_None); resultobj = Py_None;
10601 {
10602 if (temp1)
10603 delete arg1;
10604 }
10605 {
10606 if (temp2)
10607 delete arg2;
10608 }
10609 return resultobj;
10610 fail:
10611 {
10612 if (temp1)
10613 delete arg1;
10614 }
10615 {
10616 if (temp2)
10617 delete arg2;
10618 }
10619 return NULL;
10620 }
10621
10622
10623 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10624 PyObject *resultobj;
10625 wxLogNull *result;
10626 char *kwnames[] = {
10627 NULL
10628 };
10629
10630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10631 {
10632 PyThreadState* __tstate = wxPyBeginAllowThreads();
10633 result = (wxLogNull *)new wxLogNull();
10634
10635 wxPyEndAllowThreads(__tstate);
10636 if (PyErr_Occurred()) SWIG_fail;
10637 }
10638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10639 return resultobj;
10640 fail:
10641 return NULL;
10642 }
10643
10644
10645 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10646 PyObject *resultobj;
10647 wxLogNull *arg1 = (wxLogNull *) 0 ;
10648 PyObject * obj0 = 0 ;
10649 char *kwnames[] = {
10650 (char *) "self", NULL
10651 };
10652
10653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10655 if (SWIG_arg_fail(1)) SWIG_fail;
10656 {
10657 PyThreadState* __tstate = wxPyBeginAllowThreads();
10658 delete arg1;
10659
10660 wxPyEndAllowThreads(__tstate);
10661 if (PyErr_Occurred()) SWIG_fail;
10662 }
10663 Py_INCREF(Py_None); resultobj = Py_None;
10664 return resultobj;
10665 fail:
10666 return NULL;
10667 }
10668
10669
10670 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10671 PyObject *obj;
10672 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10673 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10674 Py_INCREF(obj);
10675 return Py_BuildValue((char *)"");
10676 }
10677 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10678 PyObject *resultobj;
10679 wxPyLog *result;
10680 char *kwnames[] = {
10681 NULL
10682 };
10683
10684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10685 {
10686 PyThreadState* __tstate = wxPyBeginAllowThreads();
10687 result = (wxPyLog *)new wxPyLog();
10688
10689 wxPyEndAllowThreads(__tstate);
10690 if (PyErr_Occurred()) SWIG_fail;
10691 }
10692 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10693 return resultobj;
10694 fail:
10695 return NULL;
10696 }
10697
10698
10699 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10700 PyObject *resultobj;
10701 wxPyLog *arg1 = (wxPyLog *) 0 ;
10702 PyObject *arg2 = (PyObject *) 0 ;
10703 PyObject *arg3 = (PyObject *) 0 ;
10704 PyObject * obj0 = 0 ;
10705 PyObject * obj1 = 0 ;
10706 PyObject * obj2 = 0 ;
10707 char *kwnames[] = {
10708 (char *) "self",(char *) "self",(char *) "_class", NULL
10709 };
10710
10711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10713 if (SWIG_arg_fail(1)) SWIG_fail;
10714 arg2 = obj1;
10715 arg3 = obj2;
10716 {
10717 PyThreadState* __tstate = wxPyBeginAllowThreads();
10718 (arg1)->_setCallbackInfo(arg2,arg3);
10719
10720 wxPyEndAllowThreads(__tstate);
10721 if (PyErr_Occurred()) SWIG_fail;
10722 }
10723 Py_INCREF(Py_None); resultobj = Py_None;
10724 return resultobj;
10725 fail:
10726 return NULL;
10727 }
10728
10729
10730 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10731 PyObject *obj;
10732 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10733 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10734 Py_INCREF(obj);
10735 return Py_BuildValue((char *)"");
10736 }
10737 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10738 PyObject *resultobj;
10739 int arg1 ;
10740 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10741 int arg3 = (int) wxKILL_NOCHILDREN ;
10742 wxKillError result;
10743 PyObject * obj0 = 0 ;
10744 PyObject * obj1 = 0 ;
10745 PyObject * obj2 = 0 ;
10746 char *kwnames[] = {
10747 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10748 };
10749
10750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10751 {
10752 arg1 = (int)(SWIG_As_int(obj0));
10753 if (SWIG_arg_fail(1)) SWIG_fail;
10754 }
10755 if (obj1) {
10756 {
10757 arg2 = (wxSignal)(SWIG_As_int(obj1));
10758 if (SWIG_arg_fail(2)) SWIG_fail;
10759 }
10760 }
10761 if (obj2) {
10762 {
10763 arg3 = (int)(SWIG_As_int(obj2));
10764 if (SWIG_arg_fail(3)) SWIG_fail;
10765 }
10766 }
10767 {
10768 PyThreadState* __tstate = wxPyBeginAllowThreads();
10769 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10770
10771 wxPyEndAllowThreads(__tstate);
10772 if (PyErr_Occurred()) SWIG_fail;
10773 }
10774 resultobj = SWIG_From_int((result));
10775 return resultobj;
10776 fail:
10777 return NULL;
10778 }
10779
10780
10781 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10782 PyObject *resultobj;
10783 int arg1 ;
10784 bool result;
10785 PyObject * obj0 = 0 ;
10786 char *kwnames[] = {
10787 (char *) "pid", NULL
10788 };
10789
10790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10791 {
10792 arg1 = (int)(SWIG_As_int(obj0));
10793 if (SWIG_arg_fail(1)) SWIG_fail;
10794 }
10795 {
10796 PyThreadState* __tstate = wxPyBeginAllowThreads();
10797 result = (bool)wxPyProcess::Exists(arg1);
10798
10799 wxPyEndAllowThreads(__tstate);
10800 if (PyErr_Occurred()) SWIG_fail;
10801 }
10802 {
10803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10804 }
10805 return resultobj;
10806 fail:
10807 return NULL;
10808 }
10809
10810
10811 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10812 PyObject *resultobj;
10813 wxString *arg1 = 0 ;
10814 int arg2 = (int) wxEXEC_ASYNC ;
10815 wxPyProcess *result;
10816 bool temp1 = false ;
10817 PyObject * obj0 = 0 ;
10818 PyObject * obj1 = 0 ;
10819 char *kwnames[] = {
10820 (char *) "cmd",(char *) "flags", NULL
10821 };
10822
10823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10824 {
10825 arg1 = wxString_in_helper(obj0);
10826 if (arg1 == NULL) SWIG_fail;
10827 temp1 = true;
10828 }
10829 if (obj1) {
10830 {
10831 arg2 = (int)(SWIG_As_int(obj1));
10832 if (SWIG_arg_fail(2)) SWIG_fail;
10833 }
10834 }
10835 {
10836 PyThreadState* __tstate = wxPyBeginAllowThreads();
10837 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10838
10839 wxPyEndAllowThreads(__tstate);
10840 if (PyErr_Occurred()) SWIG_fail;
10841 }
10842 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10843 {
10844 if (temp1)
10845 delete arg1;
10846 }
10847 return resultobj;
10848 fail:
10849 {
10850 if (temp1)
10851 delete arg1;
10852 }
10853 return NULL;
10854 }
10855
10856
10857 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10858 PyObject *resultobj;
10859 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10860 int arg2 = (int) -1 ;
10861 wxPyProcess *result;
10862 PyObject * obj0 = 0 ;
10863 PyObject * obj1 = 0 ;
10864 char *kwnames[] = {
10865 (char *) "parent",(char *) "id", NULL
10866 };
10867
10868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10869 if (obj0) {
10870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10871 if (SWIG_arg_fail(1)) SWIG_fail;
10872 }
10873 if (obj1) {
10874 {
10875 arg2 = (int)(SWIG_As_int(obj1));
10876 if (SWIG_arg_fail(2)) SWIG_fail;
10877 }
10878 }
10879 {
10880 PyThreadState* __tstate = wxPyBeginAllowThreads();
10881 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10882
10883 wxPyEndAllowThreads(__tstate);
10884 if (PyErr_Occurred()) SWIG_fail;
10885 }
10886 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10887 return resultobj;
10888 fail:
10889 return NULL;
10890 }
10891
10892
10893 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10894 PyObject *resultobj;
10895 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10896 PyObject *arg2 = (PyObject *) 0 ;
10897 PyObject *arg3 = (PyObject *) 0 ;
10898 PyObject * obj0 = 0 ;
10899 PyObject * obj1 = 0 ;
10900 PyObject * obj2 = 0 ;
10901 char *kwnames[] = {
10902 (char *) "self",(char *) "self",(char *) "_class", NULL
10903 };
10904
10905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10907 if (SWIG_arg_fail(1)) SWIG_fail;
10908 arg2 = obj1;
10909 arg3 = obj2;
10910 {
10911 PyThreadState* __tstate = wxPyBeginAllowThreads();
10912 (arg1)->_setCallbackInfo(arg2,arg3);
10913
10914 wxPyEndAllowThreads(__tstate);
10915 if (PyErr_Occurred()) SWIG_fail;
10916 }
10917 Py_INCREF(Py_None); resultobj = Py_None;
10918 return resultobj;
10919 fail:
10920 return NULL;
10921 }
10922
10923
10924 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10925 PyObject *resultobj;
10926 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10927 int arg2 ;
10928 int arg3 ;
10929 PyObject * obj0 = 0 ;
10930 PyObject * obj1 = 0 ;
10931 PyObject * obj2 = 0 ;
10932 char *kwnames[] = {
10933 (char *) "self",(char *) "pid",(char *) "status", NULL
10934 };
10935
10936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10938 if (SWIG_arg_fail(1)) SWIG_fail;
10939 {
10940 arg2 = (int)(SWIG_As_int(obj1));
10941 if (SWIG_arg_fail(2)) SWIG_fail;
10942 }
10943 {
10944 arg3 = (int)(SWIG_As_int(obj2));
10945 if (SWIG_arg_fail(3)) SWIG_fail;
10946 }
10947 {
10948 PyThreadState* __tstate = wxPyBeginAllowThreads();
10949 (arg1)->base_OnTerminate(arg2,arg3);
10950
10951 wxPyEndAllowThreads(__tstate);
10952 if (PyErr_Occurred()) SWIG_fail;
10953 }
10954 Py_INCREF(Py_None); resultobj = Py_None;
10955 return resultobj;
10956 fail:
10957 return NULL;
10958 }
10959
10960
10961 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10962 PyObject *resultobj;
10963 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10964 PyObject * obj0 = 0 ;
10965 char *kwnames[] = {
10966 (char *) "self", NULL
10967 };
10968
10969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10971 if (SWIG_arg_fail(1)) SWIG_fail;
10972 {
10973 PyThreadState* __tstate = wxPyBeginAllowThreads();
10974 (arg1)->Redirect();
10975
10976 wxPyEndAllowThreads(__tstate);
10977 if (PyErr_Occurred()) SWIG_fail;
10978 }
10979 Py_INCREF(Py_None); resultobj = Py_None;
10980 return resultobj;
10981 fail:
10982 return NULL;
10983 }
10984
10985
10986 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10987 PyObject *resultobj;
10988 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10989 bool result;
10990 PyObject * obj0 = 0 ;
10991 char *kwnames[] = {
10992 (char *) "self", NULL
10993 };
10994
10995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10997 if (SWIG_arg_fail(1)) SWIG_fail;
10998 {
10999 PyThreadState* __tstate = wxPyBeginAllowThreads();
11000 result = (bool)(arg1)->IsRedirected();
11001
11002 wxPyEndAllowThreads(__tstate);
11003 if (PyErr_Occurred()) SWIG_fail;
11004 }
11005 {
11006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11007 }
11008 return resultobj;
11009 fail:
11010 return NULL;
11011 }
11012
11013
11014 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11015 PyObject *resultobj;
11016 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11017 PyObject * obj0 = 0 ;
11018 char *kwnames[] = {
11019 (char *) "self", NULL
11020 };
11021
11022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11024 if (SWIG_arg_fail(1)) SWIG_fail;
11025 {
11026 PyThreadState* __tstate = wxPyBeginAllowThreads();
11027 (arg1)->Detach();
11028
11029 wxPyEndAllowThreads(__tstate);
11030 if (PyErr_Occurred()) SWIG_fail;
11031 }
11032 Py_INCREF(Py_None); resultobj = Py_None;
11033 return resultobj;
11034 fail:
11035 return NULL;
11036 }
11037
11038
11039 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11040 PyObject *resultobj;
11041 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11042 wxInputStream *result;
11043 PyObject * obj0 = 0 ;
11044 char *kwnames[] = {
11045 (char *) "self", NULL
11046 };
11047
11048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11050 if (SWIG_arg_fail(1)) SWIG_fail;
11051 {
11052 PyThreadState* __tstate = wxPyBeginAllowThreads();
11053 result = (wxInputStream *)(arg1)->GetInputStream();
11054
11055 wxPyEndAllowThreads(__tstate);
11056 if (PyErr_Occurred()) SWIG_fail;
11057 }
11058 {
11059 wxPyInputStream * _ptr = NULL;
11060
11061 if (result) {
11062 _ptr = new wxPyInputStream(result);
11063 }
11064 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11065 }
11066 return resultobj;
11067 fail:
11068 return NULL;
11069 }
11070
11071
11072 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11073 PyObject *resultobj;
11074 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11075 wxInputStream *result;
11076 PyObject * obj0 = 0 ;
11077 char *kwnames[] = {
11078 (char *) "self", NULL
11079 };
11080
11081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11083 if (SWIG_arg_fail(1)) SWIG_fail;
11084 {
11085 PyThreadState* __tstate = wxPyBeginAllowThreads();
11086 result = (wxInputStream *)(arg1)->GetErrorStream();
11087
11088 wxPyEndAllowThreads(__tstate);
11089 if (PyErr_Occurred()) SWIG_fail;
11090 }
11091 {
11092 wxPyInputStream * _ptr = NULL;
11093
11094 if (result) {
11095 _ptr = new wxPyInputStream(result);
11096 }
11097 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11098 }
11099 return resultobj;
11100 fail:
11101 return NULL;
11102 }
11103
11104
11105 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11106 PyObject *resultobj;
11107 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11108 wxOutputStream *result;
11109 PyObject * obj0 = 0 ;
11110 char *kwnames[] = {
11111 (char *) "self", NULL
11112 };
11113
11114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11116 if (SWIG_arg_fail(1)) SWIG_fail;
11117 {
11118 PyThreadState* __tstate = wxPyBeginAllowThreads();
11119 result = (wxOutputStream *)(arg1)->GetOutputStream();
11120
11121 wxPyEndAllowThreads(__tstate);
11122 if (PyErr_Occurred()) SWIG_fail;
11123 }
11124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11125 return resultobj;
11126 fail:
11127 return NULL;
11128 }
11129
11130
11131 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11132 PyObject *resultobj;
11133 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11134 PyObject * obj0 = 0 ;
11135 char *kwnames[] = {
11136 (char *) "self", NULL
11137 };
11138
11139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11141 if (SWIG_arg_fail(1)) SWIG_fail;
11142 {
11143 PyThreadState* __tstate = wxPyBeginAllowThreads();
11144 (arg1)->CloseOutput();
11145
11146 wxPyEndAllowThreads(__tstate);
11147 if (PyErr_Occurred()) SWIG_fail;
11148 }
11149 Py_INCREF(Py_None); resultobj = Py_None;
11150 return resultobj;
11151 fail:
11152 return NULL;
11153 }
11154
11155
11156 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11157 PyObject *resultobj;
11158 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11159 bool result;
11160 PyObject * obj0 = 0 ;
11161 char *kwnames[] = {
11162 (char *) "self", NULL
11163 };
11164
11165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11167 if (SWIG_arg_fail(1)) SWIG_fail;
11168 {
11169 PyThreadState* __tstate = wxPyBeginAllowThreads();
11170 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11171
11172 wxPyEndAllowThreads(__tstate);
11173 if (PyErr_Occurred()) SWIG_fail;
11174 }
11175 {
11176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11177 }
11178 return resultobj;
11179 fail:
11180 return NULL;
11181 }
11182
11183
11184 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11185 PyObject *resultobj;
11186 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11187 bool result;
11188 PyObject * obj0 = 0 ;
11189 char *kwnames[] = {
11190 (char *) "self", NULL
11191 };
11192
11193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11195 if (SWIG_arg_fail(1)) SWIG_fail;
11196 {
11197 PyThreadState* __tstate = wxPyBeginAllowThreads();
11198 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11199
11200 wxPyEndAllowThreads(__tstate);
11201 if (PyErr_Occurred()) SWIG_fail;
11202 }
11203 {
11204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11205 }
11206 return resultobj;
11207 fail:
11208 return NULL;
11209 }
11210
11211
11212 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11213 PyObject *resultobj;
11214 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11215 bool result;
11216 PyObject * obj0 = 0 ;
11217 char *kwnames[] = {
11218 (char *) "self", NULL
11219 };
11220
11221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11223 if (SWIG_arg_fail(1)) SWIG_fail;
11224 {
11225 PyThreadState* __tstate = wxPyBeginAllowThreads();
11226 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11227
11228 wxPyEndAllowThreads(__tstate);
11229 if (PyErr_Occurred()) SWIG_fail;
11230 }
11231 {
11232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11233 }
11234 return resultobj;
11235 fail:
11236 return NULL;
11237 }
11238
11239
11240 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11241 PyObject *obj;
11242 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11243 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11244 Py_INCREF(obj);
11245 return Py_BuildValue((char *)"");
11246 }
11247 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11248 PyObject *resultobj;
11249 int arg1 = (int) 0 ;
11250 int arg2 = (int) 0 ;
11251 int arg3 = (int) 0 ;
11252 wxProcessEvent *result;
11253 PyObject * obj0 = 0 ;
11254 PyObject * obj1 = 0 ;
11255 PyObject * obj2 = 0 ;
11256 char *kwnames[] = {
11257 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11258 };
11259
11260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11261 if (obj0) {
11262 {
11263 arg1 = (int)(SWIG_As_int(obj0));
11264 if (SWIG_arg_fail(1)) SWIG_fail;
11265 }
11266 }
11267 if (obj1) {
11268 {
11269 arg2 = (int)(SWIG_As_int(obj1));
11270 if (SWIG_arg_fail(2)) SWIG_fail;
11271 }
11272 }
11273 if (obj2) {
11274 {
11275 arg3 = (int)(SWIG_As_int(obj2));
11276 if (SWIG_arg_fail(3)) SWIG_fail;
11277 }
11278 }
11279 {
11280 PyThreadState* __tstate = wxPyBeginAllowThreads();
11281 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11282
11283 wxPyEndAllowThreads(__tstate);
11284 if (PyErr_Occurred()) SWIG_fail;
11285 }
11286 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11287 return resultobj;
11288 fail:
11289 return NULL;
11290 }
11291
11292
11293 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11294 PyObject *resultobj;
11295 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11296 int result;
11297 PyObject * obj0 = 0 ;
11298 char *kwnames[] = {
11299 (char *) "self", NULL
11300 };
11301
11302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11304 if (SWIG_arg_fail(1)) SWIG_fail;
11305 {
11306 PyThreadState* __tstate = wxPyBeginAllowThreads();
11307 result = (int)(arg1)->GetPid();
11308
11309 wxPyEndAllowThreads(__tstate);
11310 if (PyErr_Occurred()) SWIG_fail;
11311 }
11312 {
11313 resultobj = SWIG_From_int((int)(result));
11314 }
11315 return resultobj;
11316 fail:
11317 return NULL;
11318 }
11319
11320
11321 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11322 PyObject *resultobj;
11323 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11324 int result;
11325 PyObject * obj0 = 0 ;
11326 char *kwnames[] = {
11327 (char *) "self", NULL
11328 };
11329
11330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11332 if (SWIG_arg_fail(1)) SWIG_fail;
11333 {
11334 PyThreadState* __tstate = wxPyBeginAllowThreads();
11335 result = (int)(arg1)->GetExitCode();
11336
11337 wxPyEndAllowThreads(__tstate);
11338 if (PyErr_Occurred()) SWIG_fail;
11339 }
11340 {
11341 resultobj = SWIG_From_int((int)(result));
11342 }
11343 return resultobj;
11344 fail:
11345 return NULL;
11346 }
11347
11348
11349 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11350 PyObject *resultobj;
11351 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11352 int arg2 ;
11353 PyObject * obj0 = 0 ;
11354 PyObject * obj1 = 0 ;
11355 char *kwnames[] = {
11356 (char *) "self",(char *) "m_pid", NULL
11357 };
11358
11359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11361 if (SWIG_arg_fail(1)) SWIG_fail;
11362 {
11363 arg2 = (int)(SWIG_As_int(obj1));
11364 if (SWIG_arg_fail(2)) SWIG_fail;
11365 }
11366 if (arg1) (arg1)->m_pid = arg2;
11367
11368 Py_INCREF(Py_None); resultobj = Py_None;
11369 return resultobj;
11370 fail:
11371 return NULL;
11372 }
11373
11374
11375 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11376 PyObject *resultobj;
11377 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11378 int result;
11379 PyObject * obj0 = 0 ;
11380 char *kwnames[] = {
11381 (char *) "self", NULL
11382 };
11383
11384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11386 if (SWIG_arg_fail(1)) SWIG_fail;
11387 result = (int) ((arg1)->m_pid);
11388
11389 {
11390 resultobj = SWIG_From_int((int)(result));
11391 }
11392 return resultobj;
11393 fail:
11394 return NULL;
11395 }
11396
11397
11398 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11399 PyObject *resultobj;
11400 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11401 int arg2 ;
11402 PyObject * obj0 = 0 ;
11403 PyObject * obj1 = 0 ;
11404 char *kwnames[] = {
11405 (char *) "self",(char *) "m_exitcode", NULL
11406 };
11407
11408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11410 if (SWIG_arg_fail(1)) SWIG_fail;
11411 {
11412 arg2 = (int)(SWIG_As_int(obj1));
11413 if (SWIG_arg_fail(2)) SWIG_fail;
11414 }
11415 if (arg1) (arg1)->m_exitcode = arg2;
11416
11417 Py_INCREF(Py_None); resultobj = Py_None;
11418 return resultobj;
11419 fail:
11420 return NULL;
11421 }
11422
11423
11424 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11425 PyObject *resultobj;
11426 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11427 int result;
11428 PyObject * obj0 = 0 ;
11429 char *kwnames[] = {
11430 (char *) "self", NULL
11431 };
11432
11433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11435 if (SWIG_arg_fail(1)) SWIG_fail;
11436 result = (int) ((arg1)->m_exitcode);
11437
11438 {
11439 resultobj = SWIG_From_int((int)(result));
11440 }
11441 return resultobj;
11442 fail:
11443 return NULL;
11444 }
11445
11446
11447 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11448 PyObject *obj;
11449 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11450 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11451 Py_INCREF(obj);
11452 return Py_BuildValue((char *)"");
11453 }
11454 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11455 PyObject *resultobj;
11456 wxString *arg1 = 0 ;
11457 int arg2 = (int) wxEXEC_ASYNC ;
11458 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11459 long result;
11460 bool temp1 = false ;
11461 PyObject * obj0 = 0 ;
11462 PyObject * obj1 = 0 ;
11463 PyObject * obj2 = 0 ;
11464 char *kwnames[] = {
11465 (char *) "command",(char *) "flags",(char *) "process", NULL
11466 };
11467
11468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11469 {
11470 arg1 = wxString_in_helper(obj0);
11471 if (arg1 == NULL) SWIG_fail;
11472 temp1 = true;
11473 }
11474 if (obj1) {
11475 {
11476 arg2 = (int)(SWIG_As_int(obj1));
11477 if (SWIG_arg_fail(2)) SWIG_fail;
11478 }
11479 }
11480 if (obj2) {
11481 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11482 if (SWIG_arg_fail(3)) SWIG_fail;
11483 }
11484 {
11485 if (!wxPyCheckForApp()) SWIG_fail;
11486 PyThreadState* __tstate = wxPyBeginAllowThreads();
11487 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11488
11489 wxPyEndAllowThreads(__tstate);
11490 if (PyErr_Occurred()) SWIG_fail;
11491 }
11492 {
11493 resultobj = SWIG_From_long((long)(result));
11494 }
11495 {
11496 if (temp1)
11497 delete arg1;
11498 }
11499 return resultobj;
11500 fail:
11501 {
11502 if (temp1)
11503 delete arg1;
11504 }
11505 return NULL;
11506 }
11507
11508
11509 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11510 PyObject *resultobj;
11511 long arg1 ;
11512 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11513 wxKillError *arg3 = (wxKillError *) 0 ;
11514 int arg4 = (int) wxKILL_NOCHILDREN ;
11515 int result;
11516 wxKillError temp3 ;
11517 PyObject * obj0 = 0 ;
11518 PyObject * obj1 = 0 ;
11519 PyObject * obj2 = 0 ;
11520 char *kwnames[] = {
11521 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11522 };
11523
11524 {
11525 arg3 = &temp3;
11526 }
11527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11528 {
11529 arg1 = (long)(SWIG_As_long(obj0));
11530 if (SWIG_arg_fail(1)) SWIG_fail;
11531 }
11532 if (obj1) {
11533 {
11534 arg2 = (wxSignal)(SWIG_As_int(obj1));
11535 if (SWIG_arg_fail(2)) SWIG_fail;
11536 }
11537 }
11538 if (obj2) {
11539 {
11540 arg4 = (int)(SWIG_As_int(obj2));
11541 if (SWIG_arg_fail(4)) SWIG_fail;
11542 }
11543 }
11544 {
11545 PyThreadState* __tstate = wxPyBeginAllowThreads();
11546 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11547
11548 wxPyEndAllowThreads(__tstate);
11549 if (PyErr_Occurred()) SWIG_fail;
11550 }
11551 {
11552 resultobj = SWIG_From_int((int)(result));
11553 }
11554 {
11555 PyObject* o;
11556 o = PyInt_FromLong((long) (*arg3));
11557 resultobj = t_output_helper(resultobj, o);
11558 }
11559 return resultobj;
11560 fail:
11561 return NULL;
11562 }
11563
11564
11565 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11566 PyObject *resultobj;
11567 int arg1 = (int) wxJOYSTICK1 ;
11568 wxJoystick *result;
11569 PyObject * obj0 = 0 ;
11570 char *kwnames[] = {
11571 (char *) "joystick", NULL
11572 };
11573
11574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11575 if (obj0) {
11576 {
11577 arg1 = (int)(SWIG_As_int(obj0));
11578 if (SWIG_arg_fail(1)) SWIG_fail;
11579 }
11580 }
11581 {
11582 if (!wxPyCheckForApp()) SWIG_fail;
11583 PyThreadState* __tstate = wxPyBeginAllowThreads();
11584 result = (wxJoystick *)new wxJoystick(arg1);
11585
11586 wxPyEndAllowThreads(__tstate);
11587 if (PyErr_Occurred()) SWIG_fail;
11588 }
11589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11590 return resultobj;
11591 fail:
11592 return NULL;
11593 }
11594
11595
11596 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11597 PyObject *resultobj;
11598 wxJoystick *arg1 = (wxJoystick *) 0 ;
11599 PyObject * obj0 = 0 ;
11600 char *kwnames[] = {
11601 (char *) "self", NULL
11602 };
11603
11604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11606 if (SWIG_arg_fail(1)) SWIG_fail;
11607 {
11608 PyThreadState* __tstate = wxPyBeginAllowThreads();
11609 delete arg1;
11610
11611 wxPyEndAllowThreads(__tstate);
11612 if (PyErr_Occurred()) SWIG_fail;
11613 }
11614 Py_INCREF(Py_None); resultobj = Py_None;
11615 return resultobj;
11616 fail:
11617 return NULL;
11618 }
11619
11620
11621 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11622 PyObject *resultobj;
11623 wxJoystick *arg1 = (wxJoystick *) 0 ;
11624 wxPoint result;
11625 PyObject * obj0 = 0 ;
11626 char *kwnames[] = {
11627 (char *) "self", NULL
11628 };
11629
11630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11632 if (SWIG_arg_fail(1)) SWIG_fail;
11633 {
11634 PyThreadState* __tstate = wxPyBeginAllowThreads();
11635 result = (arg1)->GetPosition();
11636
11637 wxPyEndAllowThreads(__tstate);
11638 if (PyErr_Occurred()) SWIG_fail;
11639 }
11640 {
11641 wxPoint * resultptr;
11642 resultptr = new wxPoint((wxPoint &)(result));
11643 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11644 }
11645 return resultobj;
11646 fail:
11647 return NULL;
11648 }
11649
11650
11651 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11652 PyObject *resultobj;
11653 wxJoystick *arg1 = (wxJoystick *) 0 ;
11654 int result;
11655 PyObject * obj0 = 0 ;
11656 char *kwnames[] = {
11657 (char *) "self", NULL
11658 };
11659
11660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11662 if (SWIG_arg_fail(1)) SWIG_fail;
11663 {
11664 PyThreadState* __tstate = wxPyBeginAllowThreads();
11665 result = (int)(arg1)->GetZPosition();
11666
11667 wxPyEndAllowThreads(__tstate);
11668 if (PyErr_Occurred()) SWIG_fail;
11669 }
11670 {
11671 resultobj = SWIG_From_int((int)(result));
11672 }
11673 return resultobj;
11674 fail:
11675 return NULL;
11676 }
11677
11678
11679 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11680 PyObject *resultobj;
11681 wxJoystick *arg1 = (wxJoystick *) 0 ;
11682 int result;
11683 PyObject * obj0 = 0 ;
11684 char *kwnames[] = {
11685 (char *) "self", NULL
11686 };
11687
11688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11690 if (SWIG_arg_fail(1)) SWIG_fail;
11691 {
11692 PyThreadState* __tstate = wxPyBeginAllowThreads();
11693 result = (int)(arg1)->GetButtonState();
11694
11695 wxPyEndAllowThreads(__tstate);
11696 if (PyErr_Occurred()) SWIG_fail;
11697 }
11698 {
11699 resultobj = SWIG_From_int((int)(result));
11700 }
11701 return resultobj;
11702 fail:
11703 return NULL;
11704 }
11705
11706
11707 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11708 PyObject *resultobj;
11709 wxJoystick *arg1 = (wxJoystick *) 0 ;
11710 int result;
11711 PyObject * obj0 = 0 ;
11712 char *kwnames[] = {
11713 (char *) "self", NULL
11714 };
11715
11716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11718 if (SWIG_arg_fail(1)) SWIG_fail;
11719 {
11720 PyThreadState* __tstate = wxPyBeginAllowThreads();
11721 result = (int)(arg1)->GetPOVPosition();
11722
11723 wxPyEndAllowThreads(__tstate);
11724 if (PyErr_Occurred()) SWIG_fail;
11725 }
11726 {
11727 resultobj = SWIG_From_int((int)(result));
11728 }
11729 return resultobj;
11730 fail:
11731 return NULL;
11732 }
11733
11734
11735 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11736 PyObject *resultobj;
11737 wxJoystick *arg1 = (wxJoystick *) 0 ;
11738 int result;
11739 PyObject * obj0 = 0 ;
11740 char *kwnames[] = {
11741 (char *) "self", NULL
11742 };
11743
11744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11746 if (SWIG_arg_fail(1)) SWIG_fail;
11747 {
11748 PyThreadState* __tstate = wxPyBeginAllowThreads();
11749 result = (int)(arg1)->GetPOVCTSPosition();
11750
11751 wxPyEndAllowThreads(__tstate);
11752 if (PyErr_Occurred()) SWIG_fail;
11753 }
11754 {
11755 resultobj = SWIG_From_int((int)(result));
11756 }
11757 return resultobj;
11758 fail:
11759 return NULL;
11760 }
11761
11762
11763 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11764 PyObject *resultobj;
11765 wxJoystick *arg1 = (wxJoystick *) 0 ;
11766 int result;
11767 PyObject * obj0 = 0 ;
11768 char *kwnames[] = {
11769 (char *) "self", NULL
11770 };
11771
11772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11774 if (SWIG_arg_fail(1)) SWIG_fail;
11775 {
11776 PyThreadState* __tstate = wxPyBeginAllowThreads();
11777 result = (int)(arg1)->GetRudderPosition();
11778
11779 wxPyEndAllowThreads(__tstate);
11780 if (PyErr_Occurred()) SWIG_fail;
11781 }
11782 {
11783 resultobj = SWIG_From_int((int)(result));
11784 }
11785 return resultobj;
11786 fail:
11787 return NULL;
11788 }
11789
11790
11791 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11792 PyObject *resultobj;
11793 wxJoystick *arg1 = (wxJoystick *) 0 ;
11794 int result;
11795 PyObject * obj0 = 0 ;
11796 char *kwnames[] = {
11797 (char *) "self", NULL
11798 };
11799
11800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11802 if (SWIG_arg_fail(1)) SWIG_fail;
11803 {
11804 PyThreadState* __tstate = wxPyBeginAllowThreads();
11805 result = (int)(arg1)->GetUPosition();
11806
11807 wxPyEndAllowThreads(__tstate);
11808 if (PyErr_Occurred()) SWIG_fail;
11809 }
11810 {
11811 resultobj = SWIG_From_int((int)(result));
11812 }
11813 return resultobj;
11814 fail:
11815 return NULL;
11816 }
11817
11818
11819 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11820 PyObject *resultobj;
11821 wxJoystick *arg1 = (wxJoystick *) 0 ;
11822 int result;
11823 PyObject * obj0 = 0 ;
11824 char *kwnames[] = {
11825 (char *) "self", NULL
11826 };
11827
11828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11830 if (SWIG_arg_fail(1)) SWIG_fail;
11831 {
11832 PyThreadState* __tstate = wxPyBeginAllowThreads();
11833 result = (int)(arg1)->GetVPosition();
11834
11835 wxPyEndAllowThreads(__tstate);
11836 if (PyErr_Occurred()) SWIG_fail;
11837 }
11838 {
11839 resultobj = SWIG_From_int((int)(result));
11840 }
11841 return resultobj;
11842 fail:
11843 return NULL;
11844 }
11845
11846
11847 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11848 PyObject *resultobj;
11849 wxJoystick *arg1 = (wxJoystick *) 0 ;
11850 int result;
11851 PyObject * obj0 = 0 ;
11852 char *kwnames[] = {
11853 (char *) "self", NULL
11854 };
11855
11856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11858 if (SWIG_arg_fail(1)) SWIG_fail;
11859 {
11860 PyThreadState* __tstate = wxPyBeginAllowThreads();
11861 result = (int)(arg1)->GetMovementThreshold();
11862
11863 wxPyEndAllowThreads(__tstate);
11864 if (PyErr_Occurred()) SWIG_fail;
11865 }
11866 {
11867 resultobj = SWIG_From_int((int)(result));
11868 }
11869 return resultobj;
11870 fail:
11871 return NULL;
11872 }
11873
11874
11875 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11876 PyObject *resultobj;
11877 wxJoystick *arg1 = (wxJoystick *) 0 ;
11878 int arg2 ;
11879 PyObject * obj0 = 0 ;
11880 PyObject * obj1 = 0 ;
11881 char *kwnames[] = {
11882 (char *) "self",(char *) "threshold", NULL
11883 };
11884
11885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11887 if (SWIG_arg_fail(1)) SWIG_fail;
11888 {
11889 arg2 = (int)(SWIG_As_int(obj1));
11890 if (SWIG_arg_fail(2)) SWIG_fail;
11891 }
11892 {
11893 PyThreadState* __tstate = wxPyBeginAllowThreads();
11894 (arg1)->SetMovementThreshold(arg2);
11895
11896 wxPyEndAllowThreads(__tstate);
11897 if (PyErr_Occurred()) SWIG_fail;
11898 }
11899 Py_INCREF(Py_None); resultobj = Py_None;
11900 return resultobj;
11901 fail:
11902 return NULL;
11903 }
11904
11905
11906 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11907 PyObject *resultobj;
11908 wxJoystick *arg1 = (wxJoystick *) 0 ;
11909 bool result;
11910 PyObject * obj0 = 0 ;
11911 char *kwnames[] = {
11912 (char *) "self", NULL
11913 };
11914
11915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11917 if (SWIG_arg_fail(1)) SWIG_fail;
11918 {
11919 PyThreadState* __tstate = wxPyBeginAllowThreads();
11920 result = (bool)(arg1)->IsOk();
11921
11922 wxPyEndAllowThreads(__tstate);
11923 if (PyErr_Occurred()) SWIG_fail;
11924 }
11925 {
11926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11927 }
11928 return resultobj;
11929 fail:
11930 return NULL;
11931 }
11932
11933
11934 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11935 PyObject *resultobj;
11936 wxJoystick *arg1 = (wxJoystick *) 0 ;
11937 int result;
11938 PyObject * obj0 = 0 ;
11939 char *kwnames[] = {
11940 (char *) "self", NULL
11941 };
11942
11943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11945 if (SWIG_arg_fail(1)) SWIG_fail;
11946 {
11947 PyThreadState* __tstate = wxPyBeginAllowThreads();
11948 result = (int)(arg1)->GetNumberJoysticks();
11949
11950 wxPyEndAllowThreads(__tstate);
11951 if (PyErr_Occurred()) SWIG_fail;
11952 }
11953 {
11954 resultobj = SWIG_From_int((int)(result));
11955 }
11956 return resultobj;
11957 fail:
11958 return NULL;
11959 }
11960
11961
11962 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11963 PyObject *resultobj;
11964 wxJoystick *arg1 = (wxJoystick *) 0 ;
11965 int result;
11966 PyObject * obj0 = 0 ;
11967 char *kwnames[] = {
11968 (char *) "self", NULL
11969 };
11970
11971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11973 if (SWIG_arg_fail(1)) SWIG_fail;
11974 {
11975 PyThreadState* __tstate = wxPyBeginAllowThreads();
11976 result = (int)(arg1)->GetManufacturerId();
11977
11978 wxPyEndAllowThreads(__tstate);
11979 if (PyErr_Occurred()) SWIG_fail;
11980 }
11981 {
11982 resultobj = SWIG_From_int((int)(result));
11983 }
11984 return resultobj;
11985 fail:
11986 return NULL;
11987 }
11988
11989
11990 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11991 PyObject *resultobj;
11992 wxJoystick *arg1 = (wxJoystick *) 0 ;
11993 int result;
11994 PyObject * obj0 = 0 ;
11995 char *kwnames[] = {
11996 (char *) "self", NULL
11997 };
11998
11999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12001 if (SWIG_arg_fail(1)) SWIG_fail;
12002 {
12003 PyThreadState* __tstate = wxPyBeginAllowThreads();
12004 result = (int)(arg1)->GetProductId();
12005
12006 wxPyEndAllowThreads(__tstate);
12007 if (PyErr_Occurred()) SWIG_fail;
12008 }
12009 {
12010 resultobj = SWIG_From_int((int)(result));
12011 }
12012 return resultobj;
12013 fail:
12014 return NULL;
12015 }
12016
12017
12018 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12019 PyObject *resultobj;
12020 wxJoystick *arg1 = (wxJoystick *) 0 ;
12021 wxString result;
12022 PyObject * obj0 = 0 ;
12023 char *kwnames[] = {
12024 (char *) "self", NULL
12025 };
12026
12027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12029 if (SWIG_arg_fail(1)) SWIG_fail;
12030 {
12031 PyThreadState* __tstate = wxPyBeginAllowThreads();
12032 result = (arg1)->GetProductName();
12033
12034 wxPyEndAllowThreads(__tstate);
12035 if (PyErr_Occurred()) SWIG_fail;
12036 }
12037 {
12038 #if wxUSE_UNICODE
12039 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12040 #else
12041 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12042 #endif
12043 }
12044 return resultobj;
12045 fail:
12046 return NULL;
12047 }
12048
12049
12050 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12051 PyObject *resultobj;
12052 wxJoystick *arg1 = (wxJoystick *) 0 ;
12053 int result;
12054 PyObject * obj0 = 0 ;
12055 char *kwnames[] = {
12056 (char *) "self", NULL
12057 };
12058
12059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12061 if (SWIG_arg_fail(1)) SWIG_fail;
12062 {
12063 PyThreadState* __tstate = wxPyBeginAllowThreads();
12064 result = (int)(arg1)->GetXMin();
12065
12066 wxPyEndAllowThreads(__tstate);
12067 if (PyErr_Occurred()) SWIG_fail;
12068 }
12069 {
12070 resultobj = SWIG_From_int((int)(result));
12071 }
12072 return resultobj;
12073 fail:
12074 return NULL;
12075 }
12076
12077
12078 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12079 PyObject *resultobj;
12080 wxJoystick *arg1 = (wxJoystick *) 0 ;
12081 int result;
12082 PyObject * obj0 = 0 ;
12083 char *kwnames[] = {
12084 (char *) "self", NULL
12085 };
12086
12087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12089 if (SWIG_arg_fail(1)) SWIG_fail;
12090 {
12091 PyThreadState* __tstate = wxPyBeginAllowThreads();
12092 result = (int)(arg1)->GetYMin();
12093
12094 wxPyEndAllowThreads(__tstate);
12095 if (PyErr_Occurred()) SWIG_fail;
12096 }
12097 {
12098 resultobj = SWIG_From_int((int)(result));
12099 }
12100 return resultobj;
12101 fail:
12102 return NULL;
12103 }
12104
12105
12106 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12107 PyObject *resultobj;
12108 wxJoystick *arg1 = (wxJoystick *) 0 ;
12109 int result;
12110 PyObject * obj0 = 0 ;
12111 char *kwnames[] = {
12112 (char *) "self", NULL
12113 };
12114
12115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12117 if (SWIG_arg_fail(1)) SWIG_fail;
12118 {
12119 PyThreadState* __tstate = wxPyBeginAllowThreads();
12120 result = (int)(arg1)->GetZMin();
12121
12122 wxPyEndAllowThreads(__tstate);
12123 if (PyErr_Occurred()) SWIG_fail;
12124 }
12125 {
12126 resultobj = SWIG_From_int((int)(result));
12127 }
12128 return resultobj;
12129 fail:
12130 return NULL;
12131 }
12132
12133
12134 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12135 PyObject *resultobj;
12136 wxJoystick *arg1 = (wxJoystick *) 0 ;
12137 int result;
12138 PyObject * obj0 = 0 ;
12139 char *kwnames[] = {
12140 (char *) "self", NULL
12141 };
12142
12143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12145 if (SWIG_arg_fail(1)) SWIG_fail;
12146 {
12147 PyThreadState* __tstate = wxPyBeginAllowThreads();
12148 result = (int)(arg1)->GetXMax();
12149
12150 wxPyEndAllowThreads(__tstate);
12151 if (PyErr_Occurred()) SWIG_fail;
12152 }
12153 {
12154 resultobj = SWIG_From_int((int)(result));
12155 }
12156 return resultobj;
12157 fail:
12158 return NULL;
12159 }
12160
12161
12162 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12163 PyObject *resultobj;
12164 wxJoystick *arg1 = (wxJoystick *) 0 ;
12165 int result;
12166 PyObject * obj0 = 0 ;
12167 char *kwnames[] = {
12168 (char *) "self", NULL
12169 };
12170
12171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12173 if (SWIG_arg_fail(1)) SWIG_fail;
12174 {
12175 PyThreadState* __tstate = wxPyBeginAllowThreads();
12176 result = (int)(arg1)->GetYMax();
12177
12178 wxPyEndAllowThreads(__tstate);
12179 if (PyErr_Occurred()) SWIG_fail;
12180 }
12181 {
12182 resultobj = SWIG_From_int((int)(result));
12183 }
12184 return resultobj;
12185 fail:
12186 return NULL;
12187 }
12188
12189
12190 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12191 PyObject *resultobj;
12192 wxJoystick *arg1 = (wxJoystick *) 0 ;
12193 int result;
12194 PyObject * obj0 = 0 ;
12195 char *kwnames[] = {
12196 (char *) "self", NULL
12197 };
12198
12199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12201 if (SWIG_arg_fail(1)) SWIG_fail;
12202 {
12203 PyThreadState* __tstate = wxPyBeginAllowThreads();
12204 result = (int)(arg1)->GetZMax();
12205
12206 wxPyEndAllowThreads(__tstate);
12207 if (PyErr_Occurred()) SWIG_fail;
12208 }
12209 {
12210 resultobj = SWIG_From_int((int)(result));
12211 }
12212 return resultobj;
12213 fail:
12214 return NULL;
12215 }
12216
12217
12218 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12219 PyObject *resultobj;
12220 wxJoystick *arg1 = (wxJoystick *) 0 ;
12221 int result;
12222 PyObject * obj0 = 0 ;
12223 char *kwnames[] = {
12224 (char *) "self", NULL
12225 };
12226
12227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12229 if (SWIG_arg_fail(1)) SWIG_fail;
12230 {
12231 PyThreadState* __tstate = wxPyBeginAllowThreads();
12232 result = (int)(arg1)->GetNumberButtons();
12233
12234 wxPyEndAllowThreads(__tstate);
12235 if (PyErr_Occurred()) SWIG_fail;
12236 }
12237 {
12238 resultobj = SWIG_From_int((int)(result));
12239 }
12240 return resultobj;
12241 fail:
12242 return NULL;
12243 }
12244
12245
12246 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12247 PyObject *resultobj;
12248 wxJoystick *arg1 = (wxJoystick *) 0 ;
12249 int result;
12250 PyObject * obj0 = 0 ;
12251 char *kwnames[] = {
12252 (char *) "self", NULL
12253 };
12254
12255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12257 if (SWIG_arg_fail(1)) SWIG_fail;
12258 {
12259 PyThreadState* __tstate = wxPyBeginAllowThreads();
12260 result = (int)(arg1)->GetNumberAxes();
12261
12262 wxPyEndAllowThreads(__tstate);
12263 if (PyErr_Occurred()) SWIG_fail;
12264 }
12265 {
12266 resultobj = SWIG_From_int((int)(result));
12267 }
12268 return resultobj;
12269 fail:
12270 return NULL;
12271 }
12272
12273
12274 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12275 PyObject *resultobj;
12276 wxJoystick *arg1 = (wxJoystick *) 0 ;
12277 int result;
12278 PyObject * obj0 = 0 ;
12279 char *kwnames[] = {
12280 (char *) "self", NULL
12281 };
12282
12283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12285 if (SWIG_arg_fail(1)) SWIG_fail;
12286 {
12287 PyThreadState* __tstate = wxPyBeginAllowThreads();
12288 result = (int)(arg1)->GetMaxButtons();
12289
12290 wxPyEndAllowThreads(__tstate);
12291 if (PyErr_Occurred()) SWIG_fail;
12292 }
12293 {
12294 resultobj = SWIG_From_int((int)(result));
12295 }
12296 return resultobj;
12297 fail:
12298 return NULL;
12299 }
12300
12301
12302 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12303 PyObject *resultobj;
12304 wxJoystick *arg1 = (wxJoystick *) 0 ;
12305 int result;
12306 PyObject * obj0 = 0 ;
12307 char *kwnames[] = {
12308 (char *) "self", NULL
12309 };
12310
12311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12313 if (SWIG_arg_fail(1)) SWIG_fail;
12314 {
12315 PyThreadState* __tstate = wxPyBeginAllowThreads();
12316 result = (int)(arg1)->GetMaxAxes();
12317
12318 wxPyEndAllowThreads(__tstate);
12319 if (PyErr_Occurred()) SWIG_fail;
12320 }
12321 {
12322 resultobj = SWIG_From_int((int)(result));
12323 }
12324 return resultobj;
12325 fail:
12326 return NULL;
12327 }
12328
12329
12330 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12331 PyObject *resultobj;
12332 wxJoystick *arg1 = (wxJoystick *) 0 ;
12333 int result;
12334 PyObject * obj0 = 0 ;
12335 char *kwnames[] = {
12336 (char *) "self", NULL
12337 };
12338
12339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12341 if (SWIG_arg_fail(1)) SWIG_fail;
12342 {
12343 PyThreadState* __tstate = wxPyBeginAllowThreads();
12344 result = (int)(arg1)->GetPollingMin();
12345
12346 wxPyEndAllowThreads(__tstate);
12347 if (PyErr_Occurred()) SWIG_fail;
12348 }
12349 {
12350 resultobj = SWIG_From_int((int)(result));
12351 }
12352 return resultobj;
12353 fail:
12354 return NULL;
12355 }
12356
12357
12358 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12359 PyObject *resultobj;
12360 wxJoystick *arg1 = (wxJoystick *) 0 ;
12361 int result;
12362 PyObject * obj0 = 0 ;
12363 char *kwnames[] = {
12364 (char *) "self", NULL
12365 };
12366
12367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12369 if (SWIG_arg_fail(1)) SWIG_fail;
12370 {
12371 PyThreadState* __tstate = wxPyBeginAllowThreads();
12372 result = (int)(arg1)->GetPollingMax();
12373
12374 wxPyEndAllowThreads(__tstate);
12375 if (PyErr_Occurred()) SWIG_fail;
12376 }
12377 {
12378 resultobj = SWIG_From_int((int)(result));
12379 }
12380 return resultobj;
12381 fail:
12382 return NULL;
12383 }
12384
12385
12386 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12387 PyObject *resultobj;
12388 wxJoystick *arg1 = (wxJoystick *) 0 ;
12389 int result;
12390 PyObject * obj0 = 0 ;
12391 char *kwnames[] = {
12392 (char *) "self", NULL
12393 };
12394
12395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12397 if (SWIG_arg_fail(1)) SWIG_fail;
12398 {
12399 PyThreadState* __tstate = wxPyBeginAllowThreads();
12400 result = (int)(arg1)->GetRudderMin();
12401
12402 wxPyEndAllowThreads(__tstate);
12403 if (PyErr_Occurred()) SWIG_fail;
12404 }
12405 {
12406 resultobj = SWIG_From_int((int)(result));
12407 }
12408 return resultobj;
12409 fail:
12410 return NULL;
12411 }
12412
12413
12414 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj;
12416 wxJoystick *arg1 = (wxJoystick *) 0 ;
12417 int result;
12418 PyObject * obj0 = 0 ;
12419 char *kwnames[] = {
12420 (char *) "self", NULL
12421 };
12422
12423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12425 if (SWIG_arg_fail(1)) SWIG_fail;
12426 {
12427 PyThreadState* __tstate = wxPyBeginAllowThreads();
12428 result = (int)(arg1)->GetRudderMax();
12429
12430 wxPyEndAllowThreads(__tstate);
12431 if (PyErr_Occurred()) SWIG_fail;
12432 }
12433 {
12434 resultobj = SWIG_From_int((int)(result));
12435 }
12436 return resultobj;
12437 fail:
12438 return NULL;
12439 }
12440
12441
12442 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12443 PyObject *resultobj;
12444 wxJoystick *arg1 = (wxJoystick *) 0 ;
12445 int result;
12446 PyObject * obj0 = 0 ;
12447 char *kwnames[] = {
12448 (char *) "self", NULL
12449 };
12450
12451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12453 if (SWIG_arg_fail(1)) SWIG_fail;
12454 {
12455 PyThreadState* __tstate = wxPyBeginAllowThreads();
12456 result = (int)(arg1)->GetUMin();
12457
12458 wxPyEndAllowThreads(__tstate);
12459 if (PyErr_Occurred()) SWIG_fail;
12460 }
12461 {
12462 resultobj = SWIG_From_int((int)(result));
12463 }
12464 return resultobj;
12465 fail:
12466 return NULL;
12467 }
12468
12469
12470 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12471 PyObject *resultobj;
12472 wxJoystick *arg1 = (wxJoystick *) 0 ;
12473 int result;
12474 PyObject * obj0 = 0 ;
12475 char *kwnames[] = {
12476 (char *) "self", NULL
12477 };
12478
12479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12481 if (SWIG_arg_fail(1)) SWIG_fail;
12482 {
12483 PyThreadState* __tstate = wxPyBeginAllowThreads();
12484 result = (int)(arg1)->GetUMax();
12485
12486 wxPyEndAllowThreads(__tstate);
12487 if (PyErr_Occurred()) SWIG_fail;
12488 }
12489 {
12490 resultobj = SWIG_From_int((int)(result));
12491 }
12492 return resultobj;
12493 fail:
12494 return NULL;
12495 }
12496
12497
12498 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12499 PyObject *resultobj;
12500 wxJoystick *arg1 = (wxJoystick *) 0 ;
12501 int result;
12502 PyObject * obj0 = 0 ;
12503 char *kwnames[] = {
12504 (char *) "self", NULL
12505 };
12506
12507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12509 if (SWIG_arg_fail(1)) SWIG_fail;
12510 {
12511 PyThreadState* __tstate = wxPyBeginAllowThreads();
12512 result = (int)(arg1)->GetVMin();
12513
12514 wxPyEndAllowThreads(__tstate);
12515 if (PyErr_Occurred()) SWIG_fail;
12516 }
12517 {
12518 resultobj = SWIG_From_int((int)(result));
12519 }
12520 return resultobj;
12521 fail:
12522 return NULL;
12523 }
12524
12525
12526 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12527 PyObject *resultobj;
12528 wxJoystick *arg1 = (wxJoystick *) 0 ;
12529 int result;
12530 PyObject * obj0 = 0 ;
12531 char *kwnames[] = {
12532 (char *) "self", NULL
12533 };
12534
12535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12537 if (SWIG_arg_fail(1)) SWIG_fail;
12538 {
12539 PyThreadState* __tstate = wxPyBeginAllowThreads();
12540 result = (int)(arg1)->GetVMax();
12541
12542 wxPyEndAllowThreads(__tstate);
12543 if (PyErr_Occurred()) SWIG_fail;
12544 }
12545 {
12546 resultobj = SWIG_From_int((int)(result));
12547 }
12548 return resultobj;
12549 fail:
12550 return NULL;
12551 }
12552
12553
12554 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12555 PyObject *resultobj;
12556 wxJoystick *arg1 = (wxJoystick *) 0 ;
12557 bool result;
12558 PyObject * obj0 = 0 ;
12559 char *kwnames[] = {
12560 (char *) "self", NULL
12561 };
12562
12563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12565 if (SWIG_arg_fail(1)) SWIG_fail;
12566 {
12567 PyThreadState* __tstate = wxPyBeginAllowThreads();
12568 result = (bool)(arg1)->HasRudder();
12569
12570 wxPyEndAllowThreads(__tstate);
12571 if (PyErr_Occurred()) SWIG_fail;
12572 }
12573 {
12574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12575 }
12576 return resultobj;
12577 fail:
12578 return NULL;
12579 }
12580
12581
12582 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12583 PyObject *resultobj;
12584 wxJoystick *arg1 = (wxJoystick *) 0 ;
12585 bool result;
12586 PyObject * obj0 = 0 ;
12587 char *kwnames[] = {
12588 (char *) "self", NULL
12589 };
12590
12591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12593 if (SWIG_arg_fail(1)) SWIG_fail;
12594 {
12595 PyThreadState* __tstate = wxPyBeginAllowThreads();
12596 result = (bool)(arg1)->HasZ();
12597
12598 wxPyEndAllowThreads(__tstate);
12599 if (PyErr_Occurred()) SWIG_fail;
12600 }
12601 {
12602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12603 }
12604 return resultobj;
12605 fail:
12606 return NULL;
12607 }
12608
12609
12610 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12611 PyObject *resultobj;
12612 wxJoystick *arg1 = (wxJoystick *) 0 ;
12613 bool result;
12614 PyObject * obj0 = 0 ;
12615 char *kwnames[] = {
12616 (char *) "self", NULL
12617 };
12618
12619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12621 if (SWIG_arg_fail(1)) SWIG_fail;
12622 {
12623 PyThreadState* __tstate = wxPyBeginAllowThreads();
12624 result = (bool)(arg1)->HasU();
12625
12626 wxPyEndAllowThreads(__tstate);
12627 if (PyErr_Occurred()) SWIG_fail;
12628 }
12629 {
12630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12631 }
12632 return resultobj;
12633 fail:
12634 return NULL;
12635 }
12636
12637
12638 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12639 PyObject *resultobj;
12640 wxJoystick *arg1 = (wxJoystick *) 0 ;
12641 bool result;
12642 PyObject * obj0 = 0 ;
12643 char *kwnames[] = {
12644 (char *) "self", NULL
12645 };
12646
12647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12649 if (SWIG_arg_fail(1)) SWIG_fail;
12650 {
12651 PyThreadState* __tstate = wxPyBeginAllowThreads();
12652 result = (bool)(arg1)->HasV();
12653
12654 wxPyEndAllowThreads(__tstate);
12655 if (PyErr_Occurred()) SWIG_fail;
12656 }
12657 {
12658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12659 }
12660 return resultobj;
12661 fail:
12662 return NULL;
12663 }
12664
12665
12666 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12667 PyObject *resultobj;
12668 wxJoystick *arg1 = (wxJoystick *) 0 ;
12669 bool result;
12670 PyObject * obj0 = 0 ;
12671 char *kwnames[] = {
12672 (char *) "self", NULL
12673 };
12674
12675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12677 if (SWIG_arg_fail(1)) SWIG_fail;
12678 {
12679 PyThreadState* __tstate = wxPyBeginAllowThreads();
12680 result = (bool)(arg1)->HasPOV();
12681
12682 wxPyEndAllowThreads(__tstate);
12683 if (PyErr_Occurred()) SWIG_fail;
12684 }
12685 {
12686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12687 }
12688 return resultobj;
12689 fail:
12690 return NULL;
12691 }
12692
12693
12694 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12695 PyObject *resultobj;
12696 wxJoystick *arg1 = (wxJoystick *) 0 ;
12697 bool result;
12698 PyObject * obj0 = 0 ;
12699 char *kwnames[] = {
12700 (char *) "self", NULL
12701 };
12702
12703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12705 if (SWIG_arg_fail(1)) SWIG_fail;
12706 {
12707 PyThreadState* __tstate = wxPyBeginAllowThreads();
12708 result = (bool)(arg1)->HasPOV4Dir();
12709
12710 wxPyEndAllowThreads(__tstate);
12711 if (PyErr_Occurred()) SWIG_fail;
12712 }
12713 {
12714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12715 }
12716 return resultobj;
12717 fail:
12718 return NULL;
12719 }
12720
12721
12722 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12723 PyObject *resultobj;
12724 wxJoystick *arg1 = (wxJoystick *) 0 ;
12725 bool result;
12726 PyObject * obj0 = 0 ;
12727 char *kwnames[] = {
12728 (char *) "self", NULL
12729 };
12730
12731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12733 if (SWIG_arg_fail(1)) SWIG_fail;
12734 {
12735 PyThreadState* __tstate = wxPyBeginAllowThreads();
12736 result = (bool)(arg1)->HasPOVCTS();
12737
12738 wxPyEndAllowThreads(__tstate);
12739 if (PyErr_Occurred()) SWIG_fail;
12740 }
12741 {
12742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12743 }
12744 return resultobj;
12745 fail:
12746 return NULL;
12747 }
12748
12749
12750 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12751 PyObject *resultobj;
12752 wxJoystick *arg1 = (wxJoystick *) 0 ;
12753 wxWindow *arg2 = (wxWindow *) 0 ;
12754 int arg3 = (int) 0 ;
12755 bool result;
12756 PyObject * obj0 = 0 ;
12757 PyObject * obj1 = 0 ;
12758 PyObject * obj2 = 0 ;
12759 char *kwnames[] = {
12760 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12761 };
12762
12763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12765 if (SWIG_arg_fail(1)) SWIG_fail;
12766 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12767 if (SWIG_arg_fail(2)) SWIG_fail;
12768 if (obj2) {
12769 {
12770 arg3 = (int)(SWIG_As_int(obj2));
12771 if (SWIG_arg_fail(3)) SWIG_fail;
12772 }
12773 }
12774 {
12775 PyThreadState* __tstate = wxPyBeginAllowThreads();
12776 result = (bool)(arg1)->SetCapture(arg2,arg3);
12777
12778 wxPyEndAllowThreads(__tstate);
12779 if (PyErr_Occurred()) SWIG_fail;
12780 }
12781 {
12782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12783 }
12784 return resultobj;
12785 fail:
12786 return NULL;
12787 }
12788
12789
12790 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12791 PyObject *resultobj;
12792 wxJoystick *arg1 = (wxJoystick *) 0 ;
12793 bool result;
12794 PyObject * obj0 = 0 ;
12795 char *kwnames[] = {
12796 (char *) "self", NULL
12797 };
12798
12799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12801 if (SWIG_arg_fail(1)) SWIG_fail;
12802 {
12803 PyThreadState* __tstate = wxPyBeginAllowThreads();
12804 result = (bool)(arg1)->ReleaseCapture();
12805
12806 wxPyEndAllowThreads(__tstate);
12807 if (PyErr_Occurred()) SWIG_fail;
12808 }
12809 {
12810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12811 }
12812 return resultobj;
12813 fail:
12814 return NULL;
12815 }
12816
12817
12818 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12819 PyObject *obj;
12820 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12821 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12822 Py_INCREF(obj);
12823 return Py_BuildValue((char *)"");
12824 }
12825 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12826 PyObject *resultobj;
12827 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12828 int arg2 = (int) 0 ;
12829 int arg3 = (int) wxJOYSTICK1 ;
12830 int arg4 = (int) 0 ;
12831 wxJoystickEvent *result;
12832 PyObject * obj0 = 0 ;
12833 PyObject * obj1 = 0 ;
12834 PyObject * obj2 = 0 ;
12835 PyObject * obj3 = 0 ;
12836 char *kwnames[] = {
12837 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12838 };
12839
12840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12841 if (obj0) {
12842 {
12843 arg1 = (wxEventType)(SWIG_As_int(obj0));
12844 if (SWIG_arg_fail(1)) SWIG_fail;
12845 }
12846 }
12847 if (obj1) {
12848 {
12849 arg2 = (int)(SWIG_As_int(obj1));
12850 if (SWIG_arg_fail(2)) SWIG_fail;
12851 }
12852 }
12853 if (obj2) {
12854 {
12855 arg3 = (int)(SWIG_As_int(obj2));
12856 if (SWIG_arg_fail(3)) SWIG_fail;
12857 }
12858 }
12859 if (obj3) {
12860 {
12861 arg4 = (int)(SWIG_As_int(obj3));
12862 if (SWIG_arg_fail(4)) SWIG_fail;
12863 }
12864 }
12865 {
12866 PyThreadState* __tstate = wxPyBeginAllowThreads();
12867 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12868
12869 wxPyEndAllowThreads(__tstate);
12870 if (PyErr_Occurred()) SWIG_fail;
12871 }
12872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12873 return resultobj;
12874 fail:
12875 return NULL;
12876 }
12877
12878
12879 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12880 PyObject *resultobj;
12881 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12882 wxPoint result;
12883 PyObject * obj0 = 0 ;
12884 char *kwnames[] = {
12885 (char *) "self", NULL
12886 };
12887
12888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12890 if (SWIG_arg_fail(1)) SWIG_fail;
12891 {
12892 PyThreadState* __tstate = wxPyBeginAllowThreads();
12893 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12894
12895 wxPyEndAllowThreads(__tstate);
12896 if (PyErr_Occurred()) SWIG_fail;
12897 }
12898 {
12899 wxPoint * resultptr;
12900 resultptr = new wxPoint((wxPoint &)(result));
12901 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12902 }
12903 return resultobj;
12904 fail:
12905 return NULL;
12906 }
12907
12908
12909 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12910 PyObject *resultobj;
12911 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12912 int result;
12913 PyObject * obj0 = 0 ;
12914 char *kwnames[] = {
12915 (char *) "self", NULL
12916 };
12917
12918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12920 if (SWIG_arg_fail(1)) SWIG_fail;
12921 {
12922 PyThreadState* __tstate = wxPyBeginAllowThreads();
12923 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12924
12925 wxPyEndAllowThreads(__tstate);
12926 if (PyErr_Occurred()) SWIG_fail;
12927 }
12928 {
12929 resultobj = SWIG_From_int((int)(result));
12930 }
12931 return resultobj;
12932 fail:
12933 return NULL;
12934 }
12935
12936
12937 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12938 PyObject *resultobj;
12939 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12940 int result;
12941 PyObject * obj0 = 0 ;
12942 char *kwnames[] = {
12943 (char *) "self", NULL
12944 };
12945
12946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12948 if (SWIG_arg_fail(1)) SWIG_fail;
12949 {
12950 PyThreadState* __tstate = wxPyBeginAllowThreads();
12951 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12952
12953 wxPyEndAllowThreads(__tstate);
12954 if (PyErr_Occurred()) SWIG_fail;
12955 }
12956 {
12957 resultobj = SWIG_From_int((int)(result));
12958 }
12959 return resultobj;
12960 fail:
12961 return NULL;
12962 }
12963
12964
12965 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12966 PyObject *resultobj;
12967 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12968 int result;
12969 PyObject * obj0 = 0 ;
12970 char *kwnames[] = {
12971 (char *) "self", NULL
12972 };
12973
12974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12976 if (SWIG_arg_fail(1)) SWIG_fail;
12977 {
12978 PyThreadState* __tstate = wxPyBeginAllowThreads();
12979 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12980
12981 wxPyEndAllowThreads(__tstate);
12982 if (PyErr_Occurred()) SWIG_fail;
12983 }
12984 {
12985 resultobj = SWIG_From_int((int)(result));
12986 }
12987 return resultobj;
12988 fail:
12989 return NULL;
12990 }
12991
12992
12993 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12994 PyObject *resultobj;
12995 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12996 int result;
12997 PyObject * obj0 = 0 ;
12998 char *kwnames[] = {
12999 (char *) "self", NULL
13000 };
13001
13002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13004 if (SWIG_arg_fail(1)) SWIG_fail;
13005 {
13006 PyThreadState* __tstate = wxPyBeginAllowThreads();
13007 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13008
13009 wxPyEndAllowThreads(__tstate);
13010 if (PyErr_Occurred()) SWIG_fail;
13011 }
13012 {
13013 resultobj = SWIG_From_int((int)(result));
13014 }
13015 return resultobj;
13016 fail:
13017 return NULL;
13018 }
13019
13020
13021 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13022 PyObject *resultobj;
13023 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13024 int arg2 ;
13025 PyObject * obj0 = 0 ;
13026 PyObject * obj1 = 0 ;
13027 char *kwnames[] = {
13028 (char *) "self",(char *) "stick", NULL
13029 };
13030
13031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13033 if (SWIG_arg_fail(1)) SWIG_fail;
13034 {
13035 arg2 = (int)(SWIG_As_int(obj1));
13036 if (SWIG_arg_fail(2)) SWIG_fail;
13037 }
13038 {
13039 PyThreadState* __tstate = wxPyBeginAllowThreads();
13040 (arg1)->SetJoystick(arg2);
13041
13042 wxPyEndAllowThreads(__tstate);
13043 if (PyErr_Occurred()) SWIG_fail;
13044 }
13045 Py_INCREF(Py_None); resultobj = Py_None;
13046 return resultobj;
13047 fail:
13048 return NULL;
13049 }
13050
13051
13052 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13053 PyObject *resultobj;
13054 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13055 int arg2 ;
13056 PyObject * obj0 = 0 ;
13057 PyObject * obj1 = 0 ;
13058 char *kwnames[] = {
13059 (char *) "self",(char *) "state", NULL
13060 };
13061
13062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13064 if (SWIG_arg_fail(1)) SWIG_fail;
13065 {
13066 arg2 = (int)(SWIG_As_int(obj1));
13067 if (SWIG_arg_fail(2)) SWIG_fail;
13068 }
13069 {
13070 PyThreadState* __tstate = wxPyBeginAllowThreads();
13071 (arg1)->SetButtonState(arg2);
13072
13073 wxPyEndAllowThreads(__tstate);
13074 if (PyErr_Occurred()) SWIG_fail;
13075 }
13076 Py_INCREF(Py_None); resultobj = Py_None;
13077 return resultobj;
13078 fail:
13079 return NULL;
13080 }
13081
13082
13083 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13084 PyObject *resultobj;
13085 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13086 int arg2 ;
13087 PyObject * obj0 = 0 ;
13088 PyObject * obj1 = 0 ;
13089 char *kwnames[] = {
13090 (char *) "self",(char *) "change", NULL
13091 };
13092
13093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13095 if (SWIG_arg_fail(1)) SWIG_fail;
13096 {
13097 arg2 = (int)(SWIG_As_int(obj1));
13098 if (SWIG_arg_fail(2)) SWIG_fail;
13099 }
13100 {
13101 PyThreadState* __tstate = wxPyBeginAllowThreads();
13102 (arg1)->SetButtonChange(arg2);
13103
13104 wxPyEndAllowThreads(__tstate);
13105 if (PyErr_Occurred()) SWIG_fail;
13106 }
13107 Py_INCREF(Py_None); resultobj = Py_None;
13108 return resultobj;
13109 fail:
13110 return NULL;
13111 }
13112
13113
13114 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13115 PyObject *resultobj;
13116 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13117 wxPoint *arg2 = 0 ;
13118 wxPoint temp2 ;
13119 PyObject * obj0 = 0 ;
13120 PyObject * obj1 = 0 ;
13121 char *kwnames[] = {
13122 (char *) "self",(char *) "pos", NULL
13123 };
13124
13125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13127 if (SWIG_arg_fail(1)) SWIG_fail;
13128 {
13129 arg2 = &temp2;
13130 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13131 }
13132 {
13133 PyThreadState* __tstate = wxPyBeginAllowThreads();
13134 (arg1)->SetPosition((wxPoint const &)*arg2);
13135
13136 wxPyEndAllowThreads(__tstate);
13137 if (PyErr_Occurred()) SWIG_fail;
13138 }
13139 Py_INCREF(Py_None); resultobj = Py_None;
13140 return resultobj;
13141 fail:
13142 return NULL;
13143 }
13144
13145
13146 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13147 PyObject *resultobj;
13148 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13149 int arg2 ;
13150 PyObject * obj0 = 0 ;
13151 PyObject * obj1 = 0 ;
13152 char *kwnames[] = {
13153 (char *) "self",(char *) "zPos", NULL
13154 };
13155
13156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13158 if (SWIG_arg_fail(1)) SWIG_fail;
13159 {
13160 arg2 = (int)(SWIG_As_int(obj1));
13161 if (SWIG_arg_fail(2)) SWIG_fail;
13162 }
13163 {
13164 PyThreadState* __tstate = wxPyBeginAllowThreads();
13165 (arg1)->SetZPosition(arg2);
13166
13167 wxPyEndAllowThreads(__tstate);
13168 if (PyErr_Occurred()) SWIG_fail;
13169 }
13170 Py_INCREF(Py_None); resultobj = Py_None;
13171 return resultobj;
13172 fail:
13173 return NULL;
13174 }
13175
13176
13177 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13178 PyObject *resultobj;
13179 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13180 bool result;
13181 PyObject * obj0 = 0 ;
13182 char *kwnames[] = {
13183 (char *) "self", NULL
13184 };
13185
13186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13188 if (SWIG_arg_fail(1)) SWIG_fail;
13189 {
13190 PyThreadState* __tstate = wxPyBeginAllowThreads();
13191 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13192
13193 wxPyEndAllowThreads(__tstate);
13194 if (PyErr_Occurred()) SWIG_fail;
13195 }
13196 {
13197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13198 }
13199 return resultobj;
13200 fail:
13201 return NULL;
13202 }
13203
13204
13205 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13206 PyObject *resultobj;
13207 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13208 bool result;
13209 PyObject * obj0 = 0 ;
13210 char *kwnames[] = {
13211 (char *) "self", NULL
13212 };
13213
13214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13216 if (SWIG_arg_fail(1)) SWIG_fail;
13217 {
13218 PyThreadState* __tstate = wxPyBeginAllowThreads();
13219 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13220
13221 wxPyEndAllowThreads(__tstate);
13222 if (PyErr_Occurred()) SWIG_fail;
13223 }
13224 {
13225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13226 }
13227 return resultobj;
13228 fail:
13229 return NULL;
13230 }
13231
13232
13233 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13234 PyObject *resultobj;
13235 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13236 bool result;
13237 PyObject * obj0 = 0 ;
13238 char *kwnames[] = {
13239 (char *) "self", NULL
13240 };
13241
13242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13244 if (SWIG_arg_fail(1)) SWIG_fail;
13245 {
13246 PyThreadState* __tstate = wxPyBeginAllowThreads();
13247 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13248
13249 wxPyEndAllowThreads(__tstate);
13250 if (PyErr_Occurred()) SWIG_fail;
13251 }
13252 {
13253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13254 }
13255 return resultobj;
13256 fail:
13257 return NULL;
13258 }
13259
13260
13261 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13262 PyObject *resultobj;
13263 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13264 int arg2 = (int) wxJOY_BUTTON_ANY ;
13265 bool result;
13266 PyObject * obj0 = 0 ;
13267 PyObject * obj1 = 0 ;
13268 char *kwnames[] = {
13269 (char *) "self",(char *) "but", NULL
13270 };
13271
13272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13274 if (SWIG_arg_fail(1)) SWIG_fail;
13275 if (obj1) {
13276 {
13277 arg2 = (int)(SWIG_As_int(obj1));
13278 if (SWIG_arg_fail(2)) SWIG_fail;
13279 }
13280 }
13281 {
13282 PyThreadState* __tstate = wxPyBeginAllowThreads();
13283 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13284
13285 wxPyEndAllowThreads(__tstate);
13286 if (PyErr_Occurred()) SWIG_fail;
13287 }
13288 {
13289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13290 }
13291 return resultobj;
13292 fail:
13293 return NULL;
13294 }
13295
13296
13297 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13298 PyObject *resultobj;
13299 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13300 int arg2 = (int) wxJOY_BUTTON_ANY ;
13301 bool result;
13302 PyObject * obj0 = 0 ;
13303 PyObject * obj1 = 0 ;
13304 char *kwnames[] = {
13305 (char *) "self",(char *) "but", NULL
13306 };
13307
13308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13310 if (SWIG_arg_fail(1)) SWIG_fail;
13311 if (obj1) {
13312 {
13313 arg2 = (int)(SWIG_As_int(obj1));
13314 if (SWIG_arg_fail(2)) SWIG_fail;
13315 }
13316 }
13317 {
13318 PyThreadState* __tstate = wxPyBeginAllowThreads();
13319 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13320
13321 wxPyEndAllowThreads(__tstate);
13322 if (PyErr_Occurred()) SWIG_fail;
13323 }
13324 {
13325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13326 }
13327 return resultobj;
13328 fail:
13329 return NULL;
13330 }
13331
13332
13333 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13334 PyObject *resultobj;
13335 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13336 int arg2 = (int) wxJOY_BUTTON_ANY ;
13337 bool result;
13338 PyObject * obj0 = 0 ;
13339 PyObject * obj1 = 0 ;
13340 char *kwnames[] = {
13341 (char *) "self",(char *) "but", NULL
13342 };
13343
13344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13346 if (SWIG_arg_fail(1)) SWIG_fail;
13347 if (obj1) {
13348 {
13349 arg2 = (int)(SWIG_As_int(obj1));
13350 if (SWIG_arg_fail(2)) SWIG_fail;
13351 }
13352 }
13353 {
13354 PyThreadState* __tstate = wxPyBeginAllowThreads();
13355 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13356
13357 wxPyEndAllowThreads(__tstate);
13358 if (PyErr_Occurred()) SWIG_fail;
13359 }
13360 {
13361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13362 }
13363 return resultobj;
13364 fail:
13365 return NULL;
13366 }
13367
13368
13369 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13370 PyObject *obj;
13371 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13372 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13373 Py_INCREF(obj);
13374 return Py_BuildValue((char *)"");
13375 }
13376 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13377 PyObject *resultobj;
13378 wxString const &arg1_defvalue = wxPyEmptyString ;
13379 wxString *arg1 = (wxString *) &arg1_defvalue ;
13380 wxSound *result;
13381 bool temp1 = false ;
13382 PyObject * obj0 = 0 ;
13383 char *kwnames[] = {
13384 (char *) "fileName", NULL
13385 };
13386
13387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13388 if (obj0) {
13389 {
13390 arg1 = wxString_in_helper(obj0);
13391 if (arg1 == NULL) SWIG_fail;
13392 temp1 = true;
13393 }
13394 }
13395 {
13396 if (!wxPyCheckForApp()) SWIG_fail;
13397 PyThreadState* __tstate = wxPyBeginAllowThreads();
13398 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13399
13400 wxPyEndAllowThreads(__tstate);
13401 if (PyErr_Occurred()) SWIG_fail;
13402 }
13403 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13404 {
13405 if (temp1)
13406 delete arg1;
13407 }
13408 return resultobj;
13409 fail:
13410 {
13411 if (temp1)
13412 delete arg1;
13413 }
13414 return NULL;
13415 }
13416
13417
13418 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13419 PyObject *resultobj;
13420 PyObject *arg1 = (PyObject *) 0 ;
13421 wxSound *result;
13422 PyObject * obj0 = 0 ;
13423 char *kwnames[] = {
13424 (char *) "data", NULL
13425 };
13426
13427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13428 arg1 = obj0;
13429 {
13430 if (!wxPyCheckForApp()) SWIG_fail;
13431 PyThreadState* __tstate = wxPyBeginAllowThreads();
13432 result = (wxSound *)new_wxSound(arg1);
13433
13434 wxPyEndAllowThreads(__tstate);
13435 if (PyErr_Occurred()) SWIG_fail;
13436 }
13437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13438 return resultobj;
13439 fail:
13440 return NULL;
13441 }
13442
13443
13444 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13445 PyObject *resultobj;
13446 wxSound *arg1 = (wxSound *) 0 ;
13447 PyObject * obj0 = 0 ;
13448 char *kwnames[] = {
13449 (char *) "self", NULL
13450 };
13451
13452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13454 if (SWIG_arg_fail(1)) SWIG_fail;
13455 {
13456 PyThreadState* __tstate = wxPyBeginAllowThreads();
13457 delete arg1;
13458
13459 wxPyEndAllowThreads(__tstate);
13460 if (PyErr_Occurred()) SWIG_fail;
13461 }
13462 Py_INCREF(Py_None); resultobj = Py_None;
13463 return resultobj;
13464 fail:
13465 return NULL;
13466 }
13467
13468
13469 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13470 PyObject *resultobj;
13471 wxSound *arg1 = (wxSound *) 0 ;
13472 wxString *arg2 = 0 ;
13473 bool result;
13474 bool temp2 = false ;
13475 PyObject * obj0 = 0 ;
13476 PyObject * obj1 = 0 ;
13477 char *kwnames[] = {
13478 (char *) "self",(char *) "fileName", NULL
13479 };
13480
13481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13483 if (SWIG_arg_fail(1)) SWIG_fail;
13484 {
13485 arg2 = wxString_in_helper(obj1);
13486 if (arg2 == NULL) SWIG_fail;
13487 temp2 = true;
13488 }
13489 {
13490 PyThreadState* __tstate = wxPyBeginAllowThreads();
13491 result = (bool)(arg1)->Create((wxString const &)*arg2);
13492
13493 wxPyEndAllowThreads(__tstate);
13494 if (PyErr_Occurred()) SWIG_fail;
13495 }
13496 {
13497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13498 }
13499 {
13500 if (temp2)
13501 delete arg2;
13502 }
13503 return resultobj;
13504 fail:
13505 {
13506 if (temp2)
13507 delete arg2;
13508 }
13509 return NULL;
13510 }
13511
13512
13513 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13514 PyObject *resultobj;
13515 wxSound *arg1 = (wxSound *) 0 ;
13516 PyObject *arg2 = (PyObject *) 0 ;
13517 bool result;
13518 PyObject * obj0 = 0 ;
13519 PyObject * obj1 = 0 ;
13520 char *kwnames[] = {
13521 (char *) "self",(char *) "data", NULL
13522 };
13523
13524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13526 if (SWIG_arg_fail(1)) SWIG_fail;
13527 arg2 = obj1;
13528 {
13529 PyThreadState* __tstate = wxPyBeginAllowThreads();
13530 result = (bool)wxSound_CreateFromData(arg1,arg2);
13531
13532 wxPyEndAllowThreads(__tstate);
13533 if (PyErr_Occurred()) SWIG_fail;
13534 }
13535 {
13536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13537 }
13538 return resultobj;
13539 fail:
13540 return NULL;
13541 }
13542
13543
13544 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13545 PyObject *resultobj;
13546 wxSound *arg1 = (wxSound *) 0 ;
13547 bool result;
13548 PyObject * obj0 = 0 ;
13549 char *kwnames[] = {
13550 (char *) "self", NULL
13551 };
13552
13553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13555 if (SWIG_arg_fail(1)) SWIG_fail;
13556 {
13557 PyThreadState* __tstate = wxPyBeginAllowThreads();
13558 result = (bool)(arg1)->IsOk();
13559
13560 wxPyEndAllowThreads(__tstate);
13561 if (PyErr_Occurred()) SWIG_fail;
13562 }
13563 {
13564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13565 }
13566 return resultobj;
13567 fail:
13568 return NULL;
13569 }
13570
13571
13572 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13573 PyObject *resultobj;
13574 wxSound *arg1 = (wxSound *) 0 ;
13575 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13576 bool result;
13577 PyObject * obj0 = 0 ;
13578 PyObject * obj1 = 0 ;
13579 char *kwnames[] = {
13580 (char *) "self",(char *) "flags", NULL
13581 };
13582
13583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13585 if (SWIG_arg_fail(1)) SWIG_fail;
13586 if (obj1) {
13587 {
13588 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13589 if (SWIG_arg_fail(2)) SWIG_fail;
13590 }
13591 }
13592 {
13593 if (!wxPyCheckForApp()) SWIG_fail;
13594 PyThreadState* __tstate = wxPyBeginAllowThreads();
13595 result = (bool)((wxSound const *)arg1)->Play(arg2);
13596
13597 wxPyEndAllowThreads(__tstate);
13598 if (PyErr_Occurred()) SWIG_fail;
13599 }
13600 {
13601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13602 }
13603 return resultobj;
13604 fail:
13605 return NULL;
13606 }
13607
13608
13609 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13610 PyObject *resultobj;
13611 wxString *arg1 = 0 ;
13612 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13613 bool result;
13614 bool temp1 = false ;
13615 PyObject * obj0 = 0 ;
13616 PyObject * obj1 = 0 ;
13617 char *kwnames[] = {
13618 (char *) "filename",(char *) "flags", NULL
13619 };
13620
13621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13622 {
13623 arg1 = wxString_in_helper(obj0);
13624 if (arg1 == NULL) SWIG_fail;
13625 temp1 = true;
13626 }
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::Play((wxString const &)*arg1,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 {
13645 if (temp1)
13646 delete arg1;
13647 }
13648 return resultobj;
13649 fail:
13650 {
13651 if (temp1)
13652 delete arg1;
13653 }
13654 return NULL;
13655 }
13656
13657
13658 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13659 PyObject *resultobj;
13660 char *kwnames[] = {
13661 NULL
13662 };
13663
13664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13665 {
13666 if (!wxPyCheckForApp()) SWIG_fail;
13667 PyThreadState* __tstate = wxPyBeginAllowThreads();
13668 wxSound::Stop();
13669
13670 wxPyEndAllowThreads(__tstate);
13671 if (PyErr_Occurred()) SWIG_fail;
13672 }
13673 Py_INCREF(Py_None); resultobj = Py_None;
13674 return resultobj;
13675 fail:
13676 return NULL;
13677 }
13678
13679
13680 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13681 PyObject *obj;
13682 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13683 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13684 Py_INCREF(obj);
13685 return Py_BuildValue((char *)"");
13686 }
13687 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13688 PyObject *resultobj;
13689 wxString *arg1 = 0 ;
13690 wxString *arg2 = 0 ;
13691 wxString *arg3 = 0 ;
13692 wxString *arg4 = 0 ;
13693 wxFileTypeInfo *result;
13694 bool temp1 = false ;
13695 bool temp2 = false ;
13696 bool temp3 = false ;
13697 bool temp4 = false ;
13698 PyObject * obj0 = 0 ;
13699 PyObject * obj1 = 0 ;
13700 PyObject * obj2 = 0 ;
13701 PyObject * obj3 = 0 ;
13702 char *kwnames[] = {
13703 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13704 };
13705
13706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13707 {
13708 arg1 = wxString_in_helper(obj0);
13709 if (arg1 == NULL) SWIG_fail;
13710 temp1 = true;
13711 }
13712 {
13713 arg2 = wxString_in_helper(obj1);
13714 if (arg2 == NULL) SWIG_fail;
13715 temp2 = true;
13716 }
13717 {
13718 arg3 = wxString_in_helper(obj2);
13719 if (arg3 == NULL) SWIG_fail;
13720 temp3 = true;
13721 }
13722 {
13723 arg4 = wxString_in_helper(obj3);
13724 if (arg4 == NULL) SWIG_fail;
13725 temp4 = true;
13726 }
13727 {
13728 PyThreadState* __tstate = wxPyBeginAllowThreads();
13729 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13730
13731 wxPyEndAllowThreads(__tstate);
13732 if (PyErr_Occurred()) SWIG_fail;
13733 }
13734 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13735 {
13736 if (temp1)
13737 delete arg1;
13738 }
13739 {
13740 if (temp2)
13741 delete arg2;
13742 }
13743 {
13744 if (temp3)
13745 delete arg3;
13746 }
13747 {
13748 if (temp4)
13749 delete arg4;
13750 }
13751 return resultobj;
13752 fail:
13753 {
13754 if (temp1)
13755 delete arg1;
13756 }
13757 {
13758 if (temp2)
13759 delete arg2;
13760 }
13761 {
13762 if (temp3)
13763 delete arg3;
13764 }
13765 {
13766 if (temp4)
13767 delete arg4;
13768 }
13769 return NULL;
13770 }
13771
13772
13773 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13774 PyObject *resultobj;
13775 wxArrayString *arg1 = 0 ;
13776 wxFileTypeInfo *result;
13777 bool temp1 = false ;
13778 PyObject * obj0 = 0 ;
13779 char *kwnames[] = {
13780 (char *) "sArray", NULL
13781 };
13782
13783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13784 {
13785 if (! PySequence_Check(obj0)) {
13786 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13787 SWIG_fail;
13788 }
13789 arg1 = new wxArrayString;
13790 temp1 = true;
13791 int i, len=PySequence_Length(obj0);
13792 for (i=0; i<len; i++) {
13793 PyObject* item = PySequence_GetItem(obj0, i);
13794 #if wxUSE_UNICODE
13795 PyObject* str = PyObject_Unicode(item);
13796 #else
13797 PyObject* str = PyObject_Str(item);
13798 #endif
13799 if (PyErr_Occurred()) SWIG_fail;
13800 arg1->Add(Py2wxString(str));
13801 Py_DECREF(item);
13802 Py_DECREF(str);
13803 }
13804 }
13805 {
13806 PyThreadState* __tstate = wxPyBeginAllowThreads();
13807 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13808
13809 wxPyEndAllowThreads(__tstate);
13810 if (PyErr_Occurred()) SWIG_fail;
13811 }
13812 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13813 {
13814 if (temp1) delete arg1;
13815 }
13816 return resultobj;
13817 fail:
13818 {
13819 if (temp1) delete arg1;
13820 }
13821 return NULL;
13822 }
13823
13824
13825 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13826 PyObject *resultobj;
13827 wxFileTypeInfo *result;
13828 char *kwnames[] = {
13829 NULL
13830 };
13831
13832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13833 {
13834 PyThreadState* __tstate = wxPyBeginAllowThreads();
13835 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13836
13837 wxPyEndAllowThreads(__tstate);
13838 if (PyErr_Occurred()) SWIG_fail;
13839 }
13840 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13841 return resultobj;
13842 fail:
13843 return NULL;
13844 }
13845
13846
13847 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13848 PyObject *resultobj;
13849 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13850 bool result;
13851 PyObject * obj0 = 0 ;
13852 char *kwnames[] = {
13853 (char *) "self", NULL
13854 };
13855
13856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13858 if (SWIG_arg_fail(1)) SWIG_fail;
13859 {
13860 PyThreadState* __tstate = wxPyBeginAllowThreads();
13861 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13862
13863 wxPyEndAllowThreads(__tstate);
13864 if (PyErr_Occurred()) SWIG_fail;
13865 }
13866 {
13867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13868 }
13869 return resultobj;
13870 fail:
13871 return NULL;
13872 }
13873
13874
13875 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13876 PyObject *resultobj;
13877 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13878 wxString *arg2 = 0 ;
13879 int arg3 = (int) 0 ;
13880 bool temp2 = false ;
13881 PyObject * obj0 = 0 ;
13882 PyObject * obj1 = 0 ;
13883 PyObject * obj2 = 0 ;
13884 char *kwnames[] = {
13885 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13886 };
13887
13888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13890 if (SWIG_arg_fail(1)) SWIG_fail;
13891 {
13892 arg2 = wxString_in_helper(obj1);
13893 if (arg2 == NULL) SWIG_fail;
13894 temp2 = true;
13895 }
13896 if (obj2) {
13897 {
13898 arg3 = (int)(SWIG_As_int(obj2));
13899 if (SWIG_arg_fail(3)) SWIG_fail;
13900 }
13901 }
13902 {
13903 PyThreadState* __tstate = wxPyBeginAllowThreads();
13904 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13905
13906 wxPyEndAllowThreads(__tstate);
13907 if (PyErr_Occurred()) SWIG_fail;
13908 }
13909 Py_INCREF(Py_None); resultobj = Py_None;
13910 {
13911 if (temp2)
13912 delete arg2;
13913 }
13914 return resultobj;
13915 fail:
13916 {
13917 if (temp2)
13918 delete arg2;
13919 }
13920 return NULL;
13921 }
13922
13923
13924 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13925 PyObject *resultobj;
13926 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13927 wxString *arg2 = 0 ;
13928 bool temp2 = false ;
13929 PyObject * obj0 = 0 ;
13930 PyObject * obj1 = 0 ;
13931 char *kwnames[] = {
13932 (char *) "self",(char *) "shortDesc", NULL
13933 };
13934
13935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13937 if (SWIG_arg_fail(1)) SWIG_fail;
13938 {
13939 arg2 = wxString_in_helper(obj1);
13940 if (arg2 == NULL) SWIG_fail;
13941 temp2 = true;
13942 }
13943 {
13944 PyThreadState* __tstate = wxPyBeginAllowThreads();
13945 (arg1)->SetShortDesc((wxString const &)*arg2);
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_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13966 PyObject *resultobj;
13967 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13968 wxString *result;
13969 PyObject * obj0 = 0 ;
13970 char *kwnames[] = {
13971 (char *) "self", NULL
13972 };
13973
13974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13976 if (SWIG_arg_fail(1)) SWIG_fail;
13977 {
13978 PyThreadState* __tstate = wxPyBeginAllowThreads();
13979 {
13980 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13981 result = (wxString *) &_result_ref;
13982 }
13983
13984 wxPyEndAllowThreads(__tstate);
13985 if (PyErr_Occurred()) SWIG_fail;
13986 }
13987 {
13988 #if wxUSE_UNICODE
13989 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13990 #else
13991 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13992 #endif
13993 }
13994 return resultobj;
13995 fail:
13996 return NULL;
13997 }
13998
13999
14000 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14001 PyObject *resultobj;
14002 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14003 wxString *result;
14004 PyObject * obj0 = 0 ;
14005 char *kwnames[] = {
14006 (char *) "self", NULL
14007 };
14008
14009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14011 if (SWIG_arg_fail(1)) SWIG_fail;
14012 {
14013 PyThreadState* __tstate = wxPyBeginAllowThreads();
14014 {
14015 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14016 result = (wxString *) &_result_ref;
14017 }
14018
14019 wxPyEndAllowThreads(__tstate);
14020 if (PyErr_Occurred()) SWIG_fail;
14021 }
14022 {
14023 #if wxUSE_UNICODE
14024 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14025 #else
14026 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14027 #endif
14028 }
14029 return resultobj;
14030 fail:
14031 return NULL;
14032 }
14033
14034
14035 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14036 PyObject *resultobj;
14037 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14038 wxString *result;
14039 PyObject * obj0 = 0 ;
14040 char *kwnames[] = {
14041 (char *) "self", NULL
14042 };
14043
14044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14046 if (SWIG_arg_fail(1)) SWIG_fail;
14047 {
14048 PyThreadState* __tstate = wxPyBeginAllowThreads();
14049 {
14050 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14051 result = (wxString *) &_result_ref;
14052 }
14053
14054 wxPyEndAllowThreads(__tstate);
14055 if (PyErr_Occurred()) SWIG_fail;
14056 }
14057 {
14058 #if wxUSE_UNICODE
14059 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14060 #else
14061 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14062 #endif
14063 }
14064 return resultobj;
14065 fail:
14066 return NULL;
14067 }
14068
14069
14070 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14071 PyObject *resultobj;
14072 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14073 wxString *result;
14074 PyObject * obj0 = 0 ;
14075 char *kwnames[] = {
14076 (char *) "self", NULL
14077 };
14078
14079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14081 if (SWIG_arg_fail(1)) SWIG_fail;
14082 {
14083 PyThreadState* __tstate = wxPyBeginAllowThreads();
14084 {
14085 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14086 result = (wxString *) &_result_ref;
14087 }
14088
14089 wxPyEndAllowThreads(__tstate);
14090 if (PyErr_Occurred()) SWIG_fail;
14091 }
14092 {
14093 #if wxUSE_UNICODE
14094 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14095 #else
14096 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14097 #endif
14098 }
14099 return resultobj;
14100 fail:
14101 return NULL;
14102 }
14103
14104
14105 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14106 PyObject *resultobj;
14107 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14108 wxString *result;
14109 PyObject * obj0 = 0 ;
14110 char *kwnames[] = {
14111 (char *) "self", NULL
14112 };
14113
14114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14116 if (SWIG_arg_fail(1)) SWIG_fail;
14117 {
14118 PyThreadState* __tstate = wxPyBeginAllowThreads();
14119 {
14120 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14121 result = (wxString *) &_result_ref;
14122 }
14123
14124 wxPyEndAllowThreads(__tstate);
14125 if (PyErr_Occurred()) SWIG_fail;
14126 }
14127 {
14128 #if wxUSE_UNICODE
14129 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14130 #else
14131 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14132 #endif
14133 }
14134 return resultobj;
14135 fail:
14136 return NULL;
14137 }
14138
14139
14140 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14141 PyObject *resultobj;
14142 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14143 wxArrayString *result;
14144 PyObject * obj0 = 0 ;
14145 char *kwnames[] = {
14146 (char *) "self", NULL
14147 };
14148
14149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14151 if (SWIG_arg_fail(1)) SWIG_fail;
14152 {
14153 PyThreadState* __tstate = wxPyBeginAllowThreads();
14154 {
14155 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14156 result = (wxArrayString *) &_result_ref;
14157 }
14158
14159 wxPyEndAllowThreads(__tstate);
14160 if (PyErr_Occurred()) SWIG_fail;
14161 }
14162 {
14163 resultobj = wxArrayString2PyList_helper(*result);
14164 }
14165 return resultobj;
14166 fail:
14167 return NULL;
14168 }
14169
14170
14171 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14172 PyObject *resultobj;
14173 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14174 int result;
14175 PyObject * obj0 = 0 ;
14176 char *kwnames[] = {
14177 (char *) "self", NULL
14178 };
14179
14180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14182 if (SWIG_arg_fail(1)) SWIG_fail;
14183 {
14184 PyThreadState* __tstate = wxPyBeginAllowThreads();
14185 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14186
14187 wxPyEndAllowThreads(__tstate);
14188 if (PyErr_Occurred()) SWIG_fail;
14189 }
14190 {
14191 resultobj = SWIG_From_int((int)(result));
14192 }
14193 return resultobj;
14194 fail:
14195 return NULL;
14196 }
14197
14198
14199 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14200 PyObject *resultobj;
14201 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14202 wxString *result;
14203 PyObject * obj0 = 0 ;
14204 char *kwnames[] = {
14205 (char *) "self", NULL
14206 };
14207
14208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14210 if (SWIG_arg_fail(1)) SWIG_fail;
14211 {
14212 PyThreadState* __tstate = wxPyBeginAllowThreads();
14213 {
14214 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14215 result = (wxString *) &_result_ref;
14216 }
14217
14218 wxPyEndAllowThreads(__tstate);
14219 if (PyErr_Occurred()) SWIG_fail;
14220 }
14221 {
14222 #if wxUSE_UNICODE
14223 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14224 #else
14225 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14226 #endif
14227 }
14228 return resultobj;
14229 fail:
14230 return NULL;
14231 }
14232
14233
14234 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14235 PyObject *resultobj;
14236 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14237 int result;
14238 PyObject * obj0 = 0 ;
14239 char *kwnames[] = {
14240 (char *) "self", NULL
14241 };
14242
14243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14245 if (SWIG_arg_fail(1)) SWIG_fail;
14246 {
14247 PyThreadState* __tstate = wxPyBeginAllowThreads();
14248 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14249
14250 wxPyEndAllowThreads(__tstate);
14251 if (PyErr_Occurred()) SWIG_fail;
14252 }
14253 {
14254 resultobj = SWIG_From_int((int)(result));
14255 }
14256 return resultobj;
14257 fail:
14258 return NULL;
14259 }
14260
14261
14262 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14263 PyObject *obj;
14264 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14265 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14266 Py_INCREF(obj);
14267 return Py_BuildValue((char *)"");
14268 }
14269 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14270 PyObject *resultobj;
14271 wxFileTypeInfo *arg1 = 0 ;
14272 wxFileType *result;
14273 PyObject * obj0 = 0 ;
14274 char *kwnames[] = {
14275 (char *) "ftInfo", NULL
14276 };
14277
14278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14279 {
14280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14281 if (SWIG_arg_fail(1)) SWIG_fail;
14282 if (arg1 == NULL) {
14283 SWIG_null_ref("wxFileTypeInfo");
14284 }
14285 if (SWIG_arg_fail(1)) SWIG_fail;
14286 }
14287 {
14288 PyThreadState* __tstate = wxPyBeginAllowThreads();
14289 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14290
14291 wxPyEndAllowThreads(__tstate);
14292 if (PyErr_Occurred()) SWIG_fail;
14293 }
14294 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14295 return resultobj;
14296 fail:
14297 return NULL;
14298 }
14299
14300
14301 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14302 PyObject *resultobj;
14303 wxFileType *arg1 = (wxFileType *) 0 ;
14304 PyObject * obj0 = 0 ;
14305 char *kwnames[] = {
14306 (char *) "self", NULL
14307 };
14308
14309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14311 if (SWIG_arg_fail(1)) SWIG_fail;
14312 {
14313 PyThreadState* __tstate = wxPyBeginAllowThreads();
14314 delete arg1;
14315
14316 wxPyEndAllowThreads(__tstate);
14317 if (PyErr_Occurred()) SWIG_fail;
14318 }
14319 Py_INCREF(Py_None); resultobj = Py_None;
14320 return resultobj;
14321 fail:
14322 return NULL;
14323 }
14324
14325
14326 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14327 PyObject *resultobj;
14328 wxFileType *arg1 = (wxFileType *) 0 ;
14329 PyObject *result;
14330 PyObject * obj0 = 0 ;
14331 char *kwnames[] = {
14332 (char *) "self", NULL
14333 };
14334
14335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14337 if (SWIG_arg_fail(1)) SWIG_fail;
14338 {
14339 PyThreadState* __tstate = wxPyBeginAllowThreads();
14340 result = (PyObject *)wxFileType_GetMimeType(arg1);
14341
14342 wxPyEndAllowThreads(__tstate);
14343 if (PyErr_Occurred()) SWIG_fail;
14344 }
14345 resultobj = result;
14346 return resultobj;
14347 fail:
14348 return NULL;
14349 }
14350
14351
14352 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14353 PyObject *resultobj;
14354 wxFileType *arg1 = (wxFileType *) 0 ;
14355 PyObject *result;
14356 PyObject * obj0 = 0 ;
14357 char *kwnames[] = {
14358 (char *) "self", NULL
14359 };
14360
14361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14363 if (SWIG_arg_fail(1)) SWIG_fail;
14364 {
14365 PyThreadState* __tstate = wxPyBeginAllowThreads();
14366 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14367
14368 wxPyEndAllowThreads(__tstate);
14369 if (PyErr_Occurred()) SWIG_fail;
14370 }
14371 resultobj = result;
14372 return resultobj;
14373 fail:
14374 return NULL;
14375 }
14376
14377
14378 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14379 PyObject *resultobj;
14380 wxFileType *arg1 = (wxFileType *) 0 ;
14381 PyObject *result;
14382 PyObject * obj0 = 0 ;
14383 char *kwnames[] = {
14384 (char *) "self", NULL
14385 };
14386
14387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14389 if (SWIG_arg_fail(1)) SWIG_fail;
14390 {
14391 PyThreadState* __tstate = wxPyBeginAllowThreads();
14392 result = (PyObject *)wxFileType_GetExtensions(arg1);
14393
14394 wxPyEndAllowThreads(__tstate);
14395 if (PyErr_Occurred()) SWIG_fail;
14396 }
14397 resultobj = result;
14398 return resultobj;
14399 fail:
14400 return NULL;
14401 }
14402
14403
14404 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14405 PyObject *resultobj;
14406 wxFileType *arg1 = (wxFileType *) 0 ;
14407 wxIcon *result;
14408 PyObject * obj0 = 0 ;
14409 char *kwnames[] = {
14410 (char *) "self", NULL
14411 };
14412
14413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14415 if (SWIG_arg_fail(1)) SWIG_fail;
14416 {
14417 PyThreadState* __tstate = wxPyBeginAllowThreads();
14418 result = (wxIcon *)wxFileType_GetIcon(arg1);
14419
14420 wxPyEndAllowThreads(__tstate);
14421 if (PyErr_Occurred()) SWIG_fail;
14422 }
14423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14424 return resultobj;
14425 fail:
14426 return NULL;
14427 }
14428
14429
14430 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14431 PyObject *resultobj;
14432 wxFileType *arg1 = (wxFileType *) 0 ;
14433 PyObject *result;
14434 PyObject * obj0 = 0 ;
14435 char *kwnames[] = {
14436 (char *) "self", NULL
14437 };
14438
14439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14441 if (SWIG_arg_fail(1)) SWIG_fail;
14442 {
14443 PyThreadState* __tstate = wxPyBeginAllowThreads();
14444 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14445
14446 wxPyEndAllowThreads(__tstate);
14447 if (PyErr_Occurred()) SWIG_fail;
14448 }
14449 resultobj = result;
14450 return resultobj;
14451 fail:
14452 return NULL;
14453 }
14454
14455
14456 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14457 PyObject *resultobj;
14458 wxFileType *arg1 = (wxFileType *) 0 ;
14459 PyObject *result;
14460 PyObject * obj0 = 0 ;
14461 char *kwnames[] = {
14462 (char *) "self", NULL
14463 };
14464
14465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14467 if (SWIG_arg_fail(1)) SWIG_fail;
14468 {
14469 PyThreadState* __tstate = wxPyBeginAllowThreads();
14470 result = (PyObject *)wxFileType_GetDescription(arg1);
14471
14472 wxPyEndAllowThreads(__tstate);
14473 if (PyErr_Occurred()) SWIG_fail;
14474 }
14475 resultobj = result;
14476 return resultobj;
14477 fail:
14478 return NULL;
14479 }
14480
14481
14482 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14483 PyObject *resultobj;
14484 wxFileType *arg1 = (wxFileType *) 0 ;
14485 wxString *arg2 = 0 ;
14486 wxString const &arg3_defvalue = wxPyEmptyString ;
14487 wxString *arg3 = (wxString *) &arg3_defvalue ;
14488 PyObject *result;
14489 bool temp2 = false ;
14490 bool temp3 = false ;
14491 PyObject * obj0 = 0 ;
14492 PyObject * obj1 = 0 ;
14493 PyObject * obj2 = 0 ;
14494 char *kwnames[] = {
14495 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14496 };
14497
14498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14500 if (SWIG_arg_fail(1)) SWIG_fail;
14501 {
14502 arg2 = wxString_in_helper(obj1);
14503 if (arg2 == NULL) SWIG_fail;
14504 temp2 = true;
14505 }
14506 if (obj2) {
14507 {
14508 arg3 = wxString_in_helper(obj2);
14509 if (arg3 == NULL) SWIG_fail;
14510 temp3 = true;
14511 }
14512 }
14513 {
14514 PyThreadState* __tstate = wxPyBeginAllowThreads();
14515 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14516
14517 wxPyEndAllowThreads(__tstate);
14518 if (PyErr_Occurred()) SWIG_fail;
14519 }
14520 resultobj = result;
14521 {
14522 if (temp2)
14523 delete arg2;
14524 }
14525 {
14526 if (temp3)
14527 delete arg3;
14528 }
14529 return resultobj;
14530 fail:
14531 {
14532 if (temp2)
14533 delete arg2;
14534 }
14535 {
14536 if (temp3)
14537 delete arg3;
14538 }
14539 return NULL;
14540 }
14541
14542
14543 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14544 PyObject *resultobj;
14545 wxFileType *arg1 = (wxFileType *) 0 ;
14546 wxString *arg2 = 0 ;
14547 wxString const &arg3_defvalue = wxPyEmptyString ;
14548 wxString *arg3 = (wxString *) &arg3_defvalue ;
14549 PyObject *result;
14550 bool temp2 = false ;
14551 bool temp3 = false ;
14552 PyObject * obj0 = 0 ;
14553 PyObject * obj1 = 0 ;
14554 PyObject * obj2 = 0 ;
14555 char *kwnames[] = {
14556 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14557 };
14558
14559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14561 if (SWIG_arg_fail(1)) SWIG_fail;
14562 {
14563 arg2 = wxString_in_helper(obj1);
14564 if (arg2 == NULL) SWIG_fail;
14565 temp2 = true;
14566 }
14567 if (obj2) {
14568 {
14569 arg3 = wxString_in_helper(obj2);
14570 if (arg3 == NULL) SWIG_fail;
14571 temp3 = true;
14572 }
14573 }
14574 {
14575 PyThreadState* __tstate = wxPyBeginAllowThreads();
14576 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14577
14578 wxPyEndAllowThreads(__tstate);
14579 if (PyErr_Occurred()) SWIG_fail;
14580 }
14581 resultobj = result;
14582 {
14583 if (temp2)
14584 delete arg2;
14585 }
14586 {
14587 if (temp3)
14588 delete arg3;
14589 }
14590 return resultobj;
14591 fail:
14592 {
14593 if (temp2)
14594 delete arg2;
14595 }
14596 {
14597 if (temp3)
14598 delete arg3;
14599 }
14600 return NULL;
14601 }
14602
14603
14604 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14605 PyObject *resultobj;
14606 wxFileType *arg1 = (wxFileType *) 0 ;
14607 wxString *arg2 = 0 ;
14608 wxString const &arg3_defvalue = wxPyEmptyString ;
14609 wxString *arg3 = (wxString *) &arg3_defvalue ;
14610 PyObject *result;
14611 bool temp2 = false ;
14612 bool temp3 = false ;
14613 PyObject * obj0 = 0 ;
14614 PyObject * obj1 = 0 ;
14615 PyObject * obj2 = 0 ;
14616 char *kwnames[] = {
14617 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14618 };
14619
14620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14622 if (SWIG_arg_fail(1)) SWIG_fail;
14623 {
14624 arg2 = wxString_in_helper(obj1);
14625 if (arg2 == NULL) SWIG_fail;
14626 temp2 = true;
14627 }
14628 if (obj2) {
14629 {
14630 arg3 = wxString_in_helper(obj2);
14631 if (arg3 == NULL) SWIG_fail;
14632 temp3 = true;
14633 }
14634 }
14635 {
14636 PyThreadState* __tstate = wxPyBeginAllowThreads();
14637 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14638
14639 wxPyEndAllowThreads(__tstate);
14640 if (PyErr_Occurred()) SWIG_fail;
14641 }
14642 resultobj = result;
14643 {
14644 if (temp2)
14645 delete arg2;
14646 }
14647 {
14648 if (temp3)
14649 delete arg3;
14650 }
14651 return resultobj;
14652 fail:
14653 {
14654 if (temp2)
14655 delete arg2;
14656 }
14657 {
14658 if (temp3)
14659 delete arg3;
14660 }
14661 return NULL;
14662 }
14663
14664
14665 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14666 PyObject *resultobj;
14667 wxFileType *arg1 = (wxFileType *) 0 ;
14668 wxString *arg2 = 0 ;
14669 wxString *arg3 = 0 ;
14670 bool arg4 = (bool) true ;
14671 bool result;
14672 bool temp2 = false ;
14673 bool temp3 = false ;
14674 PyObject * obj0 = 0 ;
14675 PyObject * obj1 = 0 ;
14676 PyObject * obj2 = 0 ;
14677 PyObject * obj3 = 0 ;
14678 char *kwnames[] = {
14679 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14680 };
14681
14682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14684 if (SWIG_arg_fail(1)) SWIG_fail;
14685 {
14686 arg2 = wxString_in_helper(obj1);
14687 if (arg2 == NULL) SWIG_fail;
14688 temp2 = true;
14689 }
14690 {
14691 arg3 = wxString_in_helper(obj2);
14692 if (arg3 == NULL) SWIG_fail;
14693 temp3 = true;
14694 }
14695 if (obj3) {
14696 {
14697 arg4 = (bool)(SWIG_As_bool(obj3));
14698 if (SWIG_arg_fail(4)) SWIG_fail;
14699 }
14700 }
14701 {
14702 PyThreadState* __tstate = wxPyBeginAllowThreads();
14703 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14704
14705 wxPyEndAllowThreads(__tstate);
14706 if (PyErr_Occurred()) SWIG_fail;
14707 }
14708 {
14709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14710 }
14711 {
14712 if (temp2)
14713 delete arg2;
14714 }
14715 {
14716 if (temp3)
14717 delete arg3;
14718 }
14719 return resultobj;
14720 fail:
14721 {
14722 if (temp2)
14723 delete arg2;
14724 }
14725 {
14726 if (temp3)
14727 delete arg3;
14728 }
14729 return NULL;
14730 }
14731
14732
14733 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14734 PyObject *resultobj;
14735 wxFileType *arg1 = (wxFileType *) 0 ;
14736 wxString const &arg2_defvalue = wxPyEmptyString ;
14737 wxString *arg2 = (wxString *) &arg2_defvalue ;
14738 int arg3 = (int) 0 ;
14739 bool result;
14740 bool temp2 = false ;
14741 PyObject * obj0 = 0 ;
14742 PyObject * obj1 = 0 ;
14743 PyObject * obj2 = 0 ;
14744 char *kwnames[] = {
14745 (char *) "self",(char *) "cmd",(char *) "index", NULL
14746 };
14747
14748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14750 if (SWIG_arg_fail(1)) SWIG_fail;
14751 if (obj1) {
14752 {
14753 arg2 = wxString_in_helper(obj1);
14754 if (arg2 == NULL) SWIG_fail;
14755 temp2 = true;
14756 }
14757 }
14758 if (obj2) {
14759 {
14760 arg3 = (int)(SWIG_As_int(obj2));
14761 if (SWIG_arg_fail(3)) SWIG_fail;
14762 }
14763 }
14764 {
14765 PyThreadState* __tstate = wxPyBeginAllowThreads();
14766 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14767
14768 wxPyEndAllowThreads(__tstate);
14769 if (PyErr_Occurred()) SWIG_fail;
14770 }
14771 {
14772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14773 }
14774 {
14775 if (temp2)
14776 delete arg2;
14777 }
14778 return resultobj;
14779 fail:
14780 {
14781 if (temp2)
14782 delete arg2;
14783 }
14784 return NULL;
14785 }
14786
14787
14788 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14789 PyObject *resultobj;
14790 wxFileType *arg1 = (wxFileType *) 0 ;
14791 bool result;
14792 PyObject * obj0 = 0 ;
14793 char *kwnames[] = {
14794 (char *) "self", NULL
14795 };
14796
14797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14799 if (SWIG_arg_fail(1)) SWIG_fail;
14800 {
14801 PyThreadState* __tstate = wxPyBeginAllowThreads();
14802 result = (bool)(arg1)->Unassociate();
14803
14804 wxPyEndAllowThreads(__tstate);
14805 if (PyErr_Occurred()) SWIG_fail;
14806 }
14807 {
14808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14809 }
14810 return resultobj;
14811 fail:
14812 return NULL;
14813 }
14814
14815
14816 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14817 PyObject *resultobj;
14818 wxString *arg1 = 0 ;
14819 wxString *arg2 = 0 ;
14820 wxString const &arg3_defvalue = wxPyEmptyString ;
14821 wxString *arg3 = (wxString *) &arg3_defvalue ;
14822 wxString result;
14823 bool temp1 = false ;
14824 bool temp2 = false ;
14825 bool temp3 = false ;
14826 PyObject * obj0 = 0 ;
14827 PyObject * obj1 = 0 ;
14828 PyObject * obj2 = 0 ;
14829 char *kwnames[] = {
14830 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14831 };
14832
14833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14834 {
14835 arg1 = wxString_in_helper(obj0);
14836 if (arg1 == NULL) SWIG_fail;
14837 temp1 = true;
14838 }
14839 {
14840 arg2 = wxString_in_helper(obj1);
14841 if (arg2 == NULL) SWIG_fail;
14842 temp2 = true;
14843 }
14844 if (obj2) {
14845 {
14846 arg3 = wxString_in_helper(obj2);
14847 if (arg3 == NULL) SWIG_fail;
14848 temp3 = true;
14849 }
14850 }
14851 {
14852 PyThreadState* __tstate = wxPyBeginAllowThreads();
14853 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14854
14855 wxPyEndAllowThreads(__tstate);
14856 if (PyErr_Occurred()) SWIG_fail;
14857 }
14858 {
14859 #if wxUSE_UNICODE
14860 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14861 #else
14862 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14863 #endif
14864 }
14865 {
14866 if (temp1)
14867 delete arg1;
14868 }
14869 {
14870 if (temp2)
14871 delete arg2;
14872 }
14873 {
14874 if (temp3)
14875 delete arg3;
14876 }
14877 return resultobj;
14878 fail:
14879 {
14880 if (temp1)
14881 delete arg1;
14882 }
14883 {
14884 if (temp2)
14885 delete arg2;
14886 }
14887 {
14888 if (temp3)
14889 delete arg3;
14890 }
14891 return NULL;
14892 }
14893
14894
14895 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14896 PyObject *obj;
14897 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14898 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14899 Py_INCREF(obj);
14900 return Py_BuildValue((char *)"");
14901 }
14902 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14903 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14904 return 1;
14905 }
14906
14907
14908 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14909 PyObject *pyobj;
14910
14911 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14912 return pyobj;
14913 }
14914
14915
14916 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14917 PyObject *resultobj;
14918 wxString *arg1 = 0 ;
14919 wxString *arg2 = 0 ;
14920 bool result;
14921 bool temp1 = false ;
14922 bool temp2 = false ;
14923 PyObject * obj0 = 0 ;
14924 PyObject * obj1 = 0 ;
14925 char *kwnames[] = {
14926 (char *) "mimeType",(char *) "wildcard", NULL
14927 };
14928
14929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14930 {
14931 arg1 = wxString_in_helper(obj0);
14932 if (arg1 == NULL) SWIG_fail;
14933 temp1 = true;
14934 }
14935 {
14936 arg2 = wxString_in_helper(obj1);
14937 if (arg2 == NULL) SWIG_fail;
14938 temp2 = true;
14939 }
14940 {
14941 PyThreadState* __tstate = wxPyBeginAllowThreads();
14942 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14943
14944 wxPyEndAllowThreads(__tstate);
14945 if (PyErr_Occurred()) SWIG_fail;
14946 }
14947 {
14948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14949 }
14950 {
14951 if (temp1)
14952 delete arg1;
14953 }
14954 {
14955 if (temp2)
14956 delete arg2;
14957 }
14958 return resultobj;
14959 fail:
14960 {
14961 if (temp1)
14962 delete arg1;
14963 }
14964 {
14965 if (temp2)
14966 delete arg2;
14967 }
14968 return NULL;
14969 }
14970
14971
14972 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14973 PyObject *resultobj;
14974 wxMimeTypesManager *result;
14975 char *kwnames[] = {
14976 NULL
14977 };
14978
14979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14980 {
14981 PyThreadState* __tstate = wxPyBeginAllowThreads();
14982 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14983
14984 wxPyEndAllowThreads(__tstate);
14985 if (PyErr_Occurred()) SWIG_fail;
14986 }
14987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14988 return resultobj;
14989 fail:
14990 return NULL;
14991 }
14992
14993
14994 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14995 PyObject *resultobj;
14996 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14997 int arg2 = (int) wxMAILCAP_ALL ;
14998 wxString const &arg3_defvalue = wxPyEmptyString ;
14999 wxString *arg3 = (wxString *) &arg3_defvalue ;
15000 bool temp3 = false ;
15001 PyObject * obj0 = 0 ;
15002 PyObject * obj1 = 0 ;
15003 PyObject * obj2 = 0 ;
15004 char *kwnames[] = {
15005 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15006 };
15007
15008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15010 if (SWIG_arg_fail(1)) SWIG_fail;
15011 if (obj1) {
15012 {
15013 arg2 = (int)(SWIG_As_int(obj1));
15014 if (SWIG_arg_fail(2)) SWIG_fail;
15015 }
15016 }
15017 if (obj2) {
15018 {
15019 arg3 = wxString_in_helper(obj2);
15020 if (arg3 == NULL) SWIG_fail;
15021 temp3 = true;
15022 }
15023 }
15024 {
15025 PyThreadState* __tstate = wxPyBeginAllowThreads();
15026 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15027
15028 wxPyEndAllowThreads(__tstate);
15029 if (PyErr_Occurred()) SWIG_fail;
15030 }
15031 Py_INCREF(Py_None); resultobj = Py_None;
15032 {
15033 if (temp3)
15034 delete arg3;
15035 }
15036 return resultobj;
15037 fail:
15038 {
15039 if (temp3)
15040 delete arg3;
15041 }
15042 return NULL;
15043 }
15044
15045
15046 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15047 PyObject *resultobj;
15048 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15049 PyObject * obj0 = 0 ;
15050 char *kwnames[] = {
15051 (char *) "self", NULL
15052 };
15053
15054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15056 if (SWIG_arg_fail(1)) SWIG_fail;
15057 {
15058 PyThreadState* __tstate = wxPyBeginAllowThreads();
15059 (arg1)->ClearData();
15060
15061 wxPyEndAllowThreads(__tstate);
15062 if (PyErr_Occurred()) SWIG_fail;
15063 }
15064 Py_INCREF(Py_None); resultobj = Py_None;
15065 return resultobj;
15066 fail:
15067 return NULL;
15068 }
15069
15070
15071 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15072 PyObject *resultobj;
15073 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15074 wxString *arg2 = 0 ;
15075 wxFileType *result;
15076 bool temp2 = false ;
15077 PyObject * obj0 = 0 ;
15078 PyObject * obj1 = 0 ;
15079 char *kwnames[] = {
15080 (char *) "self",(char *) "ext", NULL
15081 };
15082
15083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15085 if (SWIG_arg_fail(1)) SWIG_fail;
15086 {
15087 arg2 = wxString_in_helper(obj1);
15088 if (arg2 == NULL) SWIG_fail;
15089 temp2 = true;
15090 }
15091 {
15092 PyThreadState* __tstate = wxPyBeginAllowThreads();
15093 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15094
15095 wxPyEndAllowThreads(__tstate);
15096 if (PyErr_Occurred()) SWIG_fail;
15097 }
15098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15099 {
15100 if (temp2)
15101 delete arg2;
15102 }
15103 return resultobj;
15104 fail:
15105 {
15106 if (temp2)
15107 delete arg2;
15108 }
15109 return NULL;
15110 }
15111
15112
15113 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15114 PyObject *resultobj;
15115 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15116 wxString *arg2 = 0 ;
15117 wxFileType *result;
15118 bool temp2 = false ;
15119 PyObject * obj0 = 0 ;
15120 PyObject * obj1 = 0 ;
15121 char *kwnames[] = {
15122 (char *) "self",(char *) "mimeType", NULL
15123 };
15124
15125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15127 if (SWIG_arg_fail(1)) SWIG_fail;
15128 {
15129 arg2 = wxString_in_helper(obj1);
15130 if (arg2 == NULL) SWIG_fail;
15131 temp2 = true;
15132 }
15133 {
15134 PyThreadState* __tstate = wxPyBeginAllowThreads();
15135 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15136
15137 wxPyEndAllowThreads(__tstate);
15138 if (PyErr_Occurred()) SWIG_fail;
15139 }
15140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15141 {
15142 if (temp2)
15143 delete arg2;
15144 }
15145 return resultobj;
15146 fail:
15147 {
15148 if (temp2)
15149 delete arg2;
15150 }
15151 return NULL;
15152 }
15153
15154
15155 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15156 PyObject *resultobj;
15157 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15158 wxString *arg2 = 0 ;
15159 bool arg3 = (bool) false ;
15160 bool result;
15161 bool temp2 = false ;
15162 PyObject * obj0 = 0 ;
15163 PyObject * obj1 = 0 ;
15164 PyObject * obj2 = 0 ;
15165 char *kwnames[] = {
15166 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15167 };
15168
15169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15171 if (SWIG_arg_fail(1)) SWIG_fail;
15172 {
15173 arg2 = wxString_in_helper(obj1);
15174 if (arg2 == NULL) SWIG_fail;
15175 temp2 = true;
15176 }
15177 if (obj2) {
15178 {
15179 arg3 = (bool)(SWIG_As_bool(obj2));
15180 if (SWIG_arg_fail(3)) SWIG_fail;
15181 }
15182 }
15183 {
15184 PyThreadState* __tstate = wxPyBeginAllowThreads();
15185 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15186
15187 wxPyEndAllowThreads(__tstate);
15188 if (PyErr_Occurred()) SWIG_fail;
15189 }
15190 {
15191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15192 }
15193 {
15194 if (temp2)
15195 delete arg2;
15196 }
15197 return resultobj;
15198 fail:
15199 {
15200 if (temp2)
15201 delete arg2;
15202 }
15203 return NULL;
15204 }
15205
15206
15207 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15208 PyObject *resultobj;
15209 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15210 wxString *arg2 = 0 ;
15211 bool result;
15212 bool temp2 = false ;
15213 PyObject * obj0 = 0 ;
15214 PyObject * obj1 = 0 ;
15215 char *kwnames[] = {
15216 (char *) "self",(char *) "filename", NULL
15217 };
15218
15219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15221 if (SWIG_arg_fail(1)) SWIG_fail;
15222 {
15223 arg2 = wxString_in_helper(obj1);
15224 if (arg2 == NULL) SWIG_fail;
15225 temp2 = true;
15226 }
15227 {
15228 PyThreadState* __tstate = wxPyBeginAllowThreads();
15229 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15230
15231 wxPyEndAllowThreads(__tstate);
15232 if (PyErr_Occurred()) SWIG_fail;
15233 }
15234 {
15235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15236 }
15237 {
15238 if (temp2)
15239 delete arg2;
15240 }
15241 return resultobj;
15242 fail:
15243 {
15244 if (temp2)
15245 delete arg2;
15246 }
15247 return NULL;
15248 }
15249
15250
15251 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15252 PyObject *resultobj;
15253 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15254 PyObject *result;
15255 PyObject * obj0 = 0 ;
15256 char *kwnames[] = {
15257 (char *) "self", NULL
15258 };
15259
15260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
15265 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15266
15267 wxPyEndAllowThreads(__tstate);
15268 if (PyErr_Occurred()) SWIG_fail;
15269 }
15270 resultobj = result;
15271 return resultobj;
15272 fail:
15273 return NULL;
15274 }
15275
15276
15277 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15278 PyObject *resultobj;
15279 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15280 wxFileTypeInfo *arg2 = 0 ;
15281 PyObject * obj0 = 0 ;
15282 PyObject * obj1 = 0 ;
15283 char *kwnames[] = {
15284 (char *) "self",(char *) "ft", NULL
15285 };
15286
15287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15289 if (SWIG_arg_fail(1)) SWIG_fail;
15290 {
15291 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15292 if (SWIG_arg_fail(2)) SWIG_fail;
15293 if (arg2 == NULL) {
15294 SWIG_null_ref("wxFileTypeInfo");
15295 }
15296 if (SWIG_arg_fail(2)) SWIG_fail;
15297 }
15298 {
15299 PyThreadState* __tstate = wxPyBeginAllowThreads();
15300 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15301
15302 wxPyEndAllowThreads(__tstate);
15303 if (PyErr_Occurred()) SWIG_fail;
15304 }
15305 Py_INCREF(Py_None); resultobj = Py_None;
15306 return resultobj;
15307 fail:
15308 return NULL;
15309 }
15310
15311
15312 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15313 PyObject *resultobj;
15314 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15315 wxFileTypeInfo *arg2 = 0 ;
15316 wxFileType *result;
15317 PyObject * obj0 = 0 ;
15318 PyObject * obj1 = 0 ;
15319 char *kwnames[] = {
15320 (char *) "self",(char *) "ftInfo", NULL
15321 };
15322
15323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15325 if (SWIG_arg_fail(1)) SWIG_fail;
15326 {
15327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15328 if (SWIG_arg_fail(2)) SWIG_fail;
15329 if (arg2 == NULL) {
15330 SWIG_null_ref("wxFileTypeInfo");
15331 }
15332 if (SWIG_arg_fail(2)) SWIG_fail;
15333 }
15334 {
15335 PyThreadState* __tstate = wxPyBeginAllowThreads();
15336 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15337
15338 wxPyEndAllowThreads(__tstate);
15339 if (PyErr_Occurred()) SWIG_fail;
15340 }
15341 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15342 return resultobj;
15343 fail:
15344 return NULL;
15345 }
15346
15347
15348 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15349 PyObject *resultobj;
15350 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15351 wxFileType *arg2 = (wxFileType *) 0 ;
15352 bool result;
15353 PyObject * obj0 = 0 ;
15354 PyObject * obj1 = 0 ;
15355 char *kwnames[] = {
15356 (char *) "self",(char *) "ft", NULL
15357 };
15358
15359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15361 if (SWIG_arg_fail(1)) SWIG_fail;
15362 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15363 if (SWIG_arg_fail(2)) SWIG_fail;
15364 {
15365 PyThreadState* __tstate = wxPyBeginAllowThreads();
15366 result = (bool)(arg1)->Unassociate(arg2);
15367
15368 wxPyEndAllowThreads(__tstate);
15369 if (PyErr_Occurred()) SWIG_fail;
15370 }
15371 {
15372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15373 }
15374 return resultobj;
15375 fail:
15376 return NULL;
15377 }
15378
15379
15380 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15381 PyObject *resultobj;
15382 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15383 PyObject * obj0 = 0 ;
15384 char *kwnames[] = {
15385 (char *) "self", NULL
15386 };
15387
15388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15390 if (SWIG_arg_fail(1)) SWIG_fail;
15391 {
15392 PyThreadState* __tstate = wxPyBeginAllowThreads();
15393 delete arg1;
15394
15395 wxPyEndAllowThreads(__tstate);
15396 if (PyErr_Occurred()) SWIG_fail;
15397 }
15398 Py_INCREF(Py_None); resultobj = Py_None;
15399 return resultobj;
15400 fail:
15401 return NULL;
15402 }
15403
15404
15405 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15406 PyObject *obj;
15407 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15408 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15409 Py_INCREF(obj);
15410 return Py_BuildValue((char *)"");
15411 }
15412 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15413 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15414 return 1;
15415 }
15416
15417
15418 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15419 PyObject *pyobj;
15420
15421 {
15422 #if wxUSE_UNICODE
15423 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15424 #else
15425 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15426 #endif
15427 }
15428 return pyobj;
15429 }
15430
15431
15432 static int _wrap_ART_MENU_set(PyObject *) {
15433 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15434 return 1;
15435 }
15436
15437
15438 static PyObject *_wrap_ART_MENU_get(void) {
15439 PyObject *pyobj;
15440
15441 {
15442 #if wxUSE_UNICODE
15443 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15444 #else
15445 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15446 #endif
15447 }
15448 return pyobj;
15449 }
15450
15451
15452 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15453 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15454 return 1;
15455 }
15456
15457
15458 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15459 PyObject *pyobj;
15460
15461 {
15462 #if wxUSE_UNICODE
15463 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15464 #else
15465 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15466 #endif
15467 }
15468 return pyobj;
15469 }
15470
15471
15472 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15473 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15474 return 1;
15475 }
15476
15477
15478 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15479 PyObject *pyobj;
15480
15481 {
15482 #if wxUSE_UNICODE
15483 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15484 #else
15485 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15486 #endif
15487 }
15488 return pyobj;
15489 }
15490
15491
15492 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15493 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15494 return 1;
15495 }
15496
15497
15498 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15499 PyObject *pyobj;
15500
15501 {
15502 #if wxUSE_UNICODE
15503 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15504 #else
15505 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15506 #endif
15507 }
15508 return pyobj;
15509 }
15510
15511
15512 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15513 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15514 return 1;
15515 }
15516
15517
15518 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15519 PyObject *pyobj;
15520
15521 {
15522 #if wxUSE_UNICODE
15523 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15524 #else
15525 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15526 #endif
15527 }
15528 return pyobj;
15529 }
15530
15531
15532 static int _wrap_ART_BUTTON_set(PyObject *) {
15533 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15534 return 1;
15535 }
15536
15537
15538 static PyObject *_wrap_ART_BUTTON_get(void) {
15539 PyObject *pyobj;
15540
15541 {
15542 #if wxUSE_UNICODE
15543 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15544 #else
15545 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15546 #endif
15547 }
15548 return pyobj;
15549 }
15550
15551
15552 static int _wrap_ART_OTHER_set(PyObject *) {
15553 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15554 return 1;
15555 }
15556
15557
15558 static PyObject *_wrap_ART_OTHER_get(void) {
15559 PyObject *pyobj;
15560
15561 {
15562 #if wxUSE_UNICODE
15563 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15564 #else
15565 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15566 #endif
15567 }
15568 return pyobj;
15569 }
15570
15571
15572 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15573 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15574 return 1;
15575 }
15576
15577
15578 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15579 PyObject *pyobj;
15580
15581 {
15582 #if wxUSE_UNICODE
15583 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15584 #else
15585 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15586 #endif
15587 }
15588 return pyobj;
15589 }
15590
15591
15592 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15593 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15594 return 1;
15595 }
15596
15597
15598 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15599 PyObject *pyobj;
15600
15601 {
15602 #if wxUSE_UNICODE
15603 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15604 #else
15605 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15606 #endif
15607 }
15608 return pyobj;
15609 }
15610
15611
15612 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15613 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15614 return 1;
15615 }
15616
15617
15618 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15619 PyObject *pyobj;
15620
15621 {
15622 #if wxUSE_UNICODE
15623 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15624 #else
15625 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15626 #endif
15627 }
15628 return pyobj;
15629 }
15630
15631
15632 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15633 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15634 return 1;
15635 }
15636
15637
15638 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15639 PyObject *pyobj;
15640
15641 {
15642 #if wxUSE_UNICODE
15643 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15644 #else
15645 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15646 #endif
15647 }
15648 return pyobj;
15649 }
15650
15651
15652 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15653 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15654 return 1;
15655 }
15656
15657
15658 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15659 PyObject *pyobj;
15660
15661 {
15662 #if wxUSE_UNICODE
15663 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15664 #else
15665 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15666 #endif
15667 }
15668 return pyobj;
15669 }
15670
15671
15672 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15673 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15674 return 1;
15675 }
15676
15677
15678 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15679 PyObject *pyobj;
15680
15681 {
15682 #if wxUSE_UNICODE
15683 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15684 #else
15685 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15686 #endif
15687 }
15688 return pyobj;
15689 }
15690
15691
15692 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15693 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15694 return 1;
15695 }
15696
15697
15698 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15699 PyObject *pyobj;
15700
15701 {
15702 #if wxUSE_UNICODE
15703 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15704 #else
15705 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15706 #endif
15707 }
15708 return pyobj;
15709 }
15710
15711
15712 static int _wrap_ART_GO_BACK_set(PyObject *) {
15713 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15714 return 1;
15715 }
15716
15717
15718 static PyObject *_wrap_ART_GO_BACK_get(void) {
15719 PyObject *pyobj;
15720
15721 {
15722 #if wxUSE_UNICODE
15723 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15724 #else
15725 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15726 #endif
15727 }
15728 return pyobj;
15729 }
15730
15731
15732 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15733 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15734 return 1;
15735 }
15736
15737
15738 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15739 PyObject *pyobj;
15740
15741 {
15742 #if wxUSE_UNICODE
15743 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15744 #else
15745 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15746 #endif
15747 }
15748 return pyobj;
15749 }
15750
15751
15752 static int _wrap_ART_GO_UP_set(PyObject *) {
15753 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15754 return 1;
15755 }
15756
15757
15758 static PyObject *_wrap_ART_GO_UP_get(void) {
15759 PyObject *pyobj;
15760
15761 {
15762 #if wxUSE_UNICODE
15763 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15764 #else
15765 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15766 #endif
15767 }
15768 return pyobj;
15769 }
15770
15771
15772 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15773 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15774 return 1;
15775 }
15776
15777
15778 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15779 PyObject *pyobj;
15780
15781 {
15782 #if wxUSE_UNICODE
15783 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15784 #else
15785 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15786 #endif
15787 }
15788 return pyobj;
15789 }
15790
15791
15792 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15793 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15794 return 1;
15795 }
15796
15797
15798 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15799 PyObject *pyobj;
15800
15801 {
15802 #if wxUSE_UNICODE
15803 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15804 #else
15805 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15806 #endif
15807 }
15808 return pyobj;
15809 }
15810
15811
15812 static int _wrap_ART_GO_HOME_set(PyObject *) {
15813 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15814 return 1;
15815 }
15816
15817
15818 static PyObject *_wrap_ART_GO_HOME_get(void) {
15819 PyObject *pyobj;
15820
15821 {
15822 #if wxUSE_UNICODE
15823 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15824 #else
15825 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15826 #endif
15827 }
15828 return pyobj;
15829 }
15830
15831
15832 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15833 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15834 return 1;
15835 }
15836
15837
15838 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15839 PyObject *pyobj;
15840
15841 {
15842 #if wxUSE_UNICODE
15843 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15844 #else
15845 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15846 #endif
15847 }
15848 return pyobj;
15849 }
15850
15851
15852 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15853 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15854 return 1;
15855 }
15856
15857
15858 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15859 PyObject *pyobj;
15860
15861 {
15862 #if wxUSE_UNICODE
15863 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15864 #else
15865 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15866 #endif
15867 }
15868 return pyobj;
15869 }
15870
15871
15872 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15873 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15874 return 1;
15875 }
15876
15877
15878 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15879 PyObject *pyobj;
15880
15881 {
15882 #if wxUSE_UNICODE
15883 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15884 #else
15885 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15886 #endif
15887 }
15888 return pyobj;
15889 }
15890
15891
15892 static int _wrap_ART_PRINT_set(PyObject *) {
15893 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15894 return 1;
15895 }
15896
15897
15898 static PyObject *_wrap_ART_PRINT_get(void) {
15899 PyObject *pyobj;
15900
15901 {
15902 #if wxUSE_UNICODE
15903 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15904 #else
15905 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15906 #endif
15907 }
15908 return pyobj;
15909 }
15910
15911
15912 static int _wrap_ART_HELP_set(PyObject *) {
15913 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15914 return 1;
15915 }
15916
15917
15918 static PyObject *_wrap_ART_HELP_get(void) {
15919 PyObject *pyobj;
15920
15921 {
15922 #if wxUSE_UNICODE
15923 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15924 #else
15925 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15926 #endif
15927 }
15928 return pyobj;
15929 }
15930
15931
15932 static int _wrap_ART_TIP_set(PyObject *) {
15933 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15934 return 1;
15935 }
15936
15937
15938 static PyObject *_wrap_ART_TIP_get(void) {
15939 PyObject *pyobj;
15940
15941 {
15942 #if wxUSE_UNICODE
15943 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15944 #else
15945 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15946 #endif
15947 }
15948 return pyobj;
15949 }
15950
15951
15952 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15953 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15954 return 1;
15955 }
15956
15957
15958 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15959 PyObject *pyobj;
15960
15961 {
15962 #if wxUSE_UNICODE
15963 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15964 #else
15965 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15966 #endif
15967 }
15968 return pyobj;
15969 }
15970
15971
15972 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15973 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15974 return 1;
15975 }
15976
15977
15978 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15979 PyObject *pyobj;
15980
15981 {
15982 #if wxUSE_UNICODE
15983 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15984 #else
15985 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15986 #endif
15987 }
15988 return pyobj;
15989 }
15990
15991
15992 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15993 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15994 return 1;
15995 }
15996
15997
15998 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15999 PyObject *pyobj;
16000
16001 {
16002 #if wxUSE_UNICODE
16003 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16004 #else
16005 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16006 #endif
16007 }
16008 return pyobj;
16009 }
16010
16011
16012 static int _wrap_ART_HARDDISK_set(PyObject *) {
16013 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16014 return 1;
16015 }
16016
16017
16018 static PyObject *_wrap_ART_HARDDISK_get(void) {
16019 PyObject *pyobj;
16020
16021 {
16022 #if wxUSE_UNICODE
16023 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16024 #else
16025 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16026 #endif
16027 }
16028 return pyobj;
16029 }
16030
16031
16032 static int _wrap_ART_FLOPPY_set(PyObject *) {
16033 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16034 return 1;
16035 }
16036
16037
16038 static PyObject *_wrap_ART_FLOPPY_get(void) {
16039 PyObject *pyobj;
16040
16041 {
16042 #if wxUSE_UNICODE
16043 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16044 #else
16045 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16046 #endif
16047 }
16048 return pyobj;
16049 }
16050
16051
16052 static int _wrap_ART_CDROM_set(PyObject *) {
16053 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16054 return 1;
16055 }
16056
16057
16058 static PyObject *_wrap_ART_CDROM_get(void) {
16059 PyObject *pyobj;
16060
16061 {
16062 #if wxUSE_UNICODE
16063 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16064 #else
16065 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16066 #endif
16067 }
16068 return pyobj;
16069 }
16070
16071
16072 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16073 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16074 return 1;
16075 }
16076
16077
16078 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16079 PyObject *pyobj;
16080
16081 {
16082 #if wxUSE_UNICODE
16083 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16084 #else
16085 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16086 #endif
16087 }
16088 return pyobj;
16089 }
16090
16091
16092 static int _wrap_ART_FOLDER_set(PyObject *) {
16093 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16094 return 1;
16095 }
16096
16097
16098 static PyObject *_wrap_ART_FOLDER_get(void) {
16099 PyObject *pyobj;
16100
16101 {
16102 #if wxUSE_UNICODE
16103 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16104 #else
16105 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16106 #endif
16107 }
16108 return pyobj;
16109 }
16110
16111
16112 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16113 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16114 return 1;
16115 }
16116
16117
16118 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16119 PyObject *pyobj;
16120
16121 {
16122 #if wxUSE_UNICODE
16123 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16124 #else
16125 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16126 #endif
16127 }
16128 return pyobj;
16129 }
16130
16131
16132 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16133 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16134 return 1;
16135 }
16136
16137
16138 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16139 PyObject *pyobj;
16140
16141 {
16142 #if wxUSE_UNICODE
16143 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16144 #else
16145 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16146 #endif
16147 }
16148 return pyobj;
16149 }
16150
16151
16152 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16153 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16154 return 1;
16155 }
16156
16157
16158 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16159 PyObject *pyobj;
16160
16161 {
16162 #if wxUSE_UNICODE
16163 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16164 #else
16165 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16166 #endif
16167 }
16168 return pyobj;
16169 }
16170
16171
16172 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16173 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16174 return 1;
16175 }
16176
16177
16178 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16179 PyObject *pyobj;
16180
16181 {
16182 #if wxUSE_UNICODE
16183 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16184 #else
16185 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16186 #endif
16187 }
16188 return pyobj;
16189 }
16190
16191
16192 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16193 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16194 return 1;
16195 }
16196
16197
16198 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16199 PyObject *pyobj;
16200
16201 {
16202 #if wxUSE_UNICODE
16203 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16204 #else
16205 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16206 #endif
16207 }
16208 return pyobj;
16209 }
16210
16211
16212 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16213 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16214 return 1;
16215 }
16216
16217
16218 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16219 PyObject *pyobj;
16220
16221 {
16222 #if wxUSE_UNICODE
16223 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16224 #else
16225 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16226 #endif
16227 }
16228 return pyobj;
16229 }
16230
16231
16232 static int _wrap_ART_ERROR_set(PyObject *) {
16233 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16234 return 1;
16235 }
16236
16237
16238 static PyObject *_wrap_ART_ERROR_get(void) {
16239 PyObject *pyobj;
16240
16241 {
16242 #if wxUSE_UNICODE
16243 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16244 #else
16245 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16246 #endif
16247 }
16248 return pyobj;
16249 }
16250
16251
16252 static int _wrap_ART_QUESTION_set(PyObject *) {
16253 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16254 return 1;
16255 }
16256
16257
16258 static PyObject *_wrap_ART_QUESTION_get(void) {
16259 PyObject *pyobj;
16260
16261 {
16262 #if wxUSE_UNICODE
16263 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16264 #else
16265 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16266 #endif
16267 }
16268 return pyobj;
16269 }
16270
16271
16272 static int _wrap_ART_WARNING_set(PyObject *) {
16273 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16274 return 1;
16275 }
16276
16277
16278 static PyObject *_wrap_ART_WARNING_get(void) {
16279 PyObject *pyobj;
16280
16281 {
16282 #if wxUSE_UNICODE
16283 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16284 #else
16285 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16286 #endif
16287 }
16288 return pyobj;
16289 }
16290
16291
16292 static int _wrap_ART_INFORMATION_set(PyObject *) {
16293 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16294 return 1;
16295 }
16296
16297
16298 static PyObject *_wrap_ART_INFORMATION_get(void) {
16299 PyObject *pyobj;
16300
16301 {
16302 #if wxUSE_UNICODE
16303 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16304 #else
16305 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16306 #endif
16307 }
16308 return pyobj;
16309 }
16310
16311
16312 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16313 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16314 return 1;
16315 }
16316
16317
16318 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16319 PyObject *pyobj;
16320
16321 {
16322 #if wxUSE_UNICODE
16323 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16324 #else
16325 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16326 #endif
16327 }
16328 return pyobj;
16329 }
16330
16331
16332 static int _wrap_ART_COPY_set(PyObject *) {
16333 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16334 return 1;
16335 }
16336
16337
16338 static PyObject *_wrap_ART_COPY_get(void) {
16339 PyObject *pyobj;
16340
16341 {
16342 #if wxUSE_UNICODE
16343 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16344 #else
16345 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16346 #endif
16347 }
16348 return pyobj;
16349 }
16350
16351
16352 static int _wrap_ART_CUT_set(PyObject *) {
16353 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16354 return 1;
16355 }
16356
16357
16358 static PyObject *_wrap_ART_CUT_get(void) {
16359 PyObject *pyobj;
16360
16361 {
16362 #if wxUSE_UNICODE
16363 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16364 #else
16365 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16366 #endif
16367 }
16368 return pyobj;
16369 }
16370
16371
16372 static int _wrap_ART_PASTE_set(PyObject *) {
16373 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16374 return 1;
16375 }
16376
16377
16378 static PyObject *_wrap_ART_PASTE_get(void) {
16379 PyObject *pyobj;
16380
16381 {
16382 #if wxUSE_UNICODE
16383 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16384 #else
16385 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16386 #endif
16387 }
16388 return pyobj;
16389 }
16390
16391
16392 static int _wrap_ART_DELETE_set(PyObject *) {
16393 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16394 return 1;
16395 }
16396
16397
16398 static PyObject *_wrap_ART_DELETE_get(void) {
16399 PyObject *pyobj;
16400
16401 {
16402 #if wxUSE_UNICODE
16403 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16404 #else
16405 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16406 #endif
16407 }
16408 return pyobj;
16409 }
16410
16411
16412 static int _wrap_ART_UNDO_set(PyObject *) {
16413 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16414 return 1;
16415 }
16416
16417
16418 static PyObject *_wrap_ART_UNDO_get(void) {
16419 PyObject *pyobj;
16420
16421 {
16422 #if wxUSE_UNICODE
16423 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16424 #else
16425 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16426 #endif
16427 }
16428 return pyobj;
16429 }
16430
16431
16432 static int _wrap_ART_REDO_set(PyObject *) {
16433 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16434 return 1;
16435 }
16436
16437
16438 static PyObject *_wrap_ART_REDO_get(void) {
16439 PyObject *pyobj;
16440
16441 {
16442 #if wxUSE_UNICODE
16443 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16444 #else
16445 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16446 #endif
16447 }
16448 return pyobj;
16449 }
16450
16451
16452 static int _wrap_ART_QUIT_set(PyObject *) {
16453 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16454 return 1;
16455 }
16456
16457
16458 static PyObject *_wrap_ART_QUIT_get(void) {
16459 PyObject *pyobj;
16460
16461 {
16462 #if wxUSE_UNICODE
16463 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16464 #else
16465 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16466 #endif
16467 }
16468 return pyobj;
16469 }
16470
16471
16472 static int _wrap_ART_FIND_set(PyObject *) {
16473 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16474 return 1;
16475 }
16476
16477
16478 static PyObject *_wrap_ART_FIND_get(void) {
16479 PyObject *pyobj;
16480
16481 {
16482 #if wxUSE_UNICODE
16483 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16484 #else
16485 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16486 #endif
16487 }
16488 return pyobj;
16489 }
16490
16491
16492 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16493 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16494 return 1;
16495 }
16496
16497
16498 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16499 PyObject *pyobj;
16500
16501 {
16502 #if wxUSE_UNICODE
16503 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16504 #else
16505 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16506 #endif
16507 }
16508 return pyobj;
16509 }
16510
16511
16512 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16513 PyObject *resultobj;
16514 wxPyArtProvider *result;
16515 char *kwnames[] = {
16516 NULL
16517 };
16518
16519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16520 {
16521 if (!wxPyCheckForApp()) SWIG_fail;
16522 PyThreadState* __tstate = wxPyBeginAllowThreads();
16523 result = (wxPyArtProvider *)new wxPyArtProvider();
16524
16525 wxPyEndAllowThreads(__tstate);
16526 if (PyErr_Occurred()) SWIG_fail;
16527 }
16528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16529 return resultobj;
16530 fail:
16531 return NULL;
16532 }
16533
16534
16535 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16536 PyObject *resultobj;
16537 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16538 PyObject *arg2 = (PyObject *) 0 ;
16539 PyObject *arg3 = (PyObject *) 0 ;
16540 PyObject * obj0 = 0 ;
16541 PyObject * obj1 = 0 ;
16542 PyObject * obj2 = 0 ;
16543 char *kwnames[] = {
16544 (char *) "self",(char *) "self",(char *) "_class", NULL
16545 };
16546
16547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16549 if (SWIG_arg_fail(1)) SWIG_fail;
16550 arg2 = obj1;
16551 arg3 = obj2;
16552 {
16553 PyThreadState* __tstate = wxPyBeginAllowThreads();
16554 (arg1)->_setCallbackInfo(arg2,arg3);
16555
16556 wxPyEndAllowThreads(__tstate);
16557 if (PyErr_Occurred()) SWIG_fail;
16558 }
16559 Py_INCREF(Py_None); resultobj = Py_None;
16560 return resultobj;
16561 fail:
16562 return NULL;
16563 }
16564
16565
16566 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16567 PyObject *resultobj;
16568 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16569 PyObject * obj0 = 0 ;
16570 char *kwnames[] = {
16571 (char *) "provider", NULL
16572 };
16573
16574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16576 if (SWIG_arg_fail(1)) SWIG_fail;
16577 {
16578 PyThreadState* __tstate = wxPyBeginAllowThreads();
16579 wxPyArtProvider::PushProvider(arg1);
16580
16581 wxPyEndAllowThreads(__tstate);
16582 if (PyErr_Occurred()) SWIG_fail;
16583 }
16584 Py_INCREF(Py_None); resultobj = Py_None;
16585 return resultobj;
16586 fail:
16587 return NULL;
16588 }
16589
16590
16591 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16592 PyObject *resultobj;
16593 bool result;
16594 char *kwnames[] = {
16595 NULL
16596 };
16597
16598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16599 {
16600 PyThreadState* __tstate = wxPyBeginAllowThreads();
16601 result = (bool)wxPyArtProvider::PopProvider();
16602
16603 wxPyEndAllowThreads(__tstate);
16604 if (PyErr_Occurred()) SWIG_fail;
16605 }
16606 {
16607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16608 }
16609 return resultobj;
16610 fail:
16611 return NULL;
16612 }
16613
16614
16615 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16616 PyObject *resultobj;
16617 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16618 bool result;
16619 PyObject * obj0 = 0 ;
16620 char *kwnames[] = {
16621 (char *) "provider", NULL
16622 };
16623
16624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16626 if (SWIG_arg_fail(1)) SWIG_fail;
16627 {
16628 PyThreadState* __tstate = wxPyBeginAllowThreads();
16629 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16630
16631 wxPyEndAllowThreads(__tstate);
16632 if (PyErr_Occurred()) SWIG_fail;
16633 }
16634 {
16635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16636 }
16637 return resultobj;
16638 fail:
16639 return NULL;
16640 }
16641
16642
16643 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16644 PyObject *resultobj;
16645 wxString *arg1 = 0 ;
16646 wxString const &arg2_defvalue = wxPyART_OTHER ;
16647 wxString *arg2 = (wxString *) &arg2_defvalue ;
16648 wxSize const &arg3_defvalue = wxDefaultSize ;
16649 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16650 wxBitmap result;
16651 bool temp1 = false ;
16652 bool temp2 = false ;
16653 wxSize temp3 ;
16654 PyObject * obj0 = 0 ;
16655 PyObject * obj1 = 0 ;
16656 PyObject * obj2 = 0 ;
16657 char *kwnames[] = {
16658 (char *) "id",(char *) "client",(char *) "size", NULL
16659 };
16660
16661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16662 {
16663 arg1 = wxString_in_helper(obj0);
16664 if (arg1 == NULL) SWIG_fail;
16665 temp1 = true;
16666 }
16667 if (obj1) {
16668 {
16669 arg2 = wxString_in_helper(obj1);
16670 if (arg2 == NULL) SWIG_fail;
16671 temp2 = true;
16672 }
16673 }
16674 if (obj2) {
16675 {
16676 arg3 = &temp3;
16677 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16678 }
16679 }
16680 {
16681 if (!wxPyCheckForApp()) SWIG_fail;
16682 PyThreadState* __tstate = wxPyBeginAllowThreads();
16683 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16684
16685 wxPyEndAllowThreads(__tstate);
16686 if (PyErr_Occurred()) SWIG_fail;
16687 }
16688 {
16689 wxBitmap * resultptr;
16690 resultptr = new wxBitmap((wxBitmap &)(result));
16691 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16692 }
16693 {
16694 if (temp1)
16695 delete arg1;
16696 }
16697 {
16698 if (temp2)
16699 delete arg2;
16700 }
16701 return resultobj;
16702 fail:
16703 {
16704 if (temp1)
16705 delete arg1;
16706 }
16707 {
16708 if (temp2)
16709 delete arg2;
16710 }
16711 return NULL;
16712 }
16713
16714
16715 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16716 PyObject *resultobj;
16717 wxString *arg1 = 0 ;
16718 wxString const &arg2_defvalue = wxPyART_OTHER ;
16719 wxString *arg2 = (wxString *) &arg2_defvalue ;
16720 wxSize const &arg3_defvalue = wxDefaultSize ;
16721 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16722 wxIcon result;
16723 bool temp1 = false ;
16724 bool temp2 = false ;
16725 wxSize temp3 ;
16726 PyObject * obj0 = 0 ;
16727 PyObject * obj1 = 0 ;
16728 PyObject * obj2 = 0 ;
16729 char *kwnames[] = {
16730 (char *) "id",(char *) "client",(char *) "size", NULL
16731 };
16732
16733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16734 {
16735 arg1 = wxString_in_helper(obj0);
16736 if (arg1 == NULL) SWIG_fail;
16737 temp1 = true;
16738 }
16739 if (obj1) {
16740 {
16741 arg2 = wxString_in_helper(obj1);
16742 if (arg2 == NULL) SWIG_fail;
16743 temp2 = true;
16744 }
16745 }
16746 if (obj2) {
16747 {
16748 arg3 = &temp3;
16749 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16750 }
16751 }
16752 {
16753 if (!wxPyCheckForApp()) SWIG_fail;
16754 PyThreadState* __tstate = wxPyBeginAllowThreads();
16755 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16756
16757 wxPyEndAllowThreads(__tstate);
16758 if (PyErr_Occurred()) SWIG_fail;
16759 }
16760 {
16761 wxIcon * resultptr;
16762 resultptr = new wxIcon((wxIcon &)(result));
16763 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16764 }
16765 {
16766 if (temp1)
16767 delete arg1;
16768 }
16769 {
16770 if (temp2)
16771 delete arg2;
16772 }
16773 return resultobj;
16774 fail:
16775 {
16776 if (temp1)
16777 delete arg1;
16778 }
16779 {
16780 if (temp2)
16781 delete arg2;
16782 }
16783 return NULL;
16784 }
16785
16786
16787 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16788 PyObject *resultobj;
16789 wxString *arg1 = 0 ;
16790 bool arg2 = (bool) false ;
16791 wxSize result;
16792 bool temp1 = false ;
16793 PyObject * obj0 = 0 ;
16794 PyObject * obj1 = 0 ;
16795 char *kwnames[] = {
16796 (char *) "client",(char *) "platform_dependent", NULL
16797 };
16798
16799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16800 {
16801 arg1 = wxString_in_helper(obj0);
16802 if (arg1 == NULL) SWIG_fail;
16803 temp1 = true;
16804 }
16805 if (obj1) {
16806 {
16807 arg2 = (bool)(SWIG_As_bool(obj1));
16808 if (SWIG_arg_fail(2)) SWIG_fail;
16809 }
16810 }
16811 {
16812 PyThreadState* __tstate = wxPyBeginAllowThreads();
16813 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16814
16815 wxPyEndAllowThreads(__tstate);
16816 if (PyErr_Occurred()) SWIG_fail;
16817 }
16818 {
16819 wxSize * resultptr;
16820 resultptr = new wxSize((wxSize &)(result));
16821 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16822 }
16823 {
16824 if (temp1)
16825 delete arg1;
16826 }
16827 return resultobj;
16828 fail:
16829 {
16830 if (temp1)
16831 delete arg1;
16832 }
16833 return NULL;
16834 }
16835
16836
16837 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16838 PyObject *resultobj;
16839 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16840 PyObject * obj0 = 0 ;
16841 char *kwnames[] = {
16842 (char *) "self", NULL
16843 };
16844
16845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16847 if (SWIG_arg_fail(1)) SWIG_fail;
16848 {
16849 PyThreadState* __tstate = wxPyBeginAllowThreads();
16850 wxPyArtProvider_Destroy(arg1);
16851
16852 wxPyEndAllowThreads(__tstate);
16853 if (PyErr_Occurred()) SWIG_fail;
16854 }
16855 Py_INCREF(Py_None); resultobj = Py_None;
16856 return resultobj;
16857 fail:
16858 return NULL;
16859 }
16860
16861
16862 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16863 PyObject *obj;
16864 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16865 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16866 Py_INCREF(obj);
16867 return Py_BuildValue((char *)"");
16868 }
16869 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16870 PyObject *resultobj;
16871 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16872 PyObject * obj0 = 0 ;
16873 char *kwnames[] = {
16874 (char *) "self", NULL
16875 };
16876
16877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16879 if (SWIG_arg_fail(1)) SWIG_fail;
16880 {
16881 PyThreadState* __tstate = wxPyBeginAllowThreads();
16882 delete arg1;
16883
16884 wxPyEndAllowThreads(__tstate);
16885 if (PyErr_Occurred()) SWIG_fail;
16886 }
16887 Py_INCREF(Py_None); resultobj = Py_None;
16888 return resultobj;
16889 fail:
16890 return NULL;
16891 }
16892
16893
16894 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16895 PyObject *resultobj;
16896 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16897 wxConfigBase *result;
16898 PyObject * obj0 = 0 ;
16899 char *kwnames[] = {
16900 (char *) "config", NULL
16901 };
16902
16903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16905 if (SWIG_arg_fail(1)) SWIG_fail;
16906 {
16907 PyThreadState* __tstate = wxPyBeginAllowThreads();
16908 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16909
16910 wxPyEndAllowThreads(__tstate);
16911 if (PyErr_Occurred()) SWIG_fail;
16912 }
16913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16914 return resultobj;
16915 fail:
16916 return NULL;
16917 }
16918
16919
16920 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16921 PyObject *resultobj;
16922 bool arg1 = (bool) true ;
16923 wxConfigBase *result;
16924 PyObject * obj0 = 0 ;
16925 char *kwnames[] = {
16926 (char *) "createOnDemand", NULL
16927 };
16928
16929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16930 if (obj0) {
16931 {
16932 arg1 = (bool)(SWIG_As_bool(obj0));
16933 if (SWIG_arg_fail(1)) SWIG_fail;
16934 }
16935 }
16936 {
16937 PyThreadState* __tstate = wxPyBeginAllowThreads();
16938 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16939
16940 wxPyEndAllowThreads(__tstate);
16941 if (PyErr_Occurred()) SWIG_fail;
16942 }
16943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16944 return resultobj;
16945 fail:
16946 return NULL;
16947 }
16948
16949
16950 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16951 PyObject *resultobj;
16952 wxConfigBase *result;
16953 char *kwnames[] = {
16954 NULL
16955 };
16956
16957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16958 {
16959 PyThreadState* __tstate = wxPyBeginAllowThreads();
16960 result = (wxConfigBase *)wxConfigBase::Create();
16961
16962 wxPyEndAllowThreads(__tstate);
16963 if (PyErr_Occurred()) SWIG_fail;
16964 }
16965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16966 return resultobj;
16967 fail:
16968 return NULL;
16969 }
16970
16971
16972 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16973 PyObject *resultobj;
16974 char *kwnames[] = {
16975 NULL
16976 };
16977
16978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16979 {
16980 PyThreadState* __tstate = wxPyBeginAllowThreads();
16981 wxConfigBase::DontCreateOnDemand();
16982
16983 wxPyEndAllowThreads(__tstate);
16984 if (PyErr_Occurred()) SWIG_fail;
16985 }
16986 Py_INCREF(Py_None); resultobj = Py_None;
16987 return resultobj;
16988 fail:
16989 return NULL;
16990 }
16991
16992
16993 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16994 PyObject *resultobj;
16995 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16996 wxString *arg2 = 0 ;
16997 bool temp2 = false ;
16998 PyObject * obj0 = 0 ;
16999 PyObject * obj1 = 0 ;
17000 char *kwnames[] = {
17001 (char *) "self",(char *) "path", NULL
17002 };
17003
17004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17006 if (SWIG_arg_fail(1)) SWIG_fail;
17007 {
17008 arg2 = wxString_in_helper(obj1);
17009 if (arg2 == NULL) SWIG_fail;
17010 temp2 = true;
17011 }
17012 {
17013 PyThreadState* __tstate = wxPyBeginAllowThreads();
17014 (arg1)->SetPath((wxString const &)*arg2);
17015
17016 wxPyEndAllowThreads(__tstate);
17017 if (PyErr_Occurred()) SWIG_fail;
17018 }
17019 Py_INCREF(Py_None); resultobj = Py_None;
17020 {
17021 if (temp2)
17022 delete arg2;
17023 }
17024 return resultobj;
17025 fail:
17026 {
17027 if (temp2)
17028 delete arg2;
17029 }
17030 return NULL;
17031 }
17032
17033
17034 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17035 PyObject *resultobj;
17036 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17037 wxString *result;
17038 PyObject * obj0 = 0 ;
17039 char *kwnames[] = {
17040 (char *) "self", NULL
17041 };
17042
17043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17045 if (SWIG_arg_fail(1)) SWIG_fail;
17046 {
17047 PyThreadState* __tstate = wxPyBeginAllowThreads();
17048 {
17049 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17050 result = (wxString *) &_result_ref;
17051 }
17052
17053 wxPyEndAllowThreads(__tstate);
17054 if (PyErr_Occurred()) SWIG_fail;
17055 }
17056 {
17057 #if wxUSE_UNICODE
17058 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17059 #else
17060 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17061 #endif
17062 }
17063 return resultobj;
17064 fail:
17065 return NULL;
17066 }
17067
17068
17069 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17070 PyObject *resultobj;
17071 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17072 PyObject *result;
17073 PyObject * obj0 = 0 ;
17074 char *kwnames[] = {
17075 (char *) "self", NULL
17076 };
17077
17078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17080 if (SWIG_arg_fail(1)) SWIG_fail;
17081 {
17082 PyThreadState* __tstate = wxPyBeginAllowThreads();
17083 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17084
17085 wxPyEndAllowThreads(__tstate);
17086 if (PyErr_Occurred()) SWIG_fail;
17087 }
17088 resultobj = result;
17089 return resultobj;
17090 fail:
17091 return NULL;
17092 }
17093
17094
17095 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17096 PyObject *resultobj;
17097 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17098 long arg2 ;
17099 PyObject *result;
17100 PyObject * obj0 = 0 ;
17101 PyObject * obj1 = 0 ;
17102 char *kwnames[] = {
17103 (char *) "self",(char *) "index", NULL
17104 };
17105
17106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17108 if (SWIG_arg_fail(1)) SWIG_fail;
17109 {
17110 arg2 = (long)(SWIG_As_long(obj1));
17111 if (SWIG_arg_fail(2)) SWIG_fail;
17112 }
17113 {
17114 PyThreadState* __tstate = wxPyBeginAllowThreads();
17115 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17116
17117 wxPyEndAllowThreads(__tstate);
17118 if (PyErr_Occurred()) SWIG_fail;
17119 }
17120 resultobj = result;
17121 return resultobj;
17122 fail:
17123 return NULL;
17124 }
17125
17126
17127 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17128 PyObject *resultobj;
17129 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17130 PyObject *result;
17131 PyObject * obj0 = 0 ;
17132 char *kwnames[] = {
17133 (char *) "self", NULL
17134 };
17135
17136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17138 if (SWIG_arg_fail(1)) SWIG_fail;
17139 {
17140 PyThreadState* __tstate = wxPyBeginAllowThreads();
17141 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17142
17143 wxPyEndAllowThreads(__tstate);
17144 if (PyErr_Occurred()) SWIG_fail;
17145 }
17146 resultobj = result;
17147 return resultobj;
17148 fail:
17149 return NULL;
17150 }
17151
17152
17153 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17154 PyObject *resultobj;
17155 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17156 long arg2 ;
17157 PyObject *result;
17158 PyObject * obj0 = 0 ;
17159 PyObject * obj1 = 0 ;
17160 char *kwnames[] = {
17161 (char *) "self",(char *) "index", NULL
17162 };
17163
17164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17166 if (SWIG_arg_fail(1)) SWIG_fail;
17167 {
17168 arg2 = (long)(SWIG_As_long(obj1));
17169 if (SWIG_arg_fail(2)) SWIG_fail;
17170 }
17171 {
17172 PyThreadState* __tstate = wxPyBeginAllowThreads();
17173 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17174
17175 wxPyEndAllowThreads(__tstate);
17176 if (PyErr_Occurred()) SWIG_fail;
17177 }
17178 resultobj = result;
17179 return resultobj;
17180 fail:
17181 return NULL;
17182 }
17183
17184
17185 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17186 PyObject *resultobj;
17187 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17188 bool arg2 = (bool) false ;
17189 size_t result;
17190 PyObject * obj0 = 0 ;
17191 PyObject * obj1 = 0 ;
17192 char *kwnames[] = {
17193 (char *) "self",(char *) "recursive", NULL
17194 };
17195
17196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17198 if (SWIG_arg_fail(1)) SWIG_fail;
17199 if (obj1) {
17200 {
17201 arg2 = (bool)(SWIG_As_bool(obj1));
17202 if (SWIG_arg_fail(2)) SWIG_fail;
17203 }
17204 }
17205 {
17206 PyThreadState* __tstate = wxPyBeginAllowThreads();
17207 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17208
17209 wxPyEndAllowThreads(__tstate);
17210 if (PyErr_Occurred()) SWIG_fail;
17211 }
17212 {
17213 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17214 }
17215 return resultobj;
17216 fail:
17217 return NULL;
17218 }
17219
17220
17221 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17222 PyObject *resultobj;
17223 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17224 bool arg2 = (bool) false ;
17225 size_t result;
17226 PyObject * obj0 = 0 ;
17227 PyObject * obj1 = 0 ;
17228 char *kwnames[] = {
17229 (char *) "self",(char *) "recursive", NULL
17230 };
17231
17232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17234 if (SWIG_arg_fail(1)) SWIG_fail;
17235 if (obj1) {
17236 {
17237 arg2 = (bool)(SWIG_As_bool(obj1));
17238 if (SWIG_arg_fail(2)) SWIG_fail;
17239 }
17240 }
17241 {
17242 PyThreadState* __tstate = wxPyBeginAllowThreads();
17243 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17244
17245 wxPyEndAllowThreads(__tstate);
17246 if (PyErr_Occurred()) SWIG_fail;
17247 }
17248 {
17249 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17250 }
17251 return resultobj;
17252 fail:
17253 return NULL;
17254 }
17255
17256
17257 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17258 PyObject *resultobj;
17259 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17260 wxString *arg2 = 0 ;
17261 bool result;
17262 bool temp2 = false ;
17263 PyObject * obj0 = 0 ;
17264 PyObject * obj1 = 0 ;
17265 char *kwnames[] = {
17266 (char *) "self",(char *) "name", NULL
17267 };
17268
17269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17271 if (SWIG_arg_fail(1)) SWIG_fail;
17272 {
17273 arg2 = wxString_in_helper(obj1);
17274 if (arg2 == NULL) SWIG_fail;
17275 temp2 = true;
17276 }
17277 {
17278 PyThreadState* __tstate = wxPyBeginAllowThreads();
17279 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17280
17281 wxPyEndAllowThreads(__tstate);
17282 if (PyErr_Occurred()) SWIG_fail;
17283 }
17284 {
17285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17286 }
17287 {
17288 if (temp2)
17289 delete arg2;
17290 }
17291 return resultobj;
17292 fail:
17293 {
17294 if (temp2)
17295 delete arg2;
17296 }
17297 return NULL;
17298 }
17299
17300
17301 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17302 PyObject *resultobj;
17303 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17304 wxString *arg2 = 0 ;
17305 bool result;
17306 bool temp2 = false ;
17307 PyObject * obj0 = 0 ;
17308 PyObject * obj1 = 0 ;
17309 char *kwnames[] = {
17310 (char *) "self",(char *) "name", NULL
17311 };
17312
17313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17315 if (SWIG_arg_fail(1)) SWIG_fail;
17316 {
17317 arg2 = wxString_in_helper(obj1);
17318 if (arg2 == NULL) SWIG_fail;
17319 temp2 = true;
17320 }
17321 {
17322 PyThreadState* __tstate = wxPyBeginAllowThreads();
17323 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17324
17325 wxPyEndAllowThreads(__tstate);
17326 if (PyErr_Occurred()) SWIG_fail;
17327 }
17328 {
17329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17330 }
17331 {
17332 if (temp2)
17333 delete arg2;
17334 }
17335 return resultobj;
17336 fail:
17337 {
17338 if (temp2)
17339 delete arg2;
17340 }
17341 return NULL;
17342 }
17343
17344
17345 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17346 PyObject *resultobj;
17347 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17348 wxString *arg2 = 0 ;
17349 bool result;
17350 bool temp2 = false ;
17351 PyObject * obj0 = 0 ;
17352 PyObject * obj1 = 0 ;
17353 char *kwnames[] = {
17354 (char *) "self",(char *) "name", NULL
17355 };
17356
17357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17359 if (SWIG_arg_fail(1)) SWIG_fail;
17360 {
17361 arg2 = wxString_in_helper(obj1);
17362 if (arg2 == NULL) SWIG_fail;
17363 temp2 = true;
17364 }
17365 {
17366 PyThreadState* __tstate = wxPyBeginAllowThreads();
17367 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17368
17369 wxPyEndAllowThreads(__tstate);
17370 if (PyErr_Occurred()) SWIG_fail;
17371 }
17372 {
17373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17374 }
17375 {
17376 if (temp2)
17377 delete arg2;
17378 }
17379 return resultobj;
17380 fail:
17381 {
17382 if (temp2)
17383 delete arg2;
17384 }
17385 return NULL;
17386 }
17387
17388
17389 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17390 PyObject *resultobj;
17391 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17392 wxString *arg2 = 0 ;
17393 wxConfigBase::EntryType result;
17394 bool temp2 = false ;
17395 PyObject * obj0 = 0 ;
17396 PyObject * obj1 = 0 ;
17397 char *kwnames[] = {
17398 (char *) "self",(char *) "name", NULL
17399 };
17400
17401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17403 if (SWIG_arg_fail(1)) SWIG_fail;
17404 {
17405 arg2 = wxString_in_helper(obj1);
17406 if (arg2 == NULL) SWIG_fail;
17407 temp2 = true;
17408 }
17409 {
17410 PyThreadState* __tstate = wxPyBeginAllowThreads();
17411 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17412
17413 wxPyEndAllowThreads(__tstate);
17414 if (PyErr_Occurred()) SWIG_fail;
17415 }
17416 resultobj = SWIG_From_int((result));
17417 {
17418 if (temp2)
17419 delete arg2;
17420 }
17421 return resultobj;
17422 fail:
17423 {
17424 if (temp2)
17425 delete arg2;
17426 }
17427 return NULL;
17428 }
17429
17430
17431 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17432 PyObject *resultobj;
17433 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17434 wxString *arg2 = 0 ;
17435 wxString const &arg3_defvalue = wxPyEmptyString ;
17436 wxString *arg3 = (wxString *) &arg3_defvalue ;
17437 wxString result;
17438 bool temp2 = false ;
17439 bool temp3 = false ;
17440 PyObject * obj0 = 0 ;
17441 PyObject * obj1 = 0 ;
17442 PyObject * obj2 = 0 ;
17443 char *kwnames[] = {
17444 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17445 };
17446
17447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17449 if (SWIG_arg_fail(1)) SWIG_fail;
17450 {
17451 arg2 = wxString_in_helper(obj1);
17452 if (arg2 == NULL) SWIG_fail;
17453 temp2 = true;
17454 }
17455 if (obj2) {
17456 {
17457 arg3 = wxString_in_helper(obj2);
17458 if (arg3 == NULL) SWIG_fail;
17459 temp3 = true;
17460 }
17461 }
17462 {
17463 PyThreadState* __tstate = wxPyBeginAllowThreads();
17464 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17465
17466 wxPyEndAllowThreads(__tstate);
17467 if (PyErr_Occurred()) SWIG_fail;
17468 }
17469 {
17470 #if wxUSE_UNICODE
17471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17472 #else
17473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17474 #endif
17475 }
17476 {
17477 if (temp2)
17478 delete arg2;
17479 }
17480 {
17481 if (temp3)
17482 delete arg3;
17483 }
17484 return resultobj;
17485 fail:
17486 {
17487 if (temp2)
17488 delete arg2;
17489 }
17490 {
17491 if (temp3)
17492 delete arg3;
17493 }
17494 return NULL;
17495 }
17496
17497
17498 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17499 PyObject *resultobj;
17500 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17501 wxString *arg2 = 0 ;
17502 long arg3 = (long) 0 ;
17503 long result;
17504 bool temp2 = false ;
17505 PyObject * obj0 = 0 ;
17506 PyObject * obj1 = 0 ;
17507 PyObject * obj2 = 0 ;
17508 char *kwnames[] = {
17509 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17510 };
17511
17512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17514 if (SWIG_arg_fail(1)) SWIG_fail;
17515 {
17516 arg2 = wxString_in_helper(obj1);
17517 if (arg2 == NULL) SWIG_fail;
17518 temp2 = true;
17519 }
17520 if (obj2) {
17521 {
17522 arg3 = (long)(SWIG_As_long(obj2));
17523 if (SWIG_arg_fail(3)) SWIG_fail;
17524 }
17525 }
17526 {
17527 PyThreadState* __tstate = wxPyBeginAllowThreads();
17528 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17529
17530 wxPyEndAllowThreads(__tstate);
17531 if (PyErr_Occurred()) SWIG_fail;
17532 }
17533 {
17534 resultobj = SWIG_From_long((long)(result));
17535 }
17536 {
17537 if (temp2)
17538 delete arg2;
17539 }
17540 return resultobj;
17541 fail:
17542 {
17543 if (temp2)
17544 delete arg2;
17545 }
17546 return NULL;
17547 }
17548
17549
17550 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17551 PyObject *resultobj;
17552 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17553 wxString *arg2 = 0 ;
17554 double arg3 = (double) 0.0 ;
17555 double result;
17556 bool temp2 = false ;
17557 PyObject * obj0 = 0 ;
17558 PyObject * obj1 = 0 ;
17559 PyObject * obj2 = 0 ;
17560 char *kwnames[] = {
17561 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17562 };
17563
17564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17566 if (SWIG_arg_fail(1)) SWIG_fail;
17567 {
17568 arg2 = wxString_in_helper(obj1);
17569 if (arg2 == NULL) SWIG_fail;
17570 temp2 = true;
17571 }
17572 if (obj2) {
17573 {
17574 arg3 = (double)(SWIG_As_double(obj2));
17575 if (SWIG_arg_fail(3)) SWIG_fail;
17576 }
17577 }
17578 {
17579 PyThreadState* __tstate = wxPyBeginAllowThreads();
17580 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17581
17582 wxPyEndAllowThreads(__tstate);
17583 if (PyErr_Occurred()) SWIG_fail;
17584 }
17585 {
17586 resultobj = SWIG_From_double((double)(result));
17587 }
17588 {
17589 if (temp2)
17590 delete arg2;
17591 }
17592 return resultobj;
17593 fail:
17594 {
17595 if (temp2)
17596 delete arg2;
17597 }
17598 return NULL;
17599 }
17600
17601
17602 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17603 PyObject *resultobj;
17604 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17605 wxString *arg2 = 0 ;
17606 bool arg3 = (bool) false ;
17607 bool result;
17608 bool temp2 = false ;
17609 PyObject * obj0 = 0 ;
17610 PyObject * obj1 = 0 ;
17611 PyObject * obj2 = 0 ;
17612 char *kwnames[] = {
17613 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17614 };
17615
17616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17618 if (SWIG_arg_fail(1)) SWIG_fail;
17619 {
17620 arg2 = wxString_in_helper(obj1);
17621 if (arg2 == NULL) SWIG_fail;
17622 temp2 = true;
17623 }
17624 if (obj2) {
17625 {
17626 arg3 = (bool)(SWIG_As_bool(obj2));
17627 if (SWIG_arg_fail(3)) SWIG_fail;
17628 }
17629 }
17630 {
17631 PyThreadState* __tstate = wxPyBeginAllowThreads();
17632 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17633
17634 wxPyEndAllowThreads(__tstate);
17635 if (PyErr_Occurred()) SWIG_fail;
17636 }
17637 {
17638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17639 }
17640 {
17641 if (temp2)
17642 delete arg2;
17643 }
17644 return resultobj;
17645 fail:
17646 {
17647 if (temp2)
17648 delete arg2;
17649 }
17650 return NULL;
17651 }
17652
17653
17654 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17655 PyObject *resultobj;
17656 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17657 wxString *arg2 = 0 ;
17658 wxString *arg3 = 0 ;
17659 bool result;
17660 bool temp2 = false ;
17661 bool temp3 = false ;
17662 PyObject * obj0 = 0 ;
17663 PyObject * obj1 = 0 ;
17664 PyObject * obj2 = 0 ;
17665 char *kwnames[] = {
17666 (char *) "self",(char *) "key",(char *) "value", NULL
17667 };
17668
17669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17671 if (SWIG_arg_fail(1)) SWIG_fail;
17672 {
17673 arg2 = wxString_in_helper(obj1);
17674 if (arg2 == NULL) SWIG_fail;
17675 temp2 = true;
17676 }
17677 {
17678 arg3 = wxString_in_helper(obj2);
17679 if (arg3 == NULL) SWIG_fail;
17680 temp3 = true;
17681 }
17682 {
17683 PyThreadState* __tstate = wxPyBeginAllowThreads();
17684 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17685
17686 wxPyEndAllowThreads(__tstate);
17687 if (PyErr_Occurred()) SWIG_fail;
17688 }
17689 {
17690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17691 }
17692 {
17693 if (temp2)
17694 delete arg2;
17695 }
17696 {
17697 if (temp3)
17698 delete arg3;
17699 }
17700 return resultobj;
17701 fail:
17702 {
17703 if (temp2)
17704 delete arg2;
17705 }
17706 {
17707 if (temp3)
17708 delete arg3;
17709 }
17710 return NULL;
17711 }
17712
17713
17714 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17715 PyObject *resultobj;
17716 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17717 wxString *arg2 = 0 ;
17718 long arg3 ;
17719 bool result;
17720 bool temp2 = false ;
17721 PyObject * obj0 = 0 ;
17722 PyObject * obj1 = 0 ;
17723 PyObject * obj2 = 0 ;
17724 char *kwnames[] = {
17725 (char *) "self",(char *) "key",(char *) "value", NULL
17726 };
17727
17728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17730 if (SWIG_arg_fail(1)) SWIG_fail;
17731 {
17732 arg2 = wxString_in_helper(obj1);
17733 if (arg2 == NULL) SWIG_fail;
17734 temp2 = true;
17735 }
17736 {
17737 arg3 = (long)(SWIG_As_long(obj2));
17738 if (SWIG_arg_fail(3)) SWIG_fail;
17739 }
17740 {
17741 PyThreadState* __tstate = wxPyBeginAllowThreads();
17742 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17743
17744 wxPyEndAllowThreads(__tstate);
17745 if (PyErr_Occurred()) SWIG_fail;
17746 }
17747 {
17748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17749 }
17750 {
17751 if (temp2)
17752 delete arg2;
17753 }
17754 return resultobj;
17755 fail:
17756 {
17757 if (temp2)
17758 delete arg2;
17759 }
17760 return NULL;
17761 }
17762
17763
17764 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17765 PyObject *resultobj;
17766 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17767 wxString *arg2 = 0 ;
17768 double arg3 ;
17769 bool result;
17770 bool temp2 = false ;
17771 PyObject * obj0 = 0 ;
17772 PyObject * obj1 = 0 ;
17773 PyObject * obj2 = 0 ;
17774 char *kwnames[] = {
17775 (char *) "self",(char *) "key",(char *) "value", NULL
17776 };
17777
17778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17780 if (SWIG_arg_fail(1)) SWIG_fail;
17781 {
17782 arg2 = wxString_in_helper(obj1);
17783 if (arg2 == NULL) SWIG_fail;
17784 temp2 = true;
17785 }
17786 {
17787 arg3 = (double)(SWIG_As_double(obj2));
17788 if (SWIG_arg_fail(3)) SWIG_fail;
17789 }
17790 {
17791 PyThreadState* __tstate = wxPyBeginAllowThreads();
17792 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17793
17794 wxPyEndAllowThreads(__tstate);
17795 if (PyErr_Occurred()) SWIG_fail;
17796 }
17797 {
17798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17799 }
17800 {
17801 if (temp2)
17802 delete arg2;
17803 }
17804 return resultobj;
17805 fail:
17806 {
17807 if (temp2)
17808 delete arg2;
17809 }
17810 return NULL;
17811 }
17812
17813
17814 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17815 PyObject *resultobj;
17816 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17817 wxString *arg2 = 0 ;
17818 bool arg3 ;
17819 bool result;
17820 bool temp2 = false ;
17821 PyObject * obj0 = 0 ;
17822 PyObject * obj1 = 0 ;
17823 PyObject * obj2 = 0 ;
17824 char *kwnames[] = {
17825 (char *) "self",(char *) "key",(char *) "value", NULL
17826 };
17827
17828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17830 if (SWIG_arg_fail(1)) SWIG_fail;
17831 {
17832 arg2 = wxString_in_helper(obj1);
17833 if (arg2 == NULL) SWIG_fail;
17834 temp2 = true;
17835 }
17836 {
17837 arg3 = (bool)(SWIG_As_bool(obj2));
17838 if (SWIG_arg_fail(3)) SWIG_fail;
17839 }
17840 {
17841 PyThreadState* __tstate = wxPyBeginAllowThreads();
17842 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17843
17844 wxPyEndAllowThreads(__tstate);
17845 if (PyErr_Occurred()) SWIG_fail;
17846 }
17847 {
17848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17849 }
17850 {
17851 if (temp2)
17852 delete arg2;
17853 }
17854 return resultobj;
17855 fail:
17856 {
17857 if (temp2)
17858 delete arg2;
17859 }
17860 return NULL;
17861 }
17862
17863
17864 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17865 PyObject *resultobj;
17866 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17867 bool arg2 = (bool) false ;
17868 bool result;
17869 PyObject * obj0 = 0 ;
17870 PyObject * obj1 = 0 ;
17871 char *kwnames[] = {
17872 (char *) "self",(char *) "currentOnly", NULL
17873 };
17874
17875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17877 if (SWIG_arg_fail(1)) SWIG_fail;
17878 if (obj1) {
17879 {
17880 arg2 = (bool)(SWIG_As_bool(obj1));
17881 if (SWIG_arg_fail(2)) SWIG_fail;
17882 }
17883 }
17884 {
17885 PyThreadState* __tstate = wxPyBeginAllowThreads();
17886 result = (bool)(arg1)->Flush(arg2);
17887
17888 wxPyEndAllowThreads(__tstate);
17889 if (PyErr_Occurred()) SWIG_fail;
17890 }
17891 {
17892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17893 }
17894 return resultobj;
17895 fail:
17896 return NULL;
17897 }
17898
17899
17900 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17901 PyObject *resultobj;
17902 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17903 wxString *arg2 = 0 ;
17904 wxString *arg3 = 0 ;
17905 bool result;
17906 bool temp2 = false ;
17907 bool temp3 = false ;
17908 PyObject * obj0 = 0 ;
17909 PyObject * obj1 = 0 ;
17910 PyObject * obj2 = 0 ;
17911 char *kwnames[] = {
17912 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17913 };
17914
17915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17917 if (SWIG_arg_fail(1)) SWIG_fail;
17918 {
17919 arg2 = wxString_in_helper(obj1);
17920 if (arg2 == NULL) SWIG_fail;
17921 temp2 = true;
17922 }
17923 {
17924 arg3 = wxString_in_helper(obj2);
17925 if (arg3 == NULL) SWIG_fail;
17926 temp3 = true;
17927 }
17928 {
17929 PyThreadState* __tstate = wxPyBeginAllowThreads();
17930 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17931
17932 wxPyEndAllowThreads(__tstate);
17933 if (PyErr_Occurred()) SWIG_fail;
17934 }
17935 {
17936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17937 }
17938 {
17939 if (temp2)
17940 delete arg2;
17941 }
17942 {
17943 if (temp3)
17944 delete arg3;
17945 }
17946 return resultobj;
17947 fail:
17948 {
17949 if (temp2)
17950 delete arg2;
17951 }
17952 {
17953 if (temp3)
17954 delete arg3;
17955 }
17956 return NULL;
17957 }
17958
17959
17960 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17961 PyObject *resultobj;
17962 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17963 wxString *arg2 = 0 ;
17964 wxString *arg3 = 0 ;
17965 bool result;
17966 bool temp2 = false ;
17967 bool temp3 = false ;
17968 PyObject * obj0 = 0 ;
17969 PyObject * obj1 = 0 ;
17970 PyObject * obj2 = 0 ;
17971 char *kwnames[] = {
17972 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17973 };
17974
17975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17977 if (SWIG_arg_fail(1)) SWIG_fail;
17978 {
17979 arg2 = wxString_in_helper(obj1);
17980 if (arg2 == NULL) SWIG_fail;
17981 temp2 = true;
17982 }
17983 {
17984 arg3 = wxString_in_helper(obj2);
17985 if (arg3 == NULL) SWIG_fail;
17986 temp3 = true;
17987 }
17988 {
17989 PyThreadState* __tstate = wxPyBeginAllowThreads();
17990 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17991
17992 wxPyEndAllowThreads(__tstate);
17993 if (PyErr_Occurred()) SWIG_fail;
17994 }
17995 {
17996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17997 }
17998 {
17999 if (temp2)
18000 delete arg2;
18001 }
18002 {
18003 if (temp3)
18004 delete arg3;
18005 }
18006 return resultobj;
18007 fail:
18008 {
18009 if (temp2)
18010 delete arg2;
18011 }
18012 {
18013 if (temp3)
18014 delete arg3;
18015 }
18016 return NULL;
18017 }
18018
18019
18020 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18021 PyObject *resultobj;
18022 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18023 wxString *arg2 = 0 ;
18024 bool arg3 = (bool) true ;
18025 bool result;
18026 bool temp2 = false ;
18027 PyObject * obj0 = 0 ;
18028 PyObject * obj1 = 0 ;
18029 PyObject * obj2 = 0 ;
18030 char *kwnames[] = {
18031 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18032 };
18033
18034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18036 if (SWIG_arg_fail(1)) SWIG_fail;
18037 {
18038 arg2 = wxString_in_helper(obj1);
18039 if (arg2 == NULL) SWIG_fail;
18040 temp2 = true;
18041 }
18042 if (obj2) {
18043 {
18044 arg3 = (bool)(SWIG_As_bool(obj2));
18045 if (SWIG_arg_fail(3)) SWIG_fail;
18046 }
18047 }
18048 {
18049 PyThreadState* __tstate = wxPyBeginAllowThreads();
18050 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18051
18052 wxPyEndAllowThreads(__tstate);
18053 if (PyErr_Occurred()) SWIG_fail;
18054 }
18055 {
18056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18057 }
18058 {
18059 if (temp2)
18060 delete arg2;
18061 }
18062 return resultobj;
18063 fail:
18064 {
18065 if (temp2)
18066 delete arg2;
18067 }
18068 return NULL;
18069 }
18070
18071
18072 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18073 PyObject *resultobj;
18074 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18075 wxString *arg2 = 0 ;
18076 bool result;
18077 bool temp2 = false ;
18078 PyObject * obj0 = 0 ;
18079 PyObject * obj1 = 0 ;
18080 char *kwnames[] = {
18081 (char *) "self",(char *) "key", NULL
18082 };
18083
18084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18086 if (SWIG_arg_fail(1)) SWIG_fail;
18087 {
18088 arg2 = wxString_in_helper(obj1);
18089 if (arg2 == NULL) SWIG_fail;
18090 temp2 = true;
18091 }
18092 {
18093 PyThreadState* __tstate = wxPyBeginAllowThreads();
18094 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18095
18096 wxPyEndAllowThreads(__tstate);
18097 if (PyErr_Occurred()) SWIG_fail;
18098 }
18099 {
18100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18101 }
18102 {
18103 if (temp2)
18104 delete arg2;
18105 }
18106 return resultobj;
18107 fail:
18108 {
18109 if (temp2)
18110 delete arg2;
18111 }
18112 return NULL;
18113 }
18114
18115
18116 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18117 PyObject *resultobj;
18118 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18119 bool result;
18120 PyObject * obj0 = 0 ;
18121 char *kwnames[] = {
18122 (char *) "self", NULL
18123 };
18124
18125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
18130 result = (bool)(arg1)->DeleteAll();
18131
18132 wxPyEndAllowThreads(__tstate);
18133 if (PyErr_Occurred()) SWIG_fail;
18134 }
18135 {
18136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18137 }
18138 return resultobj;
18139 fail:
18140 return NULL;
18141 }
18142
18143
18144 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18145 PyObject *resultobj;
18146 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18147 bool arg2 = (bool) true ;
18148 PyObject * obj0 = 0 ;
18149 PyObject * obj1 = 0 ;
18150 char *kwnames[] = {
18151 (char *) "self",(char *) "doIt", NULL
18152 };
18153
18154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18156 if (SWIG_arg_fail(1)) SWIG_fail;
18157 if (obj1) {
18158 {
18159 arg2 = (bool)(SWIG_As_bool(obj1));
18160 if (SWIG_arg_fail(2)) SWIG_fail;
18161 }
18162 }
18163 {
18164 PyThreadState* __tstate = wxPyBeginAllowThreads();
18165 (arg1)->SetExpandEnvVars(arg2);
18166
18167 wxPyEndAllowThreads(__tstate);
18168 if (PyErr_Occurred()) SWIG_fail;
18169 }
18170 Py_INCREF(Py_None); resultobj = Py_None;
18171 return resultobj;
18172 fail:
18173 return NULL;
18174 }
18175
18176
18177 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18178 PyObject *resultobj;
18179 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18180 bool result;
18181 PyObject * obj0 = 0 ;
18182 char *kwnames[] = {
18183 (char *) "self", NULL
18184 };
18185
18186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18188 if (SWIG_arg_fail(1)) SWIG_fail;
18189 {
18190 PyThreadState* __tstate = wxPyBeginAllowThreads();
18191 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18192
18193 wxPyEndAllowThreads(__tstate);
18194 if (PyErr_Occurred()) SWIG_fail;
18195 }
18196 {
18197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18198 }
18199 return resultobj;
18200 fail:
18201 return NULL;
18202 }
18203
18204
18205 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18206 PyObject *resultobj;
18207 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18208 bool arg2 = (bool) true ;
18209 PyObject * obj0 = 0 ;
18210 PyObject * obj1 = 0 ;
18211 char *kwnames[] = {
18212 (char *) "self",(char *) "doIt", NULL
18213 };
18214
18215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18217 if (SWIG_arg_fail(1)) SWIG_fail;
18218 if (obj1) {
18219 {
18220 arg2 = (bool)(SWIG_As_bool(obj1));
18221 if (SWIG_arg_fail(2)) SWIG_fail;
18222 }
18223 }
18224 {
18225 PyThreadState* __tstate = wxPyBeginAllowThreads();
18226 (arg1)->SetRecordDefaults(arg2);
18227
18228 wxPyEndAllowThreads(__tstate);
18229 if (PyErr_Occurred()) SWIG_fail;
18230 }
18231 Py_INCREF(Py_None); resultobj = Py_None;
18232 return resultobj;
18233 fail:
18234 return NULL;
18235 }
18236
18237
18238 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18239 PyObject *resultobj;
18240 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18241 bool result;
18242 PyObject * obj0 = 0 ;
18243 char *kwnames[] = {
18244 (char *) "self", NULL
18245 };
18246
18247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18249 if (SWIG_arg_fail(1)) SWIG_fail;
18250 {
18251 PyThreadState* __tstate = wxPyBeginAllowThreads();
18252 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18253
18254 wxPyEndAllowThreads(__tstate);
18255 if (PyErr_Occurred()) SWIG_fail;
18256 }
18257 {
18258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18259 }
18260 return resultobj;
18261 fail:
18262 return NULL;
18263 }
18264
18265
18266 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18267 PyObject *resultobj;
18268 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18269 wxString *arg2 = 0 ;
18270 wxString result;
18271 bool temp2 = false ;
18272 PyObject * obj0 = 0 ;
18273 PyObject * obj1 = 0 ;
18274 char *kwnames[] = {
18275 (char *) "self",(char *) "str", NULL
18276 };
18277
18278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18280 if (SWIG_arg_fail(1)) SWIG_fail;
18281 {
18282 arg2 = wxString_in_helper(obj1);
18283 if (arg2 == NULL) SWIG_fail;
18284 temp2 = true;
18285 }
18286 {
18287 PyThreadState* __tstate = wxPyBeginAllowThreads();
18288 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18289
18290 wxPyEndAllowThreads(__tstate);
18291 if (PyErr_Occurred()) SWIG_fail;
18292 }
18293 {
18294 #if wxUSE_UNICODE
18295 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18296 #else
18297 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18298 #endif
18299 }
18300 {
18301 if (temp2)
18302 delete arg2;
18303 }
18304 return resultobj;
18305 fail:
18306 {
18307 if (temp2)
18308 delete arg2;
18309 }
18310 return NULL;
18311 }
18312
18313
18314 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18315 PyObject *resultobj;
18316 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18317 wxString result;
18318 PyObject * obj0 = 0 ;
18319 char *kwnames[] = {
18320 (char *) "self", NULL
18321 };
18322
18323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18325 if (SWIG_arg_fail(1)) SWIG_fail;
18326 {
18327 PyThreadState* __tstate = wxPyBeginAllowThreads();
18328 result = ((wxConfigBase const *)arg1)->GetAppName();
18329
18330 wxPyEndAllowThreads(__tstate);
18331 if (PyErr_Occurred()) SWIG_fail;
18332 }
18333 {
18334 #if wxUSE_UNICODE
18335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18336 #else
18337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18338 #endif
18339 }
18340 return resultobj;
18341 fail:
18342 return NULL;
18343 }
18344
18345
18346 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18347 PyObject *resultobj;
18348 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18349 wxString result;
18350 PyObject * obj0 = 0 ;
18351 char *kwnames[] = {
18352 (char *) "self", NULL
18353 };
18354
18355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18357 if (SWIG_arg_fail(1)) SWIG_fail;
18358 {
18359 PyThreadState* __tstate = wxPyBeginAllowThreads();
18360 result = ((wxConfigBase const *)arg1)->GetVendorName();
18361
18362 wxPyEndAllowThreads(__tstate);
18363 if (PyErr_Occurred()) SWIG_fail;
18364 }
18365 {
18366 #if wxUSE_UNICODE
18367 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18368 #else
18369 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18370 #endif
18371 }
18372 return resultobj;
18373 fail:
18374 return NULL;
18375 }
18376
18377
18378 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18379 PyObject *resultobj;
18380 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18381 wxString *arg2 = 0 ;
18382 bool temp2 = false ;
18383 PyObject * obj0 = 0 ;
18384 PyObject * obj1 = 0 ;
18385 char *kwnames[] = {
18386 (char *) "self",(char *) "appName", NULL
18387 };
18388
18389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18391 if (SWIG_arg_fail(1)) SWIG_fail;
18392 {
18393 arg2 = wxString_in_helper(obj1);
18394 if (arg2 == NULL) SWIG_fail;
18395 temp2 = true;
18396 }
18397 {
18398 PyThreadState* __tstate = wxPyBeginAllowThreads();
18399 (arg1)->SetAppName((wxString const &)*arg2);
18400
18401 wxPyEndAllowThreads(__tstate);
18402 if (PyErr_Occurred()) SWIG_fail;
18403 }
18404 Py_INCREF(Py_None); resultobj = Py_None;
18405 {
18406 if (temp2)
18407 delete arg2;
18408 }
18409 return resultobj;
18410 fail:
18411 {
18412 if (temp2)
18413 delete arg2;
18414 }
18415 return NULL;
18416 }
18417
18418
18419 static PyObject *_wrap_ConfigBase_SetVendorName(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 *) "vendorName", NULL
18428 };
18429
18430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",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)->SetVendorName((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_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18461 PyObject *resultobj;
18462 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18463 long arg2 ;
18464 PyObject * obj0 = 0 ;
18465 PyObject * obj1 = 0 ;
18466 char *kwnames[] = {
18467 (char *) "self",(char *) "style", NULL
18468 };
18469
18470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18472 if (SWIG_arg_fail(1)) SWIG_fail;
18473 {
18474 arg2 = (long)(SWIG_As_long(obj1));
18475 if (SWIG_arg_fail(2)) SWIG_fail;
18476 }
18477 {
18478 PyThreadState* __tstate = wxPyBeginAllowThreads();
18479 (arg1)->SetStyle(arg2);
18480
18481 wxPyEndAllowThreads(__tstate);
18482 if (PyErr_Occurred()) SWIG_fail;
18483 }
18484 Py_INCREF(Py_None); resultobj = Py_None;
18485 return resultobj;
18486 fail:
18487 return NULL;
18488 }
18489
18490
18491 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18492 PyObject *resultobj;
18493 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18494 long result;
18495 PyObject * obj0 = 0 ;
18496 char *kwnames[] = {
18497 (char *) "self", NULL
18498 };
18499
18500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18502 if (SWIG_arg_fail(1)) SWIG_fail;
18503 {
18504 PyThreadState* __tstate = wxPyBeginAllowThreads();
18505 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18506
18507 wxPyEndAllowThreads(__tstate);
18508 if (PyErr_Occurred()) SWIG_fail;
18509 }
18510 {
18511 resultobj = SWIG_From_long((long)(result));
18512 }
18513 return resultobj;
18514 fail:
18515 return NULL;
18516 }
18517
18518
18519 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18520 PyObject *obj;
18521 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18522 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18523 Py_INCREF(obj);
18524 return Py_BuildValue((char *)"");
18525 }
18526 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18527 PyObject *resultobj;
18528 wxString const &arg1_defvalue = wxPyEmptyString ;
18529 wxString *arg1 = (wxString *) &arg1_defvalue ;
18530 wxString const &arg2_defvalue = wxPyEmptyString ;
18531 wxString *arg2 = (wxString *) &arg2_defvalue ;
18532 wxString const &arg3_defvalue = wxPyEmptyString ;
18533 wxString *arg3 = (wxString *) &arg3_defvalue ;
18534 wxString const &arg4_defvalue = wxPyEmptyString ;
18535 wxString *arg4 = (wxString *) &arg4_defvalue ;
18536 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18537 wxConfig *result;
18538 bool temp1 = false ;
18539 bool temp2 = false ;
18540 bool temp3 = false ;
18541 bool temp4 = false ;
18542 PyObject * obj0 = 0 ;
18543 PyObject * obj1 = 0 ;
18544 PyObject * obj2 = 0 ;
18545 PyObject * obj3 = 0 ;
18546 PyObject * obj4 = 0 ;
18547 char *kwnames[] = {
18548 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18549 };
18550
18551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18552 if (obj0) {
18553 {
18554 arg1 = wxString_in_helper(obj0);
18555 if (arg1 == NULL) SWIG_fail;
18556 temp1 = true;
18557 }
18558 }
18559 if (obj1) {
18560 {
18561 arg2 = wxString_in_helper(obj1);
18562 if (arg2 == NULL) SWIG_fail;
18563 temp2 = true;
18564 }
18565 }
18566 if (obj2) {
18567 {
18568 arg3 = wxString_in_helper(obj2);
18569 if (arg3 == NULL) SWIG_fail;
18570 temp3 = true;
18571 }
18572 }
18573 if (obj3) {
18574 {
18575 arg4 = wxString_in_helper(obj3);
18576 if (arg4 == NULL) SWIG_fail;
18577 temp4 = true;
18578 }
18579 }
18580 if (obj4) {
18581 {
18582 arg5 = (long)(SWIG_As_long(obj4));
18583 if (SWIG_arg_fail(5)) SWIG_fail;
18584 }
18585 }
18586 {
18587 PyThreadState* __tstate = wxPyBeginAllowThreads();
18588 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18589
18590 wxPyEndAllowThreads(__tstate);
18591 if (PyErr_Occurred()) SWIG_fail;
18592 }
18593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18594 {
18595 if (temp1)
18596 delete arg1;
18597 }
18598 {
18599 if (temp2)
18600 delete arg2;
18601 }
18602 {
18603 if (temp3)
18604 delete arg3;
18605 }
18606 {
18607 if (temp4)
18608 delete arg4;
18609 }
18610 return resultobj;
18611 fail:
18612 {
18613 if (temp1)
18614 delete arg1;
18615 }
18616 {
18617 if (temp2)
18618 delete arg2;
18619 }
18620 {
18621 if (temp3)
18622 delete arg3;
18623 }
18624 {
18625 if (temp4)
18626 delete arg4;
18627 }
18628 return NULL;
18629 }
18630
18631
18632 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18633 PyObject *resultobj;
18634 wxConfig *arg1 = (wxConfig *) 0 ;
18635 PyObject * obj0 = 0 ;
18636 char *kwnames[] = {
18637 (char *) "self", NULL
18638 };
18639
18640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18642 if (SWIG_arg_fail(1)) SWIG_fail;
18643 {
18644 PyThreadState* __tstate = wxPyBeginAllowThreads();
18645 delete arg1;
18646
18647 wxPyEndAllowThreads(__tstate);
18648 if (PyErr_Occurred()) SWIG_fail;
18649 }
18650 Py_INCREF(Py_None); resultobj = Py_None;
18651 return resultobj;
18652 fail:
18653 return NULL;
18654 }
18655
18656
18657 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18658 PyObject *obj;
18659 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18660 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18661 Py_INCREF(obj);
18662 return Py_BuildValue((char *)"");
18663 }
18664 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18665 PyObject *resultobj;
18666 wxString const &arg1_defvalue = wxPyEmptyString ;
18667 wxString *arg1 = (wxString *) &arg1_defvalue ;
18668 wxString const &arg2_defvalue = wxPyEmptyString ;
18669 wxString *arg2 = (wxString *) &arg2_defvalue ;
18670 wxString const &arg3_defvalue = wxPyEmptyString ;
18671 wxString *arg3 = (wxString *) &arg3_defvalue ;
18672 wxString const &arg4_defvalue = wxPyEmptyString ;
18673 wxString *arg4 = (wxString *) &arg4_defvalue ;
18674 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18675 wxFileConfig *result;
18676 bool temp1 = false ;
18677 bool temp2 = false ;
18678 bool temp3 = false ;
18679 bool temp4 = false ;
18680 PyObject * obj0 = 0 ;
18681 PyObject * obj1 = 0 ;
18682 PyObject * obj2 = 0 ;
18683 PyObject * obj3 = 0 ;
18684 PyObject * obj4 = 0 ;
18685 char *kwnames[] = {
18686 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18687 };
18688
18689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18690 if (obj0) {
18691 {
18692 arg1 = wxString_in_helper(obj0);
18693 if (arg1 == NULL) SWIG_fail;
18694 temp1 = true;
18695 }
18696 }
18697 if (obj1) {
18698 {
18699 arg2 = wxString_in_helper(obj1);
18700 if (arg2 == NULL) SWIG_fail;
18701 temp2 = true;
18702 }
18703 }
18704 if (obj2) {
18705 {
18706 arg3 = wxString_in_helper(obj2);
18707 if (arg3 == NULL) SWIG_fail;
18708 temp3 = true;
18709 }
18710 }
18711 if (obj3) {
18712 {
18713 arg4 = wxString_in_helper(obj3);
18714 if (arg4 == NULL) SWIG_fail;
18715 temp4 = true;
18716 }
18717 }
18718 if (obj4) {
18719 {
18720 arg5 = (long)(SWIG_As_long(obj4));
18721 if (SWIG_arg_fail(5)) SWIG_fail;
18722 }
18723 }
18724 {
18725 PyThreadState* __tstate = wxPyBeginAllowThreads();
18726 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18727
18728 wxPyEndAllowThreads(__tstate);
18729 if (PyErr_Occurred()) SWIG_fail;
18730 }
18731 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18732 {
18733 if (temp1)
18734 delete arg1;
18735 }
18736 {
18737 if (temp2)
18738 delete arg2;
18739 }
18740 {
18741 if (temp3)
18742 delete arg3;
18743 }
18744 {
18745 if (temp4)
18746 delete arg4;
18747 }
18748 return resultobj;
18749 fail:
18750 {
18751 if (temp1)
18752 delete arg1;
18753 }
18754 {
18755 if (temp2)
18756 delete arg2;
18757 }
18758 {
18759 if (temp3)
18760 delete arg3;
18761 }
18762 {
18763 if (temp4)
18764 delete arg4;
18765 }
18766 return NULL;
18767 }
18768
18769
18770 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18771 PyObject *resultobj;
18772 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18773 PyObject * obj0 = 0 ;
18774 char *kwnames[] = {
18775 (char *) "self", NULL
18776 };
18777
18778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18780 if (SWIG_arg_fail(1)) SWIG_fail;
18781 {
18782 PyThreadState* __tstate = wxPyBeginAllowThreads();
18783 delete arg1;
18784
18785 wxPyEndAllowThreads(__tstate);
18786 if (PyErr_Occurred()) SWIG_fail;
18787 }
18788 Py_INCREF(Py_None); resultobj = Py_None;
18789 return resultobj;
18790 fail:
18791 return NULL;
18792 }
18793
18794
18795 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18796 PyObject *obj;
18797 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18798 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18799 Py_INCREF(obj);
18800 return Py_BuildValue((char *)"");
18801 }
18802 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18803 PyObject *resultobj;
18804 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18805 wxString *arg2 = 0 ;
18806 wxConfigPathChanger *result;
18807 bool temp2 = false ;
18808 PyObject * obj0 = 0 ;
18809 PyObject * obj1 = 0 ;
18810 char *kwnames[] = {
18811 (char *) "config",(char *) "entry", NULL
18812 };
18813
18814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18816 if (SWIG_arg_fail(1)) SWIG_fail;
18817 {
18818 arg2 = wxString_in_helper(obj1);
18819 if (arg2 == NULL) SWIG_fail;
18820 temp2 = true;
18821 }
18822 {
18823 PyThreadState* __tstate = wxPyBeginAllowThreads();
18824 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18825
18826 wxPyEndAllowThreads(__tstate);
18827 if (PyErr_Occurred()) SWIG_fail;
18828 }
18829 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18830 {
18831 if (temp2)
18832 delete arg2;
18833 }
18834 return resultobj;
18835 fail:
18836 {
18837 if (temp2)
18838 delete arg2;
18839 }
18840 return NULL;
18841 }
18842
18843
18844 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18845 PyObject *resultobj;
18846 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18847 PyObject * obj0 = 0 ;
18848 char *kwnames[] = {
18849 (char *) "self", NULL
18850 };
18851
18852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18854 if (SWIG_arg_fail(1)) SWIG_fail;
18855 {
18856 PyThreadState* __tstate = wxPyBeginAllowThreads();
18857 delete arg1;
18858
18859 wxPyEndAllowThreads(__tstate);
18860 if (PyErr_Occurred()) SWIG_fail;
18861 }
18862 Py_INCREF(Py_None); resultobj = Py_None;
18863 return resultobj;
18864 fail:
18865 return NULL;
18866 }
18867
18868
18869 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18870 PyObject *resultobj;
18871 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18872 wxString *result;
18873 PyObject * obj0 = 0 ;
18874 char *kwnames[] = {
18875 (char *) "self", NULL
18876 };
18877
18878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18880 if (SWIG_arg_fail(1)) SWIG_fail;
18881 {
18882 PyThreadState* __tstate = wxPyBeginAllowThreads();
18883 {
18884 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18885 result = (wxString *) &_result_ref;
18886 }
18887
18888 wxPyEndAllowThreads(__tstate);
18889 if (PyErr_Occurred()) SWIG_fail;
18890 }
18891 {
18892 #if wxUSE_UNICODE
18893 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18894 #else
18895 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18896 #endif
18897 }
18898 return resultobj;
18899 fail:
18900 return NULL;
18901 }
18902
18903
18904 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18905 PyObject *obj;
18906 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18907 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18908 Py_INCREF(obj);
18909 return Py_BuildValue((char *)"");
18910 }
18911 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18912 PyObject *resultobj;
18913 wxString *arg1 = 0 ;
18914 wxString result;
18915 bool temp1 = false ;
18916 PyObject * obj0 = 0 ;
18917 char *kwnames[] = {
18918 (char *) "sz", NULL
18919 };
18920
18921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18922 {
18923 arg1 = wxString_in_helper(obj0);
18924 if (arg1 == NULL) SWIG_fail;
18925 temp1 = true;
18926 }
18927 {
18928 PyThreadState* __tstate = wxPyBeginAllowThreads();
18929 result = wxExpandEnvVars((wxString const &)*arg1);
18930
18931 wxPyEndAllowThreads(__tstate);
18932 if (PyErr_Occurred()) SWIG_fail;
18933 }
18934 {
18935 #if wxUSE_UNICODE
18936 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18937 #else
18938 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18939 #endif
18940 }
18941 {
18942 if (temp1)
18943 delete arg1;
18944 }
18945 return resultobj;
18946 fail:
18947 {
18948 if (temp1)
18949 delete arg1;
18950 }
18951 return NULL;
18952 }
18953
18954
18955 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18956 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18957 return 1;
18958 }
18959
18960
18961 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18962 PyObject *pyobj;
18963
18964 {
18965 #if wxUSE_UNICODE
18966 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18967 #else
18968 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18969 #endif
18970 }
18971 return pyobj;
18972 }
18973
18974
18975 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18976 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18977 return 1;
18978 }
18979
18980
18981 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18982 PyObject *pyobj;
18983
18984 {
18985 #if wxUSE_UNICODE
18986 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18987 #else
18988 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18989 #endif
18990 }
18991 return pyobj;
18992 }
18993
18994
18995 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18996 PyObject *resultobj;
18997 wxDateTime::Country arg1 ;
18998 PyObject * obj0 = 0 ;
18999 char *kwnames[] = {
19000 (char *) "country", NULL
19001 };
19002
19003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19004 {
19005 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19006 if (SWIG_arg_fail(1)) SWIG_fail;
19007 }
19008 {
19009 PyThreadState* __tstate = wxPyBeginAllowThreads();
19010 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19011
19012 wxPyEndAllowThreads(__tstate);
19013 if (PyErr_Occurred()) SWIG_fail;
19014 }
19015 Py_INCREF(Py_None); resultobj = Py_None;
19016 return resultobj;
19017 fail:
19018 return NULL;
19019 }
19020
19021
19022 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19023 PyObject *resultobj;
19024 wxDateTime::Country result;
19025 char *kwnames[] = {
19026 NULL
19027 };
19028
19029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19030 {
19031 PyThreadState* __tstate = wxPyBeginAllowThreads();
19032 result = (wxDateTime::Country)wxDateTime::GetCountry();
19033
19034 wxPyEndAllowThreads(__tstate);
19035 if (PyErr_Occurred()) SWIG_fail;
19036 }
19037 resultobj = SWIG_From_int((result));
19038 return resultobj;
19039 fail:
19040 return NULL;
19041 }
19042
19043
19044 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19045 PyObject *resultobj;
19046 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19047 bool result;
19048 PyObject * obj0 = 0 ;
19049 char *kwnames[] = {
19050 (char *) "country", NULL
19051 };
19052
19053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19054 if (obj0) {
19055 {
19056 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19057 if (SWIG_arg_fail(1)) SWIG_fail;
19058 }
19059 }
19060 {
19061 PyThreadState* __tstate = wxPyBeginAllowThreads();
19062 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19063
19064 wxPyEndAllowThreads(__tstate);
19065 if (PyErr_Occurred()) SWIG_fail;
19066 }
19067 {
19068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19069 }
19070 return resultobj;
19071 fail:
19072 return NULL;
19073 }
19074
19075
19076 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19077 PyObject *resultobj;
19078 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19079 int result;
19080 PyObject * obj0 = 0 ;
19081 char *kwnames[] = {
19082 (char *) "cal", NULL
19083 };
19084
19085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19086 if (obj0) {
19087 {
19088 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19089 if (SWIG_arg_fail(1)) SWIG_fail;
19090 }
19091 }
19092 {
19093 PyThreadState* __tstate = wxPyBeginAllowThreads();
19094 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19095
19096 wxPyEndAllowThreads(__tstate);
19097 if (PyErr_Occurred()) SWIG_fail;
19098 }
19099 {
19100 resultobj = SWIG_From_int((int)(result));
19101 }
19102 return resultobj;
19103 fail:
19104 return NULL;
19105 }
19106
19107
19108 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19109 PyObject *resultobj;
19110 int arg1 ;
19111 int result;
19112 PyObject * obj0 = 0 ;
19113 char *kwnames[] = {
19114 (char *) "year", NULL
19115 };
19116
19117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19118 {
19119 arg1 = (int)(SWIG_As_int(obj0));
19120 if (SWIG_arg_fail(1)) SWIG_fail;
19121 }
19122 {
19123 PyThreadState* __tstate = wxPyBeginAllowThreads();
19124 result = (int)wxDateTime::ConvertYearToBC(arg1);
19125
19126 wxPyEndAllowThreads(__tstate);
19127 if (PyErr_Occurred()) SWIG_fail;
19128 }
19129 {
19130 resultobj = SWIG_From_int((int)(result));
19131 }
19132 return resultobj;
19133 fail:
19134 return NULL;
19135 }
19136
19137
19138 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19139 PyObject *resultobj;
19140 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19141 wxDateTime::Month result;
19142 PyObject * obj0 = 0 ;
19143 char *kwnames[] = {
19144 (char *) "cal", NULL
19145 };
19146
19147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19148 if (obj0) {
19149 {
19150 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19151 if (SWIG_arg_fail(1)) SWIG_fail;
19152 }
19153 }
19154 {
19155 PyThreadState* __tstate = wxPyBeginAllowThreads();
19156 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19157
19158 wxPyEndAllowThreads(__tstate);
19159 if (PyErr_Occurred()) SWIG_fail;
19160 }
19161 resultobj = SWIG_From_int((result));
19162 return resultobj;
19163 fail:
19164 return NULL;
19165 }
19166
19167
19168 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19169 PyObject *resultobj;
19170 int arg1 = (int) wxDateTime::Inv_Year ;
19171 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19172 bool result;
19173 PyObject * obj0 = 0 ;
19174 PyObject * obj1 = 0 ;
19175 char *kwnames[] = {
19176 (char *) "year",(char *) "cal", NULL
19177 };
19178
19179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19180 if (obj0) {
19181 {
19182 arg1 = (int)(SWIG_As_int(obj0));
19183 if (SWIG_arg_fail(1)) SWIG_fail;
19184 }
19185 }
19186 if (obj1) {
19187 {
19188 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19189 if (SWIG_arg_fail(2)) SWIG_fail;
19190 }
19191 }
19192 {
19193 PyThreadState* __tstate = wxPyBeginAllowThreads();
19194 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19195
19196 wxPyEndAllowThreads(__tstate);
19197 if (PyErr_Occurred()) SWIG_fail;
19198 }
19199 {
19200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19201 }
19202 return resultobj;
19203 fail:
19204 return NULL;
19205 }
19206
19207
19208 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19209 PyObject *resultobj;
19210 int arg1 = (int) wxDateTime::Inv_Year ;
19211 int result;
19212 PyObject * obj0 = 0 ;
19213 char *kwnames[] = {
19214 (char *) "year", NULL
19215 };
19216
19217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19218 if (obj0) {
19219 {
19220 arg1 = (int)(SWIG_As_int(obj0));
19221 if (SWIG_arg_fail(1)) SWIG_fail;
19222 }
19223 }
19224 {
19225 PyThreadState* __tstate = wxPyBeginAllowThreads();
19226 result = (int)wxDateTime::GetCentury(arg1);
19227
19228 wxPyEndAllowThreads(__tstate);
19229 if (PyErr_Occurred()) SWIG_fail;
19230 }
19231 {
19232 resultobj = SWIG_From_int((int)(result));
19233 }
19234 return resultobj;
19235 fail:
19236 return NULL;
19237 }
19238
19239
19240 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19241 PyObject *resultobj;
19242 int arg1 ;
19243 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19244 int result;
19245 PyObject * obj0 = 0 ;
19246 PyObject * obj1 = 0 ;
19247 char *kwnames[] = {
19248 (char *) "year",(char *) "cal", NULL
19249 };
19250
19251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19252 {
19253 arg1 = (int)(SWIG_As_int(obj0));
19254 if (SWIG_arg_fail(1)) SWIG_fail;
19255 }
19256 if (obj1) {
19257 {
19258 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19259 if (SWIG_arg_fail(2)) SWIG_fail;
19260 }
19261 }
19262 {
19263 PyThreadState* __tstate = wxPyBeginAllowThreads();
19264 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19265
19266 wxPyEndAllowThreads(__tstate);
19267 if (PyErr_Occurred()) SWIG_fail;
19268 }
19269 {
19270 resultobj = SWIG_From_int((int)(result));
19271 }
19272 return resultobj;
19273 fail:
19274 return NULL;
19275 }
19276
19277
19278 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19279 PyObject *resultobj;
19280 wxDateTime::Month arg1 ;
19281 int arg2 = (int) wxDateTime::Inv_Year ;
19282 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19283 int result;
19284 PyObject * obj0 = 0 ;
19285 PyObject * obj1 = 0 ;
19286 PyObject * obj2 = 0 ;
19287 char *kwnames[] = {
19288 (char *) "month",(char *) "year",(char *) "cal", NULL
19289 };
19290
19291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19292 {
19293 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19294 if (SWIG_arg_fail(1)) SWIG_fail;
19295 }
19296 if (obj1) {
19297 {
19298 arg2 = (int)(SWIG_As_int(obj1));
19299 if (SWIG_arg_fail(2)) SWIG_fail;
19300 }
19301 }
19302 if (obj2) {
19303 {
19304 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19305 if (SWIG_arg_fail(3)) SWIG_fail;
19306 }
19307 }
19308 {
19309 PyThreadState* __tstate = wxPyBeginAllowThreads();
19310 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19311
19312 wxPyEndAllowThreads(__tstate);
19313 if (PyErr_Occurred()) SWIG_fail;
19314 }
19315 {
19316 resultobj = SWIG_From_int((int)(result));
19317 }
19318 return resultobj;
19319 fail:
19320 return NULL;
19321 }
19322
19323
19324 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19325 PyObject *resultobj;
19326 wxDateTime::Month arg1 ;
19327 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19328 wxString result;
19329 PyObject * obj0 = 0 ;
19330 PyObject * obj1 = 0 ;
19331 char *kwnames[] = {
19332 (char *) "month",(char *) "flags", NULL
19333 };
19334
19335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19336 {
19337 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19338 if (SWIG_arg_fail(1)) SWIG_fail;
19339 }
19340 if (obj1) {
19341 {
19342 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19343 if (SWIG_arg_fail(2)) SWIG_fail;
19344 }
19345 }
19346 {
19347 PyThreadState* __tstate = wxPyBeginAllowThreads();
19348 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19349
19350 wxPyEndAllowThreads(__tstate);
19351 if (PyErr_Occurred()) SWIG_fail;
19352 }
19353 {
19354 #if wxUSE_UNICODE
19355 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19356 #else
19357 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19358 #endif
19359 }
19360 return resultobj;
19361 fail:
19362 return NULL;
19363 }
19364
19365
19366 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19367 PyObject *resultobj;
19368 wxDateTime::WeekDay arg1 ;
19369 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19370 wxString result;
19371 PyObject * obj0 = 0 ;
19372 PyObject * obj1 = 0 ;
19373 char *kwnames[] = {
19374 (char *) "weekday",(char *) "flags", NULL
19375 };
19376
19377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19378 {
19379 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19380 if (SWIG_arg_fail(1)) SWIG_fail;
19381 }
19382 if (obj1) {
19383 {
19384 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19385 if (SWIG_arg_fail(2)) SWIG_fail;
19386 }
19387 }
19388 {
19389 PyThreadState* __tstate = wxPyBeginAllowThreads();
19390 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19391
19392 wxPyEndAllowThreads(__tstate);
19393 if (PyErr_Occurred()) SWIG_fail;
19394 }
19395 {
19396 #if wxUSE_UNICODE
19397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19398 #else
19399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19400 #endif
19401 }
19402 return resultobj;
19403 fail:
19404 return NULL;
19405 }
19406
19407
19408 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19409 PyObject *resultobj;
19410 PyObject *result;
19411 char *kwnames[] = {
19412 NULL
19413 };
19414
19415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19416 {
19417 PyThreadState* __tstate = wxPyBeginAllowThreads();
19418 result = (PyObject *)DateTime_GetAmPmStrings();
19419
19420 wxPyEndAllowThreads(__tstate);
19421 if (PyErr_Occurred()) SWIG_fail;
19422 }
19423 resultobj = result;
19424 return resultobj;
19425 fail:
19426 return NULL;
19427 }
19428
19429
19430 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19431 PyObject *resultobj;
19432 int arg1 = (int) wxDateTime::Inv_Year ;
19433 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19434 bool result;
19435 PyObject * obj0 = 0 ;
19436 PyObject * obj1 = 0 ;
19437 char *kwnames[] = {
19438 (char *) "year",(char *) "country", NULL
19439 };
19440
19441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19442 if (obj0) {
19443 {
19444 arg1 = (int)(SWIG_As_int(obj0));
19445 if (SWIG_arg_fail(1)) SWIG_fail;
19446 }
19447 }
19448 if (obj1) {
19449 {
19450 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19451 if (SWIG_arg_fail(2)) SWIG_fail;
19452 }
19453 }
19454 {
19455 PyThreadState* __tstate = wxPyBeginAllowThreads();
19456 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19457
19458 wxPyEndAllowThreads(__tstate);
19459 if (PyErr_Occurred()) SWIG_fail;
19460 }
19461 {
19462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19463 }
19464 return resultobj;
19465 fail:
19466 return NULL;
19467 }
19468
19469
19470 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19471 PyObject *resultobj;
19472 int arg1 = (int) wxDateTime::Inv_Year ;
19473 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19474 wxDateTime result;
19475 PyObject * obj0 = 0 ;
19476 PyObject * obj1 = 0 ;
19477 char *kwnames[] = {
19478 (char *) "year",(char *) "country", NULL
19479 };
19480
19481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19482 if (obj0) {
19483 {
19484 arg1 = (int)(SWIG_As_int(obj0));
19485 if (SWIG_arg_fail(1)) SWIG_fail;
19486 }
19487 }
19488 if (obj1) {
19489 {
19490 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19491 if (SWIG_arg_fail(2)) SWIG_fail;
19492 }
19493 }
19494 {
19495 PyThreadState* __tstate = wxPyBeginAllowThreads();
19496 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19497
19498 wxPyEndAllowThreads(__tstate);
19499 if (PyErr_Occurred()) SWIG_fail;
19500 }
19501 {
19502 wxDateTime * resultptr;
19503 resultptr = new wxDateTime((wxDateTime &)(result));
19504 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19505 }
19506 return resultobj;
19507 fail:
19508 return NULL;
19509 }
19510
19511
19512 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19513 PyObject *resultobj;
19514 int arg1 = (int) wxDateTime::Inv_Year ;
19515 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19516 wxDateTime result;
19517 PyObject * obj0 = 0 ;
19518 PyObject * obj1 = 0 ;
19519 char *kwnames[] = {
19520 (char *) "year",(char *) "country", NULL
19521 };
19522
19523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19524 if (obj0) {
19525 {
19526 arg1 = (int)(SWIG_As_int(obj0));
19527 if (SWIG_arg_fail(1)) SWIG_fail;
19528 }
19529 }
19530 if (obj1) {
19531 {
19532 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19533 if (SWIG_arg_fail(2)) SWIG_fail;
19534 }
19535 }
19536 {
19537 PyThreadState* __tstate = wxPyBeginAllowThreads();
19538 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19539
19540 wxPyEndAllowThreads(__tstate);
19541 if (PyErr_Occurred()) SWIG_fail;
19542 }
19543 {
19544 wxDateTime * resultptr;
19545 resultptr = new wxDateTime((wxDateTime &)(result));
19546 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19547 }
19548 return resultobj;
19549 fail:
19550 return NULL;
19551 }
19552
19553
19554 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19555 PyObject *resultobj;
19556 wxDateTime result;
19557 char *kwnames[] = {
19558 NULL
19559 };
19560
19561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19562 {
19563 PyThreadState* __tstate = wxPyBeginAllowThreads();
19564 result = wxDateTime::Now();
19565
19566 wxPyEndAllowThreads(__tstate);
19567 if (PyErr_Occurred()) SWIG_fail;
19568 }
19569 {
19570 wxDateTime * resultptr;
19571 resultptr = new wxDateTime((wxDateTime &)(result));
19572 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19573 }
19574 return resultobj;
19575 fail:
19576 return NULL;
19577 }
19578
19579
19580 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19581 PyObject *resultobj;
19582 wxDateTime result;
19583 char *kwnames[] = {
19584 NULL
19585 };
19586
19587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19588 {
19589 PyThreadState* __tstate = wxPyBeginAllowThreads();
19590 result = wxDateTime::UNow();
19591
19592 wxPyEndAllowThreads(__tstate);
19593 if (PyErr_Occurred()) SWIG_fail;
19594 }
19595 {
19596 wxDateTime * resultptr;
19597 resultptr = new wxDateTime((wxDateTime &)(result));
19598 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19599 }
19600 return resultobj;
19601 fail:
19602 return NULL;
19603 }
19604
19605
19606 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19607 PyObject *resultobj;
19608 wxDateTime result;
19609 char *kwnames[] = {
19610 NULL
19611 };
19612
19613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19614 {
19615 PyThreadState* __tstate = wxPyBeginAllowThreads();
19616 result = wxDateTime::Today();
19617
19618 wxPyEndAllowThreads(__tstate);
19619 if (PyErr_Occurred()) SWIG_fail;
19620 }
19621 {
19622 wxDateTime * resultptr;
19623 resultptr = new wxDateTime((wxDateTime &)(result));
19624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19625 }
19626 return resultobj;
19627 fail:
19628 return NULL;
19629 }
19630
19631
19632 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19633 PyObject *resultobj;
19634 wxDateTime *result;
19635 char *kwnames[] = {
19636 NULL
19637 };
19638
19639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19640 {
19641 PyThreadState* __tstate = wxPyBeginAllowThreads();
19642 result = (wxDateTime *)new wxDateTime();
19643
19644 wxPyEndAllowThreads(__tstate);
19645 if (PyErr_Occurred()) SWIG_fail;
19646 }
19647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19648 return resultobj;
19649 fail:
19650 return NULL;
19651 }
19652
19653
19654 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19655 PyObject *resultobj;
19656 time_t arg1 ;
19657 wxDateTime *result;
19658 PyObject * obj0 = 0 ;
19659 char *kwnames[] = {
19660 (char *) "timet", NULL
19661 };
19662
19663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19664 {
19665 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19666 if (SWIG_arg_fail(1)) SWIG_fail;
19667 }
19668 {
19669 PyThreadState* __tstate = wxPyBeginAllowThreads();
19670 result = (wxDateTime *)new wxDateTime(arg1);
19671
19672 wxPyEndAllowThreads(__tstate);
19673 if (PyErr_Occurred()) SWIG_fail;
19674 }
19675 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19676 return resultobj;
19677 fail:
19678 return NULL;
19679 }
19680
19681
19682 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19683 PyObject *resultobj;
19684 double arg1 ;
19685 wxDateTime *result;
19686 PyObject * obj0 = 0 ;
19687 char *kwnames[] = {
19688 (char *) "jdn", NULL
19689 };
19690
19691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19692 {
19693 arg1 = (double)(SWIG_As_double(obj0));
19694 if (SWIG_arg_fail(1)) SWIG_fail;
19695 }
19696 {
19697 PyThreadState* __tstate = wxPyBeginAllowThreads();
19698 result = (wxDateTime *)new wxDateTime(arg1);
19699
19700 wxPyEndAllowThreads(__tstate);
19701 if (PyErr_Occurred()) SWIG_fail;
19702 }
19703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19704 return resultobj;
19705 fail:
19706 return NULL;
19707 }
19708
19709
19710 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19711 PyObject *resultobj;
19712 int arg1 ;
19713 int arg2 = (int) 0 ;
19714 int arg3 = (int) 0 ;
19715 int arg4 = (int) 0 ;
19716 wxDateTime *result;
19717 PyObject * obj0 = 0 ;
19718 PyObject * obj1 = 0 ;
19719 PyObject * obj2 = 0 ;
19720 PyObject * obj3 = 0 ;
19721 char *kwnames[] = {
19722 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19723 };
19724
19725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19726 {
19727 arg1 = (int)(SWIG_As_int(obj0));
19728 if (SWIG_arg_fail(1)) SWIG_fail;
19729 }
19730 if (obj1) {
19731 {
19732 arg2 = (int)(SWIG_As_int(obj1));
19733 if (SWIG_arg_fail(2)) SWIG_fail;
19734 }
19735 }
19736 if (obj2) {
19737 {
19738 arg3 = (int)(SWIG_As_int(obj2));
19739 if (SWIG_arg_fail(3)) SWIG_fail;
19740 }
19741 }
19742 if (obj3) {
19743 {
19744 arg4 = (int)(SWIG_As_int(obj3));
19745 if (SWIG_arg_fail(4)) SWIG_fail;
19746 }
19747 }
19748 {
19749 PyThreadState* __tstate = wxPyBeginAllowThreads();
19750 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19751
19752 wxPyEndAllowThreads(__tstate);
19753 if (PyErr_Occurred()) SWIG_fail;
19754 }
19755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19756 return resultobj;
19757 fail:
19758 return NULL;
19759 }
19760
19761
19762 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19763 PyObject *resultobj;
19764 int arg1 ;
19765 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19766 int arg3 = (int) wxDateTime::Inv_Year ;
19767 int arg4 = (int) 0 ;
19768 int arg5 = (int) 0 ;
19769 int arg6 = (int) 0 ;
19770 int arg7 = (int) 0 ;
19771 wxDateTime *result;
19772 PyObject * obj0 = 0 ;
19773 PyObject * obj1 = 0 ;
19774 PyObject * obj2 = 0 ;
19775 PyObject * obj3 = 0 ;
19776 PyObject * obj4 = 0 ;
19777 PyObject * obj5 = 0 ;
19778 PyObject * obj6 = 0 ;
19779 char *kwnames[] = {
19780 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19781 };
19782
19783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19784 {
19785 arg1 = (int)(SWIG_As_int(obj0));
19786 if (SWIG_arg_fail(1)) SWIG_fail;
19787 }
19788 if (obj1) {
19789 {
19790 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19791 if (SWIG_arg_fail(2)) SWIG_fail;
19792 }
19793 }
19794 if (obj2) {
19795 {
19796 arg3 = (int)(SWIG_As_int(obj2));
19797 if (SWIG_arg_fail(3)) SWIG_fail;
19798 }
19799 }
19800 if (obj3) {
19801 {
19802 arg4 = (int)(SWIG_As_int(obj3));
19803 if (SWIG_arg_fail(4)) SWIG_fail;
19804 }
19805 }
19806 if (obj4) {
19807 {
19808 arg5 = (int)(SWIG_As_int(obj4));
19809 if (SWIG_arg_fail(5)) SWIG_fail;
19810 }
19811 }
19812 if (obj5) {
19813 {
19814 arg6 = (int)(SWIG_As_int(obj5));
19815 if (SWIG_arg_fail(6)) SWIG_fail;
19816 }
19817 }
19818 if (obj6) {
19819 {
19820 arg7 = (int)(SWIG_As_int(obj6));
19821 if (SWIG_arg_fail(7)) SWIG_fail;
19822 }
19823 }
19824 {
19825 PyThreadState* __tstate = wxPyBeginAllowThreads();
19826 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19827
19828 wxPyEndAllowThreads(__tstate);
19829 if (PyErr_Occurred()) SWIG_fail;
19830 }
19831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19832 return resultobj;
19833 fail:
19834 return NULL;
19835 }
19836
19837
19838 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19839 PyObject *resultobj;
19840 wxDateTime *arg1 = (wxDateTime *) 0 ;
19841 PyObject * obj0 = 0 ;
19842 char *kwnames[] = {
19843 (char *) "self", NULL
19844 };
19845
19846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19848 if (SWIG_arg_fail(1)) SWIG_fail;
19849 {
19850 PyThreadState* __tstate = wxPyBeginAllowThreads();
19851 delete arg1;
19852
19853 wxPyEndAllowThreads(__tstate);
19854 if (PyErr_Occurred()) SWIG_fail;
19855 }
19856 Py_INCREF(Py_None); resultobj = Py_None;
19857 return resultobj;
19858 fail:
19859 return NULL;
19860 }
19861
19862
19863 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19864 PyObject *resultobj;
19865 wxDateTime *arg1 = (wxDateTime *) 0 ;
19866 wxDateTime *result;
19867 PyObject * obj0 = 0 ;
19868 char *kwnames[] = {
19869 (char *) "self", NULL
19870 };
19871
19872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19874 if (SWIG_arg_fail(1)) SWIG_fail;
19875 {
19876 PyThreadState* __tstate = wxPyBeginAllowThreads();
19877 {
19878 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19879 result = (wxDateTime *) &_result_ref;
19880 }
19881
19882 wxPyEndAllowThreads(__tstate);
19883 if (PyErr_Occurred()) SWIG_fail;
19884 }
19885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19886 return resultobj;
19887 fail:
19888 return NULL;
19889 }
19890
19891
19892 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19893 PyObject *resultobj;
19894 wxDateTime *arg1 = (wxDateTime *) 0 ;
19895 time_t arg2 ;
19896 wxDateTime *result;
19897 PyObject * obj0 = 0 ;
19898 PyObject * obj1 = 0 ;
19899 char *kwnames[] = {
19900 (char *) "self",(char *) "timet", NULL
19901 };
19902
19903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19905 if (SWIG_arg_fail(1)) SWIG_fail;
19906 {
19907 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19908 if (SWIG_arg_fail(2)) SWIG_fail;
19909 }
19910 {
19911 PyThreadState* __tstate = wxPyBeginAllowThreads();
19912 {
19913 wxDateTime &_result_ref = (arg1)->Set(arg2);
19914 result = (wxDateTime *) &_result_ref;
19915 }
19916
19917 wxPyEndAllowThreads(__tstate);
19918 if (PyErr_Occurred()) SWIG_fail;
19919 }
19920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19921 return resultobj;
19922 fail:
19923 return NULL;
19924 }
19925
19926
19927 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19928 PyObject *resultobj;
19929 wxDateTime *arg1 = (wxDateTime *) 0 ;
19930 double arg2 ;
19931 wxDateTime *result;
19932 PyObject * obj0 = 0 ;
19933 PyObject * obj1 = 0 ;
19934 char *kwnames[] = {
19935 (char *) "self",(char *) "jdn", NULL
19936 };
19937
19938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19940 if (SWIG_arg_fail(1)) SWIG_fail;
19941 {
19942 arg2 = (double)(SWIG_As_double(obj1));
19943 if (SWIG_arg_fail(2)) SWIG_fail;
19944 }
19945 {
19946 PyThreadState* __tstate = wxPyBeginAllowThreads();
19947 {
19948 wxDateTime &_result_ref = (arg1)->Set(arg2);
19949 result = (wxDateTime *) &_result_ref;
19950 }
19951
19952 wxPyEndAllowThreads(__tstate);
19953 if (PyErr_Occurred()) SWIG_fail;
19954 }
19955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19956 return resultobj;
19957 fail:
19958 return NULL;
19959 }
19960
19961
19962 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19963 PyObject *resultobj;
19964 wxDateTime *arg1 = (wxDateTime *) 0 ;
19965 int arg2 ;
19966 int arg3 = (int) 0 ;
19967 int arg4 = (int) 0 ;
19968 int arg5 = (int) 0 ;
19969 wxDateTime *result;
19970 PyObject * obj0 = 0 ;
19971 PyObject * obj1 = 0 ;
19972 PyObject * obj2 = 0 ;
19973 PyObject * obj3 = 0 ;
19974 PyObject * obj4 = 0 ;
19975 char *kwnames[] = {
19976 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19977 };
19978
19979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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 = (int)(SWIG_As_int(obj1));
19984 if (SWIG_arg_fail(2)) SWIG_fail;
19985 }
19986 if (obj2) {
19987 {
19988 arg3 = (int)(SWIG_As_int(obj2));
19989 if (SWIG_arg_fail(3)) SWIG_fail;
19990 }
19991 }
19992 if (obj3) {
19993 {
19994 arg4 = (int)(SWIG_As_int(obj3));
19995 if (SWIG_arg_fail(4)) SWIG_fail;
19996 }
19997 }
19998 if (obj4) {
19999 {
20000 arg5 = (int)(SWIG_As_int(obj4));
20001 if (SWIG_arg_fail(5)) SWIG_fail;
20002 }
20003 }
20004 {
20005 PyThreadState* __tstate = wxPyBeginAllowThreads();
20006 {
20007 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20008 result = (wxDateTime *) &_result_ref;
20009 }
20010
20011 wxPyEndAllowThreads(__tstate);
20012 if (PyErr_Occurred()) SWIG_fail;
20013 }
20014 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20015 return resultobj;
20016 fail:
20017 return NULL;
20018 }
20019
20020
20021 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20022 PyObject *resultobj;
20023 wxDateTime *arg1 = (wxDateTime *) 0 ;
20024 int arg2 ;
20025 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20026 int arg4 = (int) wxDateTime::Inv_Year ;
20027 int arg5 = (int) 0 ;
20028 int arg6 = (int) 0 ;
20029 int arg7 = (int) 0 ;
20030 int arg8 = (int) 0 ;
20031 wxDateTime *result;
20032 PyObject * obj0 = 0 ;
20033 PyObject * obj1 = 0 ;
20034 PyObject * obj2 = 0 ;
20035 PyObject * obj3 = 0 ;
20036 PyObject * obj4 = 0 ;
20037 PyObject * obj5 = 0 ;
20038 PyObject * obj6 = 0 ;
20039 PyObject * obj7 = 0 ;
20040 char *kwnames[] = {
20041 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20042 };
20043
20044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20046 if (SWIG_arg_fail(1)) SWIG_fail;
20047 {
20048 arg2 = (int)(SWIG_As_int(obj1));
20049 if (SWIG_arg_fail(2)) SWIG_fail;
20050 }
20051 if (obj2) {
20052 {
20053 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20054 if (SWIG_arg_fail(3)) SWIG_fail;
20055 }
20056 }
20057 if (obj3) {
20058 {
20059 arg4 = (int)(SWIG_As_int(obj3));
20060 if (SWIG_arg_fail(4)) SWIG_fail;
20061 }
20062 }
20063 if (obj4) {
20064 {
20065 arg5 = (int)(SWIG_As_int(obj4));
20066 if (SWIG_arg_fail(5)) SWIG_fail;
20067 }
20068 }
20069 if (obj5) {
20070 {
20071 arg6 = (int)(SWIG_As_int(obj5));
20072 if (SWIG_arg_fail(6)) SWIG_fail;
20073 }
20074 }
20075 if (obj6) {
20076 {
20077 arg7 = (int)(SWIG_As_int(obj6));
20078 if (SWIG_arg_fail(7)) SWIG_fail;
20079 }
20080 }
20081 if (obj7) {
20082 {
20083 arg8 = (int)(SWIG_As_int(obj7));
20084 if (SWIG_arg_fail(8)) SWIG_fail;
20085 }
20086 }
20087 {
20088 PyThreadState* __tstate = wxPyBeginAllowThreads();
20089 {
20090 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20091 result = (wxDateTime *) &_result_ref;
20092 }
20093
20094 wxPyEndAllowThreads(__tstate);
20095 if (PyErr_Occurred()) SWIG_fail;
20096 }
20097 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20098 return resultobj;
20099 fail:
20100 return NULL;
20101 }
20102
20103
20104 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20105 PyObject *resultobj;
20106 wxDateTime *arg1 = (wxDateTime *) 0 ;
20107 wxDateTime *result;
20108 PyObject * obj0 = 0 ;
20109 char *kwnames[] = {
20110 (char *) "self", NULL
20111 };
20112
20113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20115 if (SWIG_arg_fail(1)) SWIG_fail;
20116 {
20117 PyThreadState* __tstate = wxPyBeginAllowThreads();
20118 {
20119 wxDateTime &_result_ref = (arg1)->ResetTime();
20120 result = (wxDateTime *) &_result_ref;
20121 }
20122
20123 wxPyEndAllowThreads(__tstate);
20124 if (PyErr_Occurred()) SWIG_fail;
20125 }
20126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20127 return resultobj;
20128 fail:
20129 return NULL;
20130 }
20131
20132
20133 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20134 PyObject *resultobj;
20135 wxDateTime *arg1 = (wxDateTime *) 0 ;
20136 int arg2 ;
20137 wxDateTime *result;
20138 PyObject * obj0 = 0 ;
20139 PyObject * obj1 = 0 ;
20140 char *kwnames[] = {
20141 (char *) "self",(char *) "year", NULL
20142 };
20143
20144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20146 if (SWIG_arg_fail(1)) SWIG_fail;
20147 {
20148 arg2 = (int)(SWIG_As_int(obj1));
20149 if (SWIG_arg_fail(2)) SWIG_fail;
20150 }
20151 {
20152 PyThreadState* __tstate = wxPyBeginAllowThreads();
20153 {
20154 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20155 result = (wxDateTime *) &_result_ref;
20156 }
20157
20158 wxPyEndAllowThreads(__tstate);
20159 if (PyErr_Occurred()) SWIG_fail;
20160 }
20161 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20162 return resultobj;
20163 fail:
20164 return NULL;
20165 }
20166
20167
20168 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20169 PyObject *resultobj;
20170 wxDateTime *arg1 = (wxDateTime *) 0 ;
20171 wxDateTime::Month arg2 ;
20172 wxDateTime *result;
20173 PyObject * obj0 = 0 ;
20174 PyObject * obj1 = 0 ;
20175 char *kwnames[] = {
20176 (char *) "self",(char *) "month", NULL
20177 };
20178
20179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20181 if (SWIG_arg_fail(1)) SWIG_fail;
20182 {
20183 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20184 if (SWIG_arg_fail(2)) SWIG_fail;
20185 }
20186 {
20187 PyThreadState* __tstate = wxPyBeginAllowThreads();
20188 {
20189 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20190 result = (wxDateTime *) &_result_ref;
20191 }
20192
20193 wxPyEndAllowThreads(__tstate);
20194 if (PyErr_Occurred()) SWIG_fail;
20195 }
20196 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20197 return resultobj;
20198 fail:
20199 return NULL;
20200 }
20201
20202
20203 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20204 PyObject *resultobj;
20205 wxDateTime *arg1 = (wxDateTime *) 0 ;
20206 int arg2 ;
20207 wxDateTime *result;
20208 PyObject * obj0 = 0 ;
20209 PyObject * obj1 = 0 ;
20210 char *kwnames[] = {
20211 (char *) "self",(char *) "day", NULL
20212 };
20213
20214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20216 if (SWIG_arg_fail(1)) SWIG_fail;
20217 {
20218 arg2 = (int)(SWIG_As_int(obj1));
20219 if (SWIG_arg_fail(2)) SWIG_fail;
20220 }
20221 {
20222 PyThreadState* __tstate = wxPyBeginAllowThreads();
20223 {
20224 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20225 result = (wxDateTime *) &_result_ref;
20226 }
20227
20228 wxPyEndAllowThreads(__tstate);
20229 if (PyErr_Occurred()) SWIG_fail;
20230 }
20231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20232 return resultobj;
20233 fail:
20234 return NULL;
20235 }
20236
20237
20238 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20239 PyObject *resultobj;
20240 wxDateTime *arg1 = (wxDateTime *) 0 ;
20241 int arg2 ;
20242 wxDateTime *result;
20243 PyObject * obj0 = 0 ;
20244 PyObject * obj1 = 0 ;
20245 char *kwnames[] = {
20246 (char *) "self",(char *) "hour", NULL
20247 };
20248
20249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20251 if (SWIG_arg_fail(1)) SWIG_fail;
20252 {
20253 arg2 = (int)(SWIG_As_int(obj1));
20254 if (SWIG_arg_fail(2)) SWIG_fail;
20255 }
20256 {
20257 PyThreadState* __tstate = wxPyBeginAllowThreads();
20258 {
20259 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20260 result = (wxDateTime *) &_result_ref;
20261 }
20262
20263 wxPyEndAllowThreads(__tstate);
20264 if (PyErr_Occurred()) SWIG_fail;
20265 }
20266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20267 return resultobj;
20268 fail:
20269 return NULL;
20270 }
20271
20272
20273 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20274 PyObject *resultobj;
20275 wxDateTime *arg1 = (wxDateTime *) 0 ;
20276 int arg2 ;
20277 wxDateTime *result;
20278 PyObject * obj0 = 0 ;
20279 PyObject * obj1 = 0 ;
20280 char *kwnames[] = {
20281 (char *) "self",(char *) "minute", NULL
20282 };
20283
20284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20286 if (SWIG_arg_fail(1)) SWIG_fail;
20287 {
20288 arg2 = (int)(SWIG_As_int(obj1));
20289 if (SWIG_arg_fail(2)) SWIG_fail;
20290 }
20291 {
20292 PyThreadState* __tstate = wxPyBeginAllowThreads();
20293 {
20294 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20295 result = (wxDateTime *) &_result_ref;
20296 }
20297
20298 wxPyEndAllowThreads(__tstate);
20299 if (PyErr_Occurred()) SWIG_fail;
20300 }
20301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20302 return resultobj;
20303 fail:
20304 return NULL;
20305 }
20306
20307
20308 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20309 PyObject *resultobj;
20310 wxDateTime *arg1 = (wxDateTime *) 0 ;
20311 int arg2 ;
20312 wxDateTime *result;
20313 PyObject * obj0 = 0 ;
20314 PyObject * obj1 = 0 ;
20315 char *kwnames[] = {
20316 (char *) "self",(char *) "second", NULL
20317 };
20318
20319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20321 if (SWIG_arg_fail(1)) SWIG_fail;
20322 {
20323 arg2 = (int)(SWIG_As_int(obj1));
20324 if (SWIG_arg_fail(2)) SWIG_fail;
20325 }
20326 {
20327 PyThreadState* __tstate = wxPyBeginAllowThreads();
20328 {
20329 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20330 result = (wxDateTime *) &_result_ref;
20331 }
20332
20333 wxPyEndAllowThreads(__tstate);
20334 if (PyErr_Occurred()) SWIG_fail;
20335 }
20336 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20337 return resultobj;
20338 fail:
20339 return NULL;
20340 }
20341
20342
20343 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20344 PyObject *resultobj;
20345 wxDateTime *arg1 = (wxDateTime *) 0 ;
20346 int arg2 ;
20347 wxDateTime *result;
20348 PyObject * obj0 = 0 ;
20349 PyObject * obj1 = 0 ;
20350 char *kwnames[] = {
20351 (char *) "self",(char *) "millisecond", NULL
20352 };
20353
20354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20356 if (SWIG_arg_fail(1)) SWIG_fail;
20357 {
20358 arg2 = (int)(SWIG_As_int(obj1));
20359 if (SWIG_arg_fail(2)) SWIG_fail;
20360 }
20361 {
20362 PyThreadState* __tstate = wxPyBeginAllowThreads();
20363 {
20364 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20365 result = (wxDateTime *) &_result_ref;
20366 }
20367
20368 wxPyEndAllowThreads(__tstate);
20369 if (PyErr_Occurred()) SWIG_fail;
20370 }
20371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20372 return resultobj;
20373 fail:
20374 return NULL;
20375 }
20376
20377
20378 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20379 PyObject *resultobj;
20380 wxDateTime *arg1 = (wxDateTime *) 0 ;
20381 wxDateTime::WeekDay arg2 ;
20382 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20383 wxDateTime *result;
20384 PyObject * obj0 = 0 ;
20385 PyObject * obj1 = 0 ;
20386 PyObject * obj2 = 0 ;
20387 char *kwnames[] = {
20388 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20389 };
20390
20391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20393 if (SWIG_arg_fail(1)) SWIG_fail;
20394 {
20395 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20396 if (SWIG_arg_fail(2)) SWIG_fail;
20397 }
20398 if (obj2) {
20399 {
20400 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20401 if (SWIG_arg_fail(3)) SWIG_fail;
20402 }
20403 }
20404 {
20405 PyThreadState* __tstate = wxPyBeginAllowThreads();
20406 {
20407 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20408 result = (wxDateTime *) &_result_ref;
20409 }
20410
20411 wxPyEndAllowThreads(__tstate);
20412 if (PyErr_Occurred()) SWIG_fail;
20413 }
20414 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20415 return resultobj;
20416 fail:
20417 return NULL;
20418 }
20419
20420
20421 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20422 PyObject *resultobj;
20423 wxDateTime *arg1 = (wxDateTime *) 0 ;
20424 wxDateTime::WeekDay arg2 ;
20425 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20426 wxDateTime result;
20427 PyObject * obj0 = 0 ;
20428 PyObject * obj1 = 0 ;
20429 PyObject * obj2 = 0 ;
20430 char *kwnames[] = {
20431 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20432 };
20433
20434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20436 if (SWIG_arg_fail(1)) SWIG_fail;
20437 {
20438 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20439 if (SWIG_arg_fail(2)) SWIG_fail;
20440 }
20441 if (obj2) {
20442 {
20443 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20444 if (SWIG_arg_fail(3)) SWIG_fail;
20445 }
20446 }
20447 {
20448 PyThreadState* __tstate = wxPyBeginAllowThreads();
20449 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20450
20451 wxPyEndAllowThreads(__tstate);
20452 if (PyErr_Occurred()) SWIG_fail;
20453 }
20454 {
20455 wxDateTime * resultptr;
20456 resultptr = new wxDateTime((wxDateTime &)(result));
20457 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20458 }
20459 return resultobj;
20460 fail:
20461 return NULL;
20462 }
20463
20464
20465 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20466 PyObject *resultobj;
20467 wxDateTime *arg1 = (wxDateTime *) 0 ;
20468 wxDateTime::WeekDay arg2 ;
20469 wxDateTime *result;
20470 PyObject * obj0 = 0 ;
20471 PyObject * obj1 = 0 ;
20472 char *kwnames[] = {
20473 (char *) "self",(char *) "weekday", NULL
20474 };
20475
20476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20478 if (SWIG_arg_fail(1)) SWIG_fail;
20479 {
20480 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20481 if (SWIG_arg_fail(2)) SWIG_fail;
20482 }
20483 {
20484 PyThreadState* __tstate = wxPyBeginAllowThreads();
20485 {
20486 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20487 result = (wxDateTime *) &_result_ref;
20488 }
20489
20490 wxPyEndAllowThreads(__tstate);
20491 if (PyErr_Occurred()) SWIG_fail;
20492 }
20493 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20494 return resultobj;
20495 fail:
20496 return NULL;
20497 }
20498
20499
20500 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20501 PyObject *resultobj;
20502 wxDateTime *arg1 = (wxDateTime *) 0 ;
20503 wxDateTime::WeekDay arg2 ;
20504 wxDateTime result;
20505 PyObject * obj0 = 0 ;
20506 PyObject * obj1 = 0 ;
20507 char *kwnames[] = {
20508 (char *) "self",(char *) "weekday", NULL
20509 };
20510
20511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20513 if (SWIG_arg_fail(1)) SWIG_fail;
20514 {
20515 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20516 if (SWIG_arg_fail(2)) SWIG_fail;
20517 }
20518 {
20519 PyThreadState* __tstate = wxPyBeginAllowThreads();
20520 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20521
20522 wxPyEndAllowThreads(__tstate);
20523 if (PyErr_Occurred()) SWIG_fail;
20524 }
20525 {
20526 wxDateTime * resultptr;
20527 resultptr = new wxDateTime((wxDateTime &)(result));
20528 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20529 }
20530 return resultobj;
20531 fail:
20532 return NULL;
20533 }
20534
20535
20536 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20537 PyObject *resultobj;
20538 wxDateTime *arg1 = (wxDateTime *) 0 ;
20539 wxDateTime::WeekDay arg2 ;
20540 wxDateTime *result;
20541 PyObject * obj0 = 0 ;
20542 PyObject * obj1 = 0 ;
20543 char *kwnames[] = {
20544 (char *) "self",(char *) "weekday", NULL
20545 };
20546
20547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20549 if (SWIG_arg_fail(1)) SWIG_fail;
20550 {
20551 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20552 if (SWIG_arg_fail(2)) SWIG_fail;
20553 }
20554 {
20555 PyThreadState* __tstate = wxPyBeginAllowThreads();
20556 {
20557 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20558 result = (wxDateTime *) &_result_ref;
20559 }
20560
20561 wxPyEndAllowThreads(__tstate);
20562 if (PyErr_Occurred()) SWIG_fail;
20563 }
20564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20565 return resultobj;
20566 fail:
20567 return NULL;
20568 }
20569
20570
20571 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20572 PyObject *resultobj;
20573 wxDateTime *arg1 = (wxDateTime *) 0 ;
20574 wxDateTime::WeekDay arg2 ;
20575 wxDateTime result;
20576 PyObject * obj0 = 0 ;
20577 PyObject * obj1 = 0 ;
20578 char *kwnames[] = {
20579 (char *) "self",(char *) "weekday", NULL
20580 };
20581
20582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20584 if (SWIG_arg_fail(1)) SWIG_fail;
20585 {
20586 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20587 if (SWIG_arg_fail(2)) SWIG_fail;
20588 }
20589 {
20590 PyThreadState* __tstate = wxPyBeginAllowThreads();
20591 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20592
20593 wxPyEndAllowThreads(__tstate);
20594 if (PyErr_Occurred()) SWIG_fail;
20595 }
20596 {
20597 wxDateTime * resultptr;
20598 resultptr = new wxDateTime((wxDateTime &)(result));
20599 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20600 }
20601 return resultobj;
20602 fail:
20603 return NULL;
20604 }
20605
20606
20607 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20608 PyObject *resultobj;
20609 wxDateTime *arg1 = (wxDateTime *) 0 ;
20610 wxDateTime::WeekDay arg2 ;
20611 int arg3 = (int) 1 ;
20612 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20613 int arg5 = (int) wxDateTime::Inv_Year ;
20614 bool result;
20615 PyObject * obj0 = 0 ;
20616 PyObject * obj1 = 0 ;
20617 PyObject * obj2 = 0 ;
20618 PyObject * obj3 = 0 ;
20619 PyObject * obj4 = 0 ;
20620 char *kwnames[] = {
20621 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20622 };
20623
20624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20626 if (SWIG_arg_fail(1)) SWIG_fail;
20627 {
20628 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20629 if (SWIG_arg_fail(2)) SWIG_fail;
20630 }
20631 if (obj2) {
20632 {
20633 arg3 = (int)(SWIG_As_int(obj2));
20634 if (SWIG_arg_fail(3)) SWIG_fail;
20635 }
20636 }
20637 if (obj3) {
20638 {
20639 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20640 if (SWIG_arg_fail(4)) SWIG_fail;
20641 }
20642 }
20643 if (obj4) {
20644 {
20645 arg5 = (int)(SWIG_As_int(obj4));
20646 if (SWIG_arg_fail(5)) SWIG_fail;
20647 }
20648 }
20649 {
20650 PyThreadState* __tstate = wxPyBeginAllowThreads();
20651 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20652
20653 wxPyEndAllowThreads(__tstate);
20654 if (PyErr_Occurred()) SWIG_fail;
20655 }
20656 {
20657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20658 }
20659 return resultobj;
20660 fail:
20661 return NULL;
20662 }
20663
20664
20665 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20666 PyObject *resultobj;
20667 wxDateTime *arg1 = (wxDateTime *) 0 ;
20668 wxDateTime::WeekDay arg2 ;
20669 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20670 int arg4 = (int) wxDateTime::Inv_Year ;
20671 bool result;
20672 PyObject * obj0 = 0 ;
20673 PyObject * obj1 = 0 ;
20674 PyObject * obj2 = 0 ;
20675 PyObject * obj3 = 0 ;
20676 char *kwnames[] = {
20677 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20678 };
20679
20680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20682 if (SWIG_arg_fail(1)) SWIG_fail;
20683 {
20684 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20685 if (SWIG_arg_fail(2)) SWIG_fail;
20686 }
20687 if (obj2) {
20688 {
20689 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20690 if (SWIG_arg_fail(3)) SWIG_fail;
20691 }
20692 }
20693 if (obj3) {
20694 {
20695 arg4 = (int)(SWIG_As_int(obj3));
20696 if (SWIG_arg_fail(4)) SWIG_fail;
20697 }
20698 }
20699 {
20700 PyThreadState* __tstate = wxPyBeginAllowThreads();
20701 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20702
20703 wxPyEndAllowThreads(__tstate);
20704 if (PyErr_Occurred()) SWIG_fail;
20705 }
20706 {
20707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20708 }
20709 return resultobj;
20710 fail:
20711 return NULL;
20712 }
20713
20714
20715 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20716 PyObject *resultobj;
20717 wxDateTime *arg1 = (wxDateTime *) 0 ;
20718 wxDateTime::WeekDay arg2 ;
20719 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20720 int arg4 = (int) wxDateTime::Inv_Year ;
20721 wxDateTime result;
20722 PyObject * obj0 = 0 ;
20723 PyObject * obj1 = 0 ;
20724 PyObject * obj2 = 0 ;
20725 PyObject * obj3 = 0 ;
20726 char *kwnames[] = {
20727 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20728 };
20729
20730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20732 if (SWIG_arg_fail(1)) SWIG_fail;
20733 {
20734 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20735 if (SWIG_arg_fail(2)) SWIG_fail;
20736 }
20737 if (obj2) {
20738 {
20739 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20740 if (SWIG_arg_fail(3)) SWIG_fail;
20741 }
20742 }
20743 if (obj3) {
20744 {
20745 arg4 = (int)(SWIG_As_int(obj3));
20746 if (SWIG_arg_fail(4)) SWIG_fail;
20747 }
20748 }
20749 {
20750 PyThreadState* __tstate = wxPyBeginAllowThreads();
20751 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20752
20753 wxPyEndAllowThreads(__tstate);
20754 if (PyErr_Occurred()) SWIG_fail;
20755 }
20756 {
20757 wxDateTime * resultptr;
20758 resultptr = new wxDateTime((wxDateTime &)(result));
20759 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20760 }
20761 return resultobj;
20762 fail:
20763 return NULL;
20764 }
20765
20766
20767 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20768 PyObject *resultobj;
20769 wxDateTime *arg1 = (wxDateTime *) 0 ;
20770 int arg2 ;
20771 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20772 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20773 bool result;
20774 PyObject * obj0 = 0 ;
20775 PyObject * obj1 = 0 ;
20776 PyObject * obj2 = 0 ;
20777 PyObject * obj3 = 0 ;
20778 char *kwnames[] = {
20779 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20780 };
20781
20782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20784 if (SWIG_arg_fail(1)) SWIG_fail;
20785 {
20786 arg2 = (int)(SWIG_As_int(obj1));
20787 if (SWIG_arg_fail(2)) SWIG_fail;
20788 }
20789 if (obj2) {
20790 {
20791 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20792 if (SWIG_arg_fail(3)) SWIG_fail;
20793 }
20794 }
20795 if (obj3) {
20796 {
20797 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20798 if (SWIG_arg_fail(4)) SWIG_fail;
20799 }
20800 }
20801 {
20802 PyThreadState* __tstate = wxPyBeginAllowThreads();
20803 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20804
20805 wxPyEndAllowThreads(__tstate);
20806 if (PyErr_Occurred()) SWIG_fail;
20807 }
20808 {
20809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20810 }
20811 return resultobj;
20812 fail:
20813 return NULL;
20814 }
20815
20816
20817 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20818 PyObject *resultobj;
20819 wxDateTime *arg1 = (wxDateTime *) 0 ;
20820 int arg2 ;
20821 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20822 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20823 wxDateTime result;
20824 PyObject * obj0 = 0 ;
20825 PyObject * obj1 = 0 ;
20826 PyObject * obj2 = 0 ;
20827 PyObject * obj3 = 0 ;
20828 char *kwnames[] = {
20829 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20830 };
20831
20832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20834 if (SWIG_arg_fail(1)) SWIG_fail;
20835 {
20836 arg2 = (int)(SWIG_As_int(obj1));
20837 if (SWIG_arg_fail(2)) SWIG_fail;
20838 }
20839 if (obj2) {
20840 {
20841 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20842 if (SWIG_arg_fail(3)) SWIG_fail;
20843 }
20844 }
20845 if (obj3) {
20846 {
20847 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20848 if (SWIG_arg_fail(4)) SWIG_fail;
20849 }
20850 }
20851 {
20852 PyThreadState* __tstate = wxPyBeginAllowThreads();
20853 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20854
20855 wxPyEndAllowThreads(__tstate);
20856 if (PyErr_Occurred()) SWIG_fail;
20857 }
20858 {
20859 wxDateTime * resultptr;
20860 resultptr = new wxDateTime((wxDateTime &)(result));
20861 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20862 }
20863 return resultobj;
20864 fail:
20865 return NULL;
20866 }
20867
20868
20869 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20870 PyObject *resultobj;
20871 int arg1 ;
20872 int arg2 ;
20873 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20874 wxDateTime result;
20875 PyObject * obj0 = 0 ;
20876 PyObject * obj1 = 0 ;
20877 PyObject * obj2 = 0 ;
20878 char *kwnames[] = {
20879 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20880 };
20881
20882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20883 {
20884 arg1 = (int)(SWIG_As_int(obj0));
20885 if (SWIG_arg_fail(1)) SWIG_fail;
20886 }
20887 {
20888 arg2 = (int)(SWIG_As_int(obj1));
20889 if (SWIG_arg_fail(2)) SWIG_fail;
20890 }
20891 if (obj2) {
20892 {
20893 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20894 if (SWIG_arg_fail(3)) SWIG_fail;
20895 }
20896 }
20897 {
20898 PyThreadState* __tstate = wxPyBeginAllowThreads();
20899 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20900
20901 wxPyEndAllowThreads(__tstate);
20902 if (PyErr_Occurred()) SWIG_fail;
20903 }
20904 {
20905 wxDateTime * resultptr;
20906 resultptr = new wxDateTime((wxDateTime &)(result));
20907 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20908 }
20909 return resultobj;
20910 fail:
20911 return NULL;
20912 }
20913
20914
20915 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20916 PyObject *resultobj;
20917 wxDateTime *arg1 = (wxDateTime *) 0 ;
20918 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20919 int arg3 = (int) wxDateTime::Inv_Year ;
20920 wxDateTime *result;
20921 PyObject * obj0 = 0 ;
20922 PyObject * obj1 = 0 ;
20923 PyObject * obj2 = 0 ;
20924 char *kwnames[] = {
20925 (char *) "self",(char *) "month",(char *) "year", NULL
20926 };
20927
20928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20930 if (SWIG_arg_fail(1)) SWIG_fail;
20931 if (obj1) {
20932 {
20933 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20934 if (SWIG_arg_fail(2)) SWIG_fail;
20935 }
20936 }
20937 if (obj2) {
20938 {
20939 arg3 = (int)(SWIG_As_int(obj2));
20940 if (SWIG_arg_fail(3)) SWIG_fail;
20941 }
20942 }
20943 {
20944 PyThreadState* __tstate = wxPyBeginAllowThreads();
20945 {
20946 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20947 result = (wxDateTime *) &_result_ref;
20948 }
20949
20950 wxPyEndAllowThreads(__tstate);
20951 if (PyErr_Occurred()) SWIG_fail;
20952 }
20953 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20954 return resultobj;
20955 fail:
20956 return NULL;
20957 }
20958
20959
20960 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20961 PyObject *resultobj;
20962 wxDateTime *arg1 = (wxDateTime *) 0 ;
20963 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20964 int arg3 = (int) wxDateTime::Inv_Year ;
20965 wxDateTime result;
20966 PyObject * obj0 = 0 ;
20967 PyObject * obj1 = 0 ;
20968 PyObject * obj2 = 0 ;
20969 char *kwnames[] = {
20970 (char *) "self",(char *) "month",(char *) "year", NULL
20971 };
20972
20973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20975 if (SWIG_arg_fail(1)) SWIG_fail;
20976 if (obj1) {
20977 {
20978 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20979 if (SWIG_arg_fail(2)) SWIG_fail;
20980 }
20981 }
20982 if (obj2) {
20983 {
20984 arg3 = (int)(SWIG_As_int(obj2));
20985 if (SWIG_arg_fail(3)) SWIG_fail;
20986 }
20987 }
20988 {
20989 PyThreadState* __tstate = wxPyBeginAllowThreads();
20990 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20991
20992 wxPyEndAllowThreads(__tstate);
20993 if (PyErr_Occurred()) SWIG_fail;
20994 }
20995 {
20996 wxDateTime * resultptr;
20997 resultptr = new wxDateTime((wxDateTime &)(result));
20998 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20999 }
21000 return resultobj;
21001 fail:
21002 return NULL;
21003 }
21004
21005
21006 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21007 PyObject *resultobj;
21008 wxDateTime *arg1 = (wxDateTime *) 0 ;
21009 int arg2 ;
21010 wxDateTime *result;
21011 PyObject * obj0 = 0 ;
21012 PyObject * obj1 = 0 ;
21013 char *kwnames[] = {
21014 (char *) "self",(char *) "yday", NULL
21015 };
21016
21017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21019 if (SWIG_arg_fail(1)) SWIG_fail;
21020 {
21021 arg2 = (int)(SWIG_As_int(obj1));
21022 if (SWIG_arg_fail(2)) SWIG_fail;
21023 }
21024 {
21025 PyThreadState* __tstate = wxPyBeginAllowThreads();
21026 {
21027 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21028 result = (wxDateTime *) &_result_ref;
21029 }
21030
21031 wxPyEndAllowThreads(__tstate);
21032 if (PyErr_Occurred()) SWIG_fail;
21033 }
21034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21035 return resultobj;
21036 fail:
21037 return NULL;
21038 }
21039
21040
21041 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21042 PyObject *resultobj;
21043 wxDateTime *arg1 = (wxDateTime *) 0 ;
21044 int arg2 ;
21045 wxDateTime result;
21046 PyObject * obj0 = 0 ;
21047 PyObject * obj1 = 0 ;
21048 char *kwnames[] = {
21049 (char *) "self",(char *) "yday", NULL
21050 };
21051
21052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21054 if (SWIG_arg_fail(1)) SWIG_fail;
21055 {
21056 arg2 = (int)(SWIG_As_int(obj1));
21057 if (SWIG_arg_fail(2)) SWIG_fail;
21058 }
21059 {
21060 PyThreadState* __tstate = wxPyBeginAllowThreads();
21061 result = (arg1)->GetYearDay(arg2);
21062
21063 wxPyEndAllowThreads(__tstate);
21064 if (PyErr_Occurred()) SWIG_fail;
21065 }
21066 {
21067 wxDateTime * resultptr;
21068 resultptr = new wxDateTime((wxDateTime &)(result));
21069 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21070 }
21071 return resultobj;
21072 fail:
21073 return NULL;
21074 }
21075
21076
21077 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21078 PyObject *resultobj;
21079 wxDateTime *arg1 = (wxDateTime *) 0 ;
21080 double result;
21081 PyObject * obj0 = 0 ;
21082 char *kwnames[] = {
21083 (char *) "self", NULL
21084 };
21085
21086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21088 if (SWIG_arg_fail(1)) SWIG_fail;
21089 {
21090 PyThreadState* __tstate = wxPyBeginAllowThreads();
21091 result = (double)(arg1)->GetJulianDayNumber();
21092
21093 wxPyEndAllowThreads(__tstate);
21094 if (PyErr_Occurred()) SWIG_fail;
21095 }
21096 {
21097 resultobj = SWIG_From_double((double)(result));
21098 }
21099 return resultobj;
21100 fail:
21101 return NULL;
21102 }
21103
21104
21105 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21106 PyObject *resultobj;
21107 wxDateTime *arg1 = (wxDateTime *) 0 ;
21108 double result;
21109 PyObject * obj0 = 0 ;
21110 char *kwnames[] = {
21111 (char *) "self", NULL
21112 };
21113
21114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21116 if (SWIG_arg_fail(1)) SWIG_fail;
21117 {
21118 PyThreadState* __tstate = wxPyBeginAllowThreads();
21119 result = (double)(arg1)->GetJDN();
21120
21121 wxPyEndAllowThreads(__tstate);
21122 if (PyErr_Occurred()) SWIG_fail;
21123 }
21124 {
21125 resultobj = SWIG_From_double((double)(result));
21126 }
21127 return resultobj;
21128 fail:
21129 return NULL;
21130 }
21131
21132
21133 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21134 PyObject *resultobj;
21135 wxDateTime *arg1 = (wxDateTime *) 0 ;
21136 double result;
21137 PyObject * obj0 = 0 ;
21138 char *kwnames[] = {
21139 (char *) "self", NULL
21140 };
21141
21142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21144 if (SWIG_arg_fail(1)) SWIG_fail;
21145 {
21146 PyThreadState* __tstate = wxPyBeginAllowThreads();
21147 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21148
21149 wxPyEndAllowThreads(__tstate);
21150 if (PyErr_Occurred()) SWIG_fail;
21151 }
21152 {
21153 resultobj = SWIG_From_double((double)(result));
21154 }
21155 return resultobj;
21156 fail:
21157 return NULL;
21158 }
21159
21160
21161 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21162 PyObject *resultobj;
21163 wxDateTime *arg1 = (wxDateTime *) 0 ;
21164 double result;
21165 PyObject * obj0 = 0 ;
21166 char *kwnames[] = {
21167 (char *) "self", NULL
21168 };
21169
21170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21172 if (SWIG_arg_fail(1)) SWIG_fail;
21173 {
21174 PyThreadState* __tstate = wxPyBeginAllowThreads();
21175 result = (double)(arg1)->GetMJD();
21176
21177 wxPyEndAllowThreads(__tstate);
21178 if (PyErr_Occurred()) SWIG_fail;
21179 }
21180 {
21181 resultobj = SWIG_From_double((double)(result));
21182 }
21183 return resultobj;
21184 fail:
21185 return NULL;
21186 }
21187
21188
21189 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21190 PyObject *resultobj;
21191 wxDateTime *arg1 = (wxDateTime *) 0 ;
21192 double result;
21193 PyObject * obj0 = 0 ;
21194 char *kwnames[] = {
21195 (char *) "self", NULL
21196 };
21197
21198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21200 if (SWIG_arg_fail(1)) SWIG_fail;
21201 {
21202 PyThreadState* __tstate = wxPyBeginAllowThreads();
21203 result = (double)(arg1)->GetRataDie();
21204
21205 wxPyEndAllowThreads(__tstate);
21206 if (PyErr_Occurred()) SWIG_fail;
21207 }
21208 {
21209 resultobj = SWIG_From_double((double)(result));
21210 }
21211 return resultobj;
21212 fail:
21213 return NULL;
21214 }
21215
21216
21217 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21218 PyObject *resultobj;
21219 wxDateTime *arg1 = (wxDateTime *) 0 ;
21220 wxDateTime::TimeZone *arg2 = 0 ;
21221 bool arg3 = (bool) false ;
21222 wxDateTime result;
21223 bool temp2 = false ;
21224 PyObject * obj0 = 0 ;
21225 PyObject * obj1 = 0 ;
21226 PyObject * obj2 = 0 ;
21227 char *kwnames[] = {
21228 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21229 };
21230
21231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21233 if (SWIG_arg_fail(1)) SWIG_fail;
21234 {
21235 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21236 temp2 = true;
21237 }
21238 if (obj2) {
21239 {
21240 arg3 = (bool)(SWIG_As_bool(obj2));
21241 if (SWIG_arg_fail(3)) SWIG_fail;
21242 }
21243 }
21244 {
21245 PyThreadState* __tstate = wxPyBeginAllowThreads();
21246 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21247
21248 wxPyEndAllowThreads(__tstate);
21249 if (PyErr_Occurred()) SWIG_fail;
21250 }
21251 {
21252 wxDateTime * resultptr;
21253 resultptr = new wxDateTime((wxDateTime &)(result));
21254 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21255 }
21256 {
21257 if (temp2) delete arg2;
21258 }
21259 return resultobj;
21260 fail:
21261 {
21262 if (temp2) delete arg2;
21263 }
21264 return NULL;
21265 }
21266
21267
21268 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21269 PyObject *resultobj;
21270 wxDateTime *arg1 = (wxDateTime *) 0 ;
21271 wxDateTime::TimeZone *arg2 = 0 ;
21272 bool arg3 = (bool) false ;
21273 wxDateTime *result;
21274 bool temp2 = false ;
21275 PyObject * obj0 = 0 ;
21276 PyObject * obj1 = 0 ;
21277 PyObject * obj2 = 0 ;
21278 char *kwnames[] = {
21279 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21280 };
21281
21282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21284 if (SWIG_arg_fail(1)) SWIG_fail;
21285 {
21286 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21287 temp2 = true;
21288 }
21289 if (obj2) {
21290 {
21291 arg3 = (bool)(SWIG_As_bool(obj2));
21292 if (SWIG_arg_fail(3)) SWIG_fail;
21293 }
21294 }
21295 {
21296 PyThreadState* __tstate = wxPyBeginAllowThreads();
21297 {
21298 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21299 result = (wxDateTime *) &_result_ref;
21300 }
21301
21302 wxPyEndAllowThreads(__tstate);
21303 if (PyErr_Occurred()) SWIG_fail;
21304 }
21305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21306 {
21307 if (temp2) delete arg2;
21308 }
21309 return resultobj;
21310 fail:
21311 {
21312 if (temp2) delete arg2;
21313 }
21314 return NULL;
21315 }
21316
21317
21318 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21319 PyObject *resultobj;
21320 wxDateTime *arg1 = (wxDateTime *) 0 ;
21321 bool arg2 = (bool) false ;
21322 wxDateTime result;
21323 PyObject * obj0 = 0 ;
21324 PyObject * obj1 = 0 ;
21325 char *kwnames[] = {
21326 (char *) "self",(char *) "noDST", NULL
21327 };
21328
21329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21331 if (SWIG_arg_fail(1)) SWIG_fail;
21332 if (obj1) {
21333 {
21334 arg2 = (bool)(SWIG_As_bool(obj1));
21335 if (SWIG_arg_fail(2)) SWIG_fail;
21336 }
21337 }
21338 {
21339 PyThreadState* __tstate = wxPyBeginAllowThreads();
21340 result = (arg1)->ToGMT(arg2);
21341
21342 wxPyEndAllowThreads(__tstate);
21343 if (PyErr_Occurred()) SWIG_fail;
21344 }
21345 {
21346 wxDateTime * resultptr;
21347 resultptr = new wxDateTime((wxDateTime &)(result));
21348 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21349 }
21350 return resultobj;
21351 fail:
21352 return NULL;
21353 }
21354
21355
21356 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21357 PyObject *resultobj;
21358 wxDateTime *arg1 = (wxDateTime *) 0 ;
21359 bool arg2 = (bool) false ;
21360 wxDateTime *result;
21361 PyObject * obj0 = 0 ;
21362 PyObject * obj1 = 0 ;
21363 char *kwnames[] = {
21364 (char *) "self",(char *) "noDST", NULL
21365 };
21366
21367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21369 if (SWIG_arg_fail(1)) SWIG_fail;
21370 if (obj1) {
21371 {
21372 arg2 = (bool)(SWIG_As_bool(obj1));
21373 if (SWIG_arg_fail(2)) SWIG_fail;
21374 }
21375 }
21376 {
21377 PyThreadState* __tstate = wxPyBeginAllowThreads();
21378 {
21379 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21380 result = (wxDateTime *) &_result_ref;
21381 }
21382
21383 wxPyEndAllowThreads(__tstate);
21384 if (PyErr_Occurred()) SWIG_fail;
21385 }
21386 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21387 return resultobj;
21388 fail:
21389 return NULL;
21390 }
21391
21392
21393 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21394 PyObject *resultobj;
21395 wxDateTime *arg1 = (wxDateTime *) 0 ;
21396 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21397 int result;
21398 PyObject * obj0 = 0 ;
21399 PyObject * obj1 = 0 ;
21400 char *kwnames[] = {
21401 (char *) "self",(char *) "country", NULL
21402 };
21403
21404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21406 if (SWIG_arg_fail(1)) SWIG_fail;
21407 if (obj1) {
21408 {
21409 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21410 if (SWIG_arg_fail(2)) SWIG_fail;
21411 }
21412 }
21413 {
21414 PyThreadState* __tstate = wxPyBeginAllowThreads();
21415 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21416
21417 wxPyEndAllowThreads(__tstate);
21418 if (PyErr_Occurred()) SWIG_fail;
21419 }
21420 {
21421 resultobj = SWIG_From_int((int)(result));
21422 }
21423 return resultobj;
21424 fail:
21425 return NULL;
21426 }
21427
21428
21429 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21430 PyObject *resultobj;
21431 wxDateTime *arg1 = (wxDateTime *) 0 ;
21432 bool result;
21433 PyObject * obj0 = 0 ;
21434 char *kwnames[] = {
21435 (char *) "self", NULL
21436 };
21437
21438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21440 if (SWIG_arg_fail(1)) SWIG_fail;
21441 {
21442 PyThreadState* __tstate = wxPyBeginAllowThreads();
21443 result = (bool)((wxDateTime const *)arg1)->IsValid();
21444
21445 wxPyEndAllowThreads(__tstate);
21446 if (PyErr_Occurred()) SWIG_fail;
21447 }
21448 {
21449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21450 }
21451 return resultobj;
21452 fail:
21453 return NULL;
21454 }
21455
21456
21457 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21458 PyObject *resultobj;
21459 wxDateTime *arg1 = (wxDateTime *) 0 ;
21460 time_t result;
21461 PyObject * obj0 = 0 ;
21462 char *kwnames[] = {
21463 (char *) "self", NULL
21464 };
21465
21466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21468 if (SWIG_arg_fail(1)) SWIG_fail;
21469 {
21470 PyThreadState* __tstate = wxPyBeginAllowThreads();
21471 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21472
21473 wxPyEndAllowThreads(__tstate);
21474 if (PyErr_Occurred()) SWIG_fail;
21475 }
21476 {
21477 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21478 }
21479 return resultobj;
21480 fail:
21481 return NULL;
21482 }
21483
21484
21485 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21486 PyObject *resultobj;
21487 wxDateTime *arg1 = (wxDateTime *) 0 ;
21488 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21489 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21490 int result;
21491 bool temp2 = false ;
21492 PyObject * obj0 = 0 ;
21493 PyObject * obj1 = 0 ;
21494 char *kwnames[] = {
21495 (char *) "self",(char *) "tz", NULL
21496 };
21497
21498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21500 if (SWIG_arg_fail(1)) SWIG_fail;
21501 if (obj1) {
21502 {
21503 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21504 temp2 = true;
21505 }
21506 }
21507 {
21508 PyThreadState* __tstate = wxPyBeginAllowThreads();
21509 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21510
21511 wxPyEndAllowThreads(__tstate);
21512 if (PyErr_Occurred()) SWIG_fail;
21513 }
21514 {
21515 resultobj = SWIG_From_int((int)(result));
21516 }
21517 {
21518 if (temp2) delete arg2;
21519 }
21520 return resultobj;
21521 fail:
21522 {
21523 if (temp2) delete arg2;
21524 }
21525 return NULL;
21526 }
21527
21528
21529 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21530 PyObject *resultobj;
21531 wxDateTime *arg1 = (wxDateTime *) 0 ;
21532 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21533 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21534 wxDateTime::Month result;
21535 bool temp2 = false ;
21536 PyObject * obj0 = 0 ;
21537 PyObject * obj1 = 0 ;
21538 char *kwnames[] = {
21539 (char *) "self",(char *) "tz", NULL
21540 };
21541
21542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21544 if (SWIG_arg_fail(1)) SWIG_fail;
21545 if (obj1) {
21546 {
21547 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21548 temp2 = true;
21549 }
21550 }
21551 {
21552 PyThreadState* __tstate = wxPyBeginAllowThreads();
21553 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21554
21555 wxPyEndAllowThreads(__tstate);
21556 if (PyErr_Occurred()) SWIG_fail;
21557 }
21558 resultobj = SWIG_From_int((result));
21559 {
21560 if (temp2) delete arg2;
21561 }
21562 return resultobj;
21563 fail:
21564 {
21565 if (temp2) delete arg2;
21566 }
21567 return NULL;
21568 }
21569
21570
21571 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21572 PyObject *resultobj;
21573 wxDateTime *arg1 = (wxDateTime *) 0 ;
21574 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21575 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21576 int result;
21577 bool temp2 = false ;
21578 PyObject * obj0 = 0 ;
21579 PyObject * obj1 = 0 ;
21580 char *kwnames[] = {
21581 (char *) "self",(char *) "tz", NULL
21582 };
21583
21584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21586 if (SWIG_arg_fail(1)) SWIG_fail;
21587 if (obj1) {
21588 {
21589 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21590 temp2 = true;
21591 }
21592 }
21593 {
21594 PyThreadState* __tstate = wxPyBeginAllowThreads();
21595 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21596
21597 wxPyEndAllowThreads(__tstate);
21598 if (PyErr_Occurred()) SWIG_fail;
21599 }
21600 {
21601 resultobj = SWIG_From_int((int)(result));
21602 }
21603 {
21604 if (temp2) delete arg2;
21605 }
21606 return resultobj;
21607 fail:
21608 {
21609 if (temp2) delete arg2;
21610 }
21611 return NULL;
21612 }
21613
21614
21615 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21616 PyObject *resultobj;
21617 wxDateTime *arg1 = (wxDateTime *) 0 ;
21618 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21619 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21620 wxDateTime::WeekDay result;
21621 bool temp2 = false ;
21622 PyObject * obj0 = 0 ;
21623 PyObject * obj1 = 0 ;
21624 char *kwnames[] = {
21625 (char *) "self",(char *) "tz", NULL
21626 };
21627
21628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21630 if (SWIG_arg_fail(1)) SWIG_fail;
21631 if (obj1) {
21632 {
21633 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21634 temp2 = true;
21635 }
21636 }
21637 {
21638 PyThreadState* __tstate = wxPyBeginAllowThreads();
21639 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21640
21641 wxPyEndAllowThreads(__tstate);
21642 if (PyErr_Occurred()) SWIG_fail;
21643 }
21644 resultobj = SWIG_From_int((result));
21645 {
21646 if (temp2) delete arg2;
21647 }
21648 return resultobj;
21649 fail:
21650 {
21651 if (temp2) delete arg2;
21652 }
21653 return NULL;
21654 }
21655
21656
21657 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21658 PyObject *resultobj;
21659 wxDateTime *arg1 = (wxDateTime *) 0 ;
21660 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21661 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21662 int result;
21663 bool temp2 = false ;
21664 PyObject * obj0 = 0 ;
21665 PyObject * obj1 = 0 ;
21666 char *kwnames[] = {
21667 (char *) "self",(char *) "tz", NULL
21668 };
21669
21670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21672 if (SWIG_arg_fail(1)) SWIG_fail;
21673 if (obj1) {
21674 {
21675 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21676 temp2 = true;
21677 }
21678 }
21679 {
21680 PyThreadState* __tstate = wxPyBeginAllowThreads();
21681 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21682
21683 wxPyEndAllowThreads(__tstate);
21684 if (PyErr_Occurred()) SWIG_fail;
21685 }
21686 {
21687 resultobj = SWIG_From_int((int)(result));
21688 }
21689 {
21690 if (temp2) delete arg2;
21691 }
21692 return resultobj;
21693 fail:
21694 {
21695 if (temp2) delete arg2;
21696 }
21697 return NULL;
21698 }
21699
21700
21701 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21702 PyObject *resultobj;
21703 wxDateTime *arg1 = (wxDateTime *) 0 ;
21704 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21705 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21706 int result;
21707 bool temp2 = false ;
21708 PyObject * obj0 = 0 ;
21709 PyObject * obj1 = 0 ;
21710 char *kwnames[] = {
21711 (char *) "self",(char *) "tz", NULL
21712 };
21713
21714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21716 if (SWIG_arg_fail(1)) SWIG_fail;
21717 if (obj1) {
21718 {
21719 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21720 temp2 = true;
21721 }
21722 }
21723 {
21724 PyThreadState* __tstate = wxPyBeginAllowThreads();
21725 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21726
21727 wxPyEndAllowThreads(__tstate);
21728 if (PyErr_Occurred()) SWIG_fail;
21729 }
21730 {
21731 resultobj = SWIG_From_int((int)(result));
21732 }
21733 {
21734 if (temp2) delete arg2;
21735 }
21736 return resultobj;
21737 fail:
21738 {
21739 if (temp2) delete arg2;
21740 }
21741 return NULL;
21742 }
21743
21744
21745 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21746 PyObject *resultobj;
21747 wxDateTime *arg1 = (wxDateTime *) 0 ;
21748 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21749 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21750 int result;
21751 bool temp2 = false ;
21752 PyObject * obj0 = 0 ;
21753 PyObject * obj1 = 0 ;
21754 char *kwnames[] = {
21755 (char *) "self",(char *) "tz", NULL
21756 };
21757
21758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21760 if (SWIG_arg_fail(1)) SWIG_fail;
21761 if (obj1) {
21762 {
21763 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21764 temp2 = true;
21765 }
21766 }
21767 {
21768 PyThreadState* __tstate = wxPyBeginAllowThreads();
21769 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21770
21771 wxPyEndAllowThreads(__tstate);
21772 if (PyErr_Occurred()) SWIG_fail;
21773 }
21774 {
21775 resultobj = SWIG_From_int((int)(result));
21776 }
21777 {
21778 if (temp2) delete arg2;
21779 }
21780 return resultobj;
21781 fail:
21782 {
21783 if (temp2) delete arg2;
21784 }
21785 return NULL;
21786 }
21787
21788
21789 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21790 PyObject *resultobj;
21791 wxDateTime *arg1 = (wxDateTime *) 0 ;
21792 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21793 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21794 int result;
21795 bool temp2 = false ;
21796 PyObject * obj0 = 0 ;
21797 PyObject * obj1 = 0 ;
21798 char *kwnames[] = {
21799 (char *) "self",(char *) "tz", NULL
21800 };
21801
21802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21804 if (SWIG_arg_fail(1)) SWIG_fail;
21805 if (obj1) {
21806 {
21807 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21808 temp2 = true;
21809 }
21810 }
21811 {
21812 PyThreadState* __tstate = wxPyBeginAllowThreads();
21813 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21814
21815 wxPyEndAllowThreads(__tstate);
21816 if (PyErr_Occurred()) SWIG_fail;
21817 }
21818 {
21819 resultobj = SWIG_From_int((int)(result));
21820 }
21821 {
21822 if (temp2) delete arg2;
21823 }
21824 return resultobj;
21825 fail:
21826 {
21827 if (temp2) delete arg2;
21828 }
21829 return NULL;
21830 }
21831
21832
21833 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21834 PyObject *resultobj;
21835 wxDateTime *arg1 = (wxDateTime *) 0 ;
21836 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21837 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21838 int result;
21839 bool temp2 = false ;
21840 PyObject * obj0 = 0 ;
21841 PyObject * obj1 = 0 ;
21842 char *kwnames[] = {
21843 (char *) "self",(char *) "tz", NULL
21844 };
21845
21846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21848 if (SWIG_arg_fail(1)) SWIG_fail;
21849 if (obj1) {
21850 {
21851 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21852 temp2 = true;
21853 }
21854 }
21855 {
21856 PyThreadState* __tstate = wxPyBeginAllowThreads();
21857 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21858
21859 wxPyEndAllowThreads(__tstate);
21860 if (PyErr_Occurred()) SWIG_fail;
21861 }
21862 {
21863 resultobj = SWIG_From_int((int)(result));
21864 }
21865 {
21866 if (temp2) delete arg2;
21867 }
21868 return resultobj;
21869 fail:
21870 {
21871 if (temp2) delete arg2;
21872 }
21873 return NULL;
21874 }
21875
21876
21877 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21878 PyObject *resultobj;
21879 wxDateTime *arg1 = (wxDateTime *) 0 ;
21880 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21881 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21882 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21883 int result;
21884 bool temp3 = false ;
21885 PyObject * obj0 = 0 ;
21886 PyObject * obj1 = 0 ;
21887 PyObject * obj2 = 0 ;
21888 char *kwnames[] = {
21889 (char *) "self",(char *) "flags",(char *) "tz", NULL
21890 };
21891
21892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21894 if (SWIG_arg_fail(1)) SWIG_fail;
21895 if (obj1) {
21896 {
21897 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21898 if (SWIG_arg_fail(2)) SWIG_fail;
21899 }
21900 }
21901 if (obj2) {
21902 {
21903 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21904 temp3 = true;
21905 }
21906 }
21907 {
21908 PyThreadState* __tstate = wxPyBeginAllowThreads();
21909 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21910
21911 wxPyEndAllowThreads(__tstate);
21912 if (PyErr_Occurred()) SWIG_fail;
21913 }
21914 {
21915 resultobj = SWIG_From_int((int)(result));
21916 }
21917 {
21918 if (temp3) delete arg3;
21919 }
21920 return resultobj;
21921 fail:
21922 {
21923 if (temp3) delete arg3;
21924 }
21925 return NULL;
21926 }
21927
21928
21929 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21930 PyObject *resultobj;
21931 wxDateTime *arg1 = (wxDateTime *) 0 ;
21932 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21933 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21934 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21935 int result;
21936 bool temp3 = false ;
21937 PyObject * obj0 = 0 ;
21938 PyObject * obj1 = 0 ;
21939 PyObject * obj2 = 0 ;
21940 char *kwnames[] = {
21941 (char *) "self",(char *) "flags",(char *) "tz", NULL
21942 };
21943
21944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21946 if (SWIG_arg_fail(1)) SWIG_fail;
21947 if (obj1) {
21948 {
21949 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21950 if (SWIG_arg_fail(2)) SWIG_fail;
21951 }
21952 }
21953 if (obj2) {
21954 {
21955 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21956 temp3 = true;
21957 }
21958 }
21959 {
21960 PyThreadState* __tstate = wxPyBeginAllowThreads();
21961 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21962
21963 wxPyEndAllowThreads(__tstate);
21964 if (PyErr_Occurred()) SWIG_fail;
21965 }
21966 {
21967 resultobj = SWIG_From_int((int)(result));
21968 }
21969 {
21970 if (temp3) delete arg3;
21971 }
21972 return resultobj;
21973 fail:
21974 {
21975 if (temp3) delete arg3;
21976 }
21977 return NULL;
21978 }
21979
21980
21981 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21982 PyObject *resultobj;
21983 wxDateTime *arg1 = (wxDateTime *) 0 ;
21984 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21985 bool result;
21986 PyObject * obj0 = 0 ;
21987 PyObject * obj1 = 0 ;
21988 char *kwnames[] = {
21989 (char *) "self",(char *) "country", NULL
21990 };
21991
21992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21994 if (SWIG_arg_fail(1)) SWIG_fail;
21995 if (obj1) {
21996 {
21997 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21998 if (SWIG_arg_fail(2)) SWIG_fail;
21999 }
22000 }
22001 {
22002 PyThreadState* __tstate = wxPyBeginAllowThreads();
22003 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22004
22005 wxPyEndAllowThreads(__tstate);
22006 if (PyErr_Occurred()) SWIG_fail;
22007 }
22008 {
22009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22010 }
22011 return resultobj;
22012 fail:
22013 return NULL;
22014 }
22015
22016
22017 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22018 PyObject *resultobj;
22019 wxDateTime *arg1 = (wxDateTime *) 0 ;
22020 wxDateTime *arg2 = 0 ;
22021 bool result;
22022 PyObject * obj0 = 0 ;
22023 PyObject * obj1 = 0 ;
22024 char *kwnames[] = {
22025 (char *) "self",(char *) "datetime", NULL
22026 };
22027
22028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22030 if (SWIG_arg_fail(1)) SWIG_fail;
22031 {
22032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22033 if (SWIG_arg_fail(2)) SWIG_fail;
22034 if (arg2 == NULL) {
22035 SWIG_null_ref("wxDateTime");
22036 }
22037 if (SWIG_arg_fail(2)) SWIG_fail;
22038 }
22039 {
22040 PyThreadState* __tstate = wxPyBeginAllowThreads();
22041 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22042
22043 wxPyEndAllowThreads(__tstate);
22044 if (PyErr_Occurred()) SWIG_fail;
22045 }
22046 {
22047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22048 }
22049 return resultobj;
22050 fail:
22051 return NULL;
22052 }
22053
22054
22055 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22056 PyObject *resultobj;
22057 wxDateTime *arg1 = (wxDateTime *) 0 ;
22058 wxDateTime *arg2 = 0 ;
22059 bool result;
22060 PyObject * obj0 = 0 ;
22061 PyObject * obj1 = 0 ;
22062 char *kwnames[] = {
22063 (char *) "self",(char *) "datetime", NULL
22064 };
22065
22066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22068 if (SWIG_arg_fail(1)) SWIG_fail;
22069 {
22070 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22071 if (SWIG_arg_fail(2)) SWIG_fail;
22072 if (arg2 == NULL) {
22073 SWIG_null_ref("wxDateTime");
22074 }
22075 if (SWIG_arg_fail(2)) SWIG_fail;
22076 }
22077 {
22078 PyThreadState* __tstate = wxPyBeginAllowThreads();
22079 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22080
22081 wxPyEndAllowThreads(__tstate);
22082 if (PyErr_Occurred()) SWIG_fail;
22083 }
22084 {
22085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22086 }
22087 return resultobj;
22088 fail:
22089 return NULL;
22090 }
22091
22092
22093 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22094 PyObject *resultobj;
22095 wxDateTime *arg1 = (wxDateTime *) 0 ;
22096 wxDateTime *arg2 = 0 ;
22097 bool result;
22098 PyObject * obj0 = 0 ;
22099 PyObject * obj1 = 0 ;
22100 char *kwnames[] = {
22101 (char *) "self",(char *) "datetime", NULL
22102 };
22103
22104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22106 if (SWIG_arg_fail(1)) SWIG_fail;
22107 {
22108 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22109 if (SWIG_arg_fail(2)) SWIG_fail;
22110 if (arg2 == NULL) {
22111 SWIG_null_ref("wxDateTime");
22112 }
22113 if (SWIG_arg_fail(2)) SWIG_fail;
22114 }
22115 {
22116 PyThreadState* __tstate = wxPyBeginAllowThreads();
22117 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22118
22119 wxPyEndAllowThreads(__tstate);
22120 if (PyErr_Occurred()) SWIG_fail;
22121 }
22122 {
22123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22124 }
22125 return resultobj;
22126 fail:
22127 return NULL;
22128 }
22129
22130
22131 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22132 PyObject *resultobj;
22133 wxDateTime *arg1 = (wxDateTime *) 0 ;
22134 wxDateTime *arg2 = 0 ;
22135 wxDateTime *arg3 = 0 ;
22136 bool result;
22137 PyObject * obj0 = 0 ;
22138 PyObject * obj1 = 0 ;
22139 PyObject * obj2 = 0 ;
22140 char *kwnames[] = {
22141 (char *) "self",(char *) "t1",(char *) "t2", NULL
22142 };
22143
22144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22146 if (SWIG_arg_fail(1)) SWIG_fail;
22147 {
22148 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22149 if (SWIG_arg_fail(2)) SWIG_fail;
22150 if (arg2 == NULL) {
22151 SWIG_null_ref("wxDateTime");
22152 }
22153 if (SWIG_arg_fail(2)) SWIG_fail;
22154 }
22155 {
22156 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22157 if (SWIG_arg_fail(3)) SWIG_fail;
22158 if (arg3 == NULL) {
22159 SWIG_null_ref("wxDateTime");
22160 }
22161 if (SWIG_arg_fail(3)) SWIG_fail;
22162 }
22163 {
22164 PyThreadState* __tstate = wxPyBeginAllowThreads();
22165 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22166
22167 wxPyEndAllowThreads(__tstate);
22168 if (PyErr_Occurred()) SWIG_fail;
22169 }
22170 {
22171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22172 }
22173 return resultobj;
22174 fail:
22175 return NULL;
22176 }
22177
22178
22179 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22180 PyObject *resultobj;
22181 wxDateTime *arg1 = (wxDateTime *) 0 ;
22182 wxDateTime *arg2 = 0 ;
22183 wxDateTime *arg3 = 0 ;
22184 bool result;
22185 PyObject * obj0 = 0 ;
22186 PyObject * obj1 = 0 ;
22187 PyObject * obj2 = 0 ;
22188 char *kwnames[] = {
22189 (char *) "self",(char *) "t1",(char *) "t2", NULL
22190 };
22191
22192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22194 if (SWIG_arg_fail(1)) SWIG_fail;
22195 {
22196 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22197 if (SWIG_arg_fail(2)) SWIG_fail;
22198 if (arg2 == NULL) {
22199 SWIG_null_ref("wxDateTime");
22200 }
22201 if (SWIG_arg_fail(2)) SWIG_fail;
22202 }
22203 {
22204 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22205 if (SWIG_arg_fail(3)) SWIG_fail;
22206 if (arg3 == NULL) {
22207 SWIG_null_ref("wxDateTime");
22208 }
22209 if (SWIG_arg_fail(3)) SWIG_fail;
22210 }
22211 {
22212 PyThreadState* __tstate = wxPyBeginAllowThreads();
22213 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22214
22215 wxPyEndAllowThreads(__tstate);
22216 if (PyErr_Occurred()) SWIG_fail;
22217 }
22218 {
22219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22220 }
22221 return resultobj;
22222 fail:
22223 return NULL;
22224 }
22225
22226
22227 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22228 PyObject *resultobj;
22229 wxDateTime *arg1 = (wxDateTime *) 0 ;
22230 wxDateTime *arg2 = 0 ;
22231 bool result;
22232 PyObject * obj0 = 0 ;
22233 PyObject * obj1 = 0 ;
22234 char *kwnames[] = {
22235 (char *) "self",(char *) "dt", NULL
22236 };
22237
22238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22240 if (SWIG_arg_fail(1)) SWIG_fail;
22241 {
22242 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22243 if (SWIG_arg_fail(2)) SWIG_fail;
22244 if (arg2 == NULL) {
22245 SWIG_null_ref("wxDateTime");
22246 }
22247 if (SWIG_arg_fail(2)) SWIG_fail;
22248 }
22249 {
22250 PyThreadState* __tstate = wxPyBeginAllowThreads();
22251 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22252
22253 wxPyEndAllowThreads(__tstate);
22254 if (PyErr_Occurred()) SWIG_fail;
22255 }
22256 {
22257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22258 }
22259 return resultobj;
22260 fail:
22261 return NULL;
22262 }
22263
22264
22265 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22266 PyObject *resultobj;
22267 wxDateTime *arg1 = (wxDateTime *) 0 ;
22268 wxDateTime *arg2 = 0 ;
22269 bool result;
22270 PyObject * obj0 = 0 ;
22271 PyObject * obj1 = 0 ;
22272 char *kwnames[] = {
22273 (char *) "self",(char *) "dt", NULL
22274 };
22275
22276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22278 if (SWIG_arg_fail(1)) SWIG_fail;
22279 {
22280 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22281 if (SWIG_arg_fail(2)) SWIG_fail;
22282 if (arg2 == NULL) {
22283 SWIG_null_ref("wxDateTime");
22284 }
22285 if (SWIG_arg_fail(2)) SWIG_fail;
22286 }
22287 {
22288 PyThreadState* __tstate = wxPyBeginAllowThreads();
22289 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22290
22291 wxPyEndAllowThreads(__tstate);
22292 if (PyErr_Occurred()) SWIG_fail;
22293 }
22294 {
22295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22296 }
22297 return resultobj;
22298 fail:
22299 return NULL;
22300 }
22301
22302
22303 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22304 PyObject *resultobj;
22305 wxDateTime *arg1 = (wxDateTime *) 0 ;
22306 wxDateTime *arg2 = 0 ;
22307 wxTimeSpan *arg3 = 0 ;
22308 bool result;
22309 PyObject * obj0 = 0 ;
22310 PyObject * obj1 = 0 ;
22311 PyObject * obj2 = 0 ;
22312 char *kwnames[] = {
22313 (char *) "self",(char *) "dt",(char *) "ts", NULL
22314 };
22315
22316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22318 if (SWIG_arg_fail(1)) SWIG_fail;
22319 {
22320 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22321 if (SWIG_arg_fail(2)) SWIG_fail;
22322 if (arg2 == NULL) {
22323 SWIG_null_ref("wxDateTime");
22324 }
22325 if (SWIG_arg_fail(2)) SWIG_fail;
22326 }
22327 {
22328 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22329 if (SWIG_arg_fail(3)) SWIG_fail;
22330 if (arg3 == NULL) {
22331 SWIG_null_ref("wxTimeSpan");
22332 }
22333 if (SWIG_arg_fail(3)) SWIG_fail;
22334 }
22335 {
22336 PyThreadState* __tstate = wxPyBeginAllowThreads();
22337 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22338
22339 wxPyEndAllowThreads(__tstate);
22340 if (PyErr_Occurred()) SWIG_fail;
22341 }
22342 {
22343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22344 }
22345 return resultobj;
22346 fail:
22347 return NULL;
22348 }
22349
22350
22351 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22352 PyObject *resultobj;
22353 wxDateTime *arg1 = (wxDateTime *) 0 ;
22354 wxTimeSpan *arg2 = 0 ;
22355 wxDateTime *result;
22356 PyObject * obj0 = 0 ;
22357 PyObject * obj1 = 0 ;
22358 char *kwnames[] = {
22359 (char *) "self",(char *) "diff", NULL
22360 };
22361
22362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22364 if (SWIG_arg_fail(1)) SWIG_fail;
22365 {
22366 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22367 if (SWIG_arg_fail(2)) SWIG_fail;
22368 if (arg2 == NULL) {
22369 SWIG_null_ref("wxTimeSpan");
22370 }
22371 if (SWIG_arg_fail(2)) SWIG_fail;
22372 }
22373 {
22374 PyThreadState* __tstate = wxPyBeginAllowThreads();
22375 {
22376 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22377 result = (wxDateTime *) &_result_ref;
22378 }
22379
22380 wxPyEndAllowThreads(__tstate);
22381 if (PyErr_Occurred()) SWIG_fail;
22382 }
22383 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22384 return resultobj;
22385 fail:
22386 return NULL;
22387 }
22388
22389
22390 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22391 PyObject *resultobj;
22392 wxDateTime *arg1 = (wxDateTime *) 0 ;
22393 wxDateSpan *arg2 = 0 ;
22394 wxDateTime *result;
22395 PyObject * obj0 = 0 ;
22396 PyObject * obj1 = 0 ;
22397 char *kwnames[] = {
22398 (char *) "self",(char *) "diff", NULL
22399 };
22400
22401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22403 if (SWIG_arg_fail(1)) SWIG_fail;
22404 {
22405 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22406 if (SWIG_arg_fail(2)) SWIG_fail;
22407 if (arg2 == NULL) {
22408 SWIG_null_ref("wxDateSpan");
22409 }
22410 if (SWIG_arg_fail(2)) SWIG_fail;
22411 }
22412 {
22413 PyThreadState* __tstate = wxPyBeginAllowThreads();
22414 {
22415 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22416 result = (wxDateTime *) &_result_ref;
22417 }
22418
22419 wxPyEndAllowThreads(__tstate);
22420 if (PyErr_Occurred()) SWIG_fail;
22421 }
22422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22423 return resultobj;
22424 fail:
22425 return NULL;
22426 }
22427
22428
22429 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22430 PyObject *resultobj;
22431 wxDateTime *arg1 = (wxDateTime *) 0 ;
22432 wxTimeSpan *arg2 = 0 ;
22433 wxDateTime *result;
22434 PyObject * obj0 = 0 ;
22435 PyObject * obj1 = 0 ;
22436 char *kwnames[] = {
22437 (char *) "self",(char *) "diff", NULL
22438 };
22439
22440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22442 if (SWIG_arg_fail(1)) SWIG_fail;
22443 {
22444 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22445 if (SWIG_arg_fail(2)) SWIG_fail;
22446 if (arg2 == NULL) {
22447 SWIG_null_ref("wxTimeSpan");
22448 }
22449 if (SWIG_arg_fail(2)) SWIG_fail;
22450 }
22451 {
22452 PyThreadState* __tstate = wxPyBeginAllowThreads();
22453 {
22454 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22455 result = (wxDateTime *) &_result_ref;
22456 }
22457
22458 wxPyEndAllowThreads(__tstate);
22459 if (PyErr_Occurred()) SWIG_fail;
22460 }
22461 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22462 return resultobj;
22463 fail:
22464 return NULL;
22465 }
22466
22467
22468 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22469 PyObject *resultobj;
22470 wxDateTime *arg1 = (wxDateTime *) 0 ;
22471 wxDateSpan *arg2 = 0 ;
22472 wxDateTime *result;
22473 PyObject * obj0 = 0 ;
22474 PyObject * obj1 = 0 ;
22475 char *kwnames[] = {
22476 (char *) "self",(char *) "diff", NULL
22477 };
22478
22479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22481 if (SWIG_arg_fail(1)) SWIG_fail;
22482 {
22483 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22484 if (SWIG_arg_fail(2)) SWIG_fail;
22485 if (arg2 == NULL) {
22486 SWIG_null_ref("wxDateSpan");
22487 }
22488 if (SWIG_arg_fail(2)) SWIG_fail;
22489 }
22490 {
22491 PyThreadState* __tstate = wxPyBeginAllowThreads();
22492 {
22493 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22494 result = (wxDateTime *) &_result_ref;
22495 }
22496
22497 wxPyEndAllowThreads(__tstate);
22498 if (PyErr_Occurred()) SWIG_fail;
22499 }
22500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22501 return resultobj;
22502 fail:
22503 return NULL;
22504 }
22505
22506
22507 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22508 PyObject *resultobj;
22509 wxDateTime *arg1 = (wxDateTime *) 0 ;
22510 wxDateTime *arg2 = 0 ;
22511 wxTimeSpan result;
22512 PyObject * obj0 = 0 ;
22513 PyObject * obj1 = 0 ;
22514 char *kwnames[] = {
22515 (char *) "self",(char *) "dt", NULL
22516 };
22517
22518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22520 if (SWIG_arg_fail(1)) SWIG_fail;
22521 {
22522 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22523 if (SWIG_arg_fail(2)) SWIG_fail;
22524 if (arg2 == NULL) {
22525 SWIG_null_ref("wxDateTime");
22526 }
22527 if (SWIG_arg_fail(2)) SWIG_fail;
22528 }
22529 {
22530 PyThreadState* __tstate = wxPyBeginAllowThreads();
22531 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22532
22533 wxPyEndAllowThreads(__tstate);
22534 if (PyErr_Occurred()) SWIG_fail;
22535 }
22536 {
22537 wxTimeSpan * resultptr;
22538 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22539 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22540 }
22541 return resultobj;
22542 fail:
22543 return NULL;
22544 }
22545
22546
22547 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22548 PyObject *resultobj;
22549 wxDateTime *arg1 = (wxDateTime *) 0 ;
22550 wxTimeSpan *arg2 = 0 ;
22551 wxDateTime *result;
22552 PyObject * obj0 = 0 ;
22553 PyObject * obj1 = 0 ;
22554
22555 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22557 if (SWIG_arg_fail(1)) SWIG_fail;
22558 {
22559 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22560 if (SWIG_arg_fail(2)) SWIG_fail;
22561 if (arg2 == NULL) {
22562 SWIG_null_ref("wxTimeSpan");
22563 }
22564 if (SWIG_arg_fail(2)) SWIG_fail;
22565 }
22566 {
22567 PyThreadState* __tstate = wxPyBeginAllowThreads();
22568 {
22569 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22570 result = (wxDateTime *) &_result_ref;
22571 }
22572
22573 wxPyEndAllowThreads(__tstate);
22574 if (PyErr_Occurred()) SWIG_fail;
22575 }
22576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22577 return resultobj;
22578 fail:
22579 return NULL;
22580 }
22581
22582
22583 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22584 PyObject *resultobj;
22585 wxDateTime *arg1 = (wxDateTime *) 0 ;
22586 wxDateSpan *arg2 = 0 ;
22587 wxDateTime *result;
22588 PyObject * obj0 = 0 ;
22589 PyObject * obj1 = 0 ;
22590
22591 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22593 if (SWIG_arg_fail(1)) SWIG_fail;
22594 {
22595 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22596 if (SWIG_arg_fail(2)) SWIG_fail;
22597 if (arg2 == NULL) {
22598 SWIG_null_ref("wxDateSpan");
22599 }
22600 if (SWIG_arg_fail(2)) SWIG_fail;
22601 }
22602 {
22603 PyThreadState* __tstate = wxPyBeginAllowThreads();
22604 {
22605 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22606 result = (wxDateTime *) &_result_ref;
22607 }
22608
22609 wxPyEndAllowThreads(__tstate);
22610 if (PyErr_Occurred()) SWIG_fail;
22611 }
22612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22613 return resultobj;
22614 fail:
22615 return NULL;
22616 }
22617
22618
22619 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22620 int argc;
22621 PyObject *argv[3];
22622 int ii;
22623
22624 argc = PyObject_Length(args);
22625 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22626 argv[ii] = PyTuple_GetItem(args,ii);
22627 }
22628 if (argc == 2) {
22629 int _v;
22630 {
22631 void *ptr;
22632 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22633 _v = 0;
22634 PyErr_Clear();
22635 } else {
22636 _v = 1;
22637 }
22638 }
22639 if (_v) {
22640 {
22641 void *ptr = 0;
22642 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22643 _v = 0;
22644 PyErr_Clear();
22645 } else {
22646 _v = (ptr != 0);
22647 }
22648 }
22649 if (_v) {
22650 return _wrap_DateTime___iadd____SWIG_0(self,args);
22651 }
22652 }
22653 }
22654 if (argc == 2) {
22655 int _v;
22656 {
22657 void *ptr;
22658 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22659 _v = 0;
22660 PyErr_Clear();
22661 } else {
22662 _v = 1;
22663 }
22664 }
22665 if (_v) {
22666 {
22667 void *ptr = 0;
22668 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22669 _v = 0;
22670 PyErr_Clear();
22671 } else {
22672 _v = (ptr != 0);
22673 }
22674 }
22675 if (_v) {
22676 return _wrap_DateTime___iadd____SWIG_1(self,args);
22677 }
22678 }
22679 }
22680
22681 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22682 return NULL;
22683 }
22684
22685
22686 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22687 PyObject *resultobj;
22688 wxDateTime *arg1 = (wxDateTime *) 0 ;
22689 wxTimeSpan *arg2 = 0 ;
22690 wxDateTime *result;
22691 PyObject * obj0 = 0 ;
22692 PyObject * obj1 = 0 ;
22693
22694 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22696 if (SWIG_arg_fail(1)) SWIG_fail;
22697 {
22698 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22699 if (SWIG_arg_fail(2)) SWIG_fail;
22700 if (arg2 == NULL) {
22701 SWIG_null_ref("wxTimeSpan");
22702 }
22703 if (SWIG_arg_fail(2)) SWIG_fail;
22704 }
22705 {
22706 PyThreadState* __tstate = wxPyBeginAllowThreads();
22707 {
22708 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22709 result = (wxDateTime *) &_result_ref;
22710 }
22711
22712 wxPyEndAllowThreads(__tstate);
22713 if (PyErr_Occurred()) SWIG_fail;
22714 }
22715 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22716 return resultobj;
22717 fail:
22718 return NULL;
22719 }
22720
22721
22722 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22723 PyObject *resultobj;
22724 wxDateTime *arg1 = (wxDateTime *) 0 ;
22725 wxDateSpan *arg2 = 0 ;
22726 wxDateTime *result;
22727 PyObject * obj0 = 0 ;
22728 PyObject * obj1 = 0 ;
22729
22730 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22732 if (SWIG_arg_fail(1)) SWIG_fail;
22733 {
22734 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22735 if (SWIG_arg_fail(2)) SWIG_fail;
22736 if (arg2 == NULL) {
22737 SWIG_null_ref("wxDateSpan");
22738 }
22739 if (SWIG_arg_fail(2)) SWIG_fail;
22740 }
22741 {
22742 PyThreadState* __tstate = wxPyBeginAllowThreads();
22743 {
22744 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22745 result = (wxDateTime *) &_result_ref;
22746 }
22747
22748 wxPyEndAllowThreads(__tstate);
22749 if (PyErr_Occurred()) SWIG_fail;
22750 }
22751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22752 return resultobj;
22753 fail:
22754 return NULL;
22755 }
22756
22757
22758 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22759 int argc;
22760 PyObject *argv[3];
22761 int ii;
22762
22763 argc = PyObject_Length(args);
22764 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22765 argv[ii] = PyTuple_GetItem(args,ii);
22766 }
22767 if (argc == 2) {
22768 int _v;
22769 {
22770 void *ptr;
22771 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22772 _v = 0;
22773 PyErr_Clear();
22774 } else {
22775 _v = 1;
22776 }
22777 }
22778 if (_v) {
22779 {
22780 void *ptr = 0;
22781 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22782 _v = 0;
22783 PyErr_Clear();
22784 } else {
22785 _v = (ptr != 0);
22786 }
22787 }
22788 if (_v) {
22789 return _wrap_DateTime___isub____SWIG_0(self,args);
22790 }
22791 }
22792 }
22793 if (argc == 2) {
22794 int _v;
22795 {
22796 void *ptr;
22797 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22798 _v = 0;
22799 PyErr_Clear();
22800 } else {
22801 _v = 1;
22802 }
22803 }
22804 if (_v) {
22805 {
22806 void *ptr = 0;
22807 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22808 _v = 0;
22809 PyErr_Clear();
22810 } else {
22811 _v = (ptr != 0);
22812 }
22813 }
22814 if (_v) {
22815 return _wrap_DateTime___isub____SWIG_1(self,args);
22816 }
22817 }
22818 }
22819
22820 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22821 return NULL;
22822 }
22823
22824
22825 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22826 PyObject *resultobj;
22827 wxDateTime *arg1 = (wxDateTime *) 0 ;
22828 wxTimeSpan *arg2 = 0 ;
22829 wxDateTime result;
22830 PyObject * obj0 = 0 ;
22831 PyObject * obj1 = 0 ;
22832
22833 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22835 if (SWIG_arg_fail(1)) SWIG_fail;
22836 {
22837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22838 if (SWIG_arg_fail(2)) SWIG_fail;
22839 if (arg2 == NULL) {
22840 SWIG_null_ref("wxTimeSpan");
22841 }
22842 if (SWIG_arg_fail(2)) SWIG_fail;
22843 }
22844 {
22845 PyThreadState* __tstate = wxPyBeginAllowThreads();
22846 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22847
22848 wxPyEndAllowThreads(__tstate);
22849 if (PyErr_Occurred()) SWIG_fail;
22850 }
22851 {
22852 wxDateTime * resultptr;
22853 resultptr = new wxDateTime((wxDateTime &)(result));
22854 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22855 }
22856 return resultobj;
22857 fail:
22858 return NULL;
22859 }
22860
22861
22862 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22863 PyObject *resultobj;
22864 wxDateTime *arg1 = (wxDateTime *) 0 ;
22865 wxDateSpan *arg2 = 0 ;
22866 wxDateTime result;
22867 PyObject * obj0 = 0 ;
22868 PyObject * obj1 = 0 ;
22869
22870 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22872 if (SWIG_arg_fail(1)) SWIG_fail;
22873 {
22874 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22875 if (SWIG_arg_fail(2)) SWIG_fail;
22876 if (arg2 == NULL) {
22877 SWIG_null_ref("wxDateSpan");
22878 }
22879 if (SWIG_arg_fail(2)) SWIG_fail;
22880 }
22881 {
22882 PyThreadState* __tstate = wxPyBeginAllowThreads();
22883 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22884
22885 wxPyEndAllowThreads(__tstate);
22886 if (PyErr_Occurred()) SWIG_fail;
22887 }
22888 {
22889 wxDateTime * resultptr;
22890 resultptr = new wxDateTime((wxDateTime &)(result));
22891 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22892 }
22893 return resultobj;
22894 fail:
22895 return NULL;
22896 }
22897
22898
22899 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22900 int argc;
22901 PyObject *argv[3];
22902 int ii;
22903
22904 argc = PyObject_Length(args);
22905 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22906 argv[ii] = PyTuple_GetItem(args,ii);
22907 }
22908 if (argc == 2) {
22909 int _v;
22910 {
22911 void *ptr;
22912 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22913 _v = 0;
22914 PyErr_Clear();
22915 } else {
22916 _v = 1;
22917 }
22918 }
22919 if (_v) {
22920 {
22921 void *ptr = 0;
22922 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22923 _v = 0;
22924 PyErr_Clear();
22925 } else {
22926 _v = (ptr != 0);
22927 }
22928 }
22929 if (_v) {
22930 return _wrap_DateTime___add____SWIG_0(self,args);
22931 }
22932 }
22933 }
22934 if (argc == 2) {
22935 int _v;
22936 {
22937 void *ptr;
22938 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22939 _v = 0;
22940 PyErr_Clear();
22941 } else {
22942 _v = 1;
22943 }
22944 }
22945 if (_v) {
22946 {
22947 void *ptr = 0;
22948 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22949 _v = 0;
22950 PyErr_Clear();
22951 } else {
22952 _v = (ptr != 0);
22953 }
22954 }
22955 if (_v) {
22956 return _wrap_DateTime___add____SWIG_1(self,args);
22957 }
22958 }
22959 }
22960
22961 Py_INCREF(Py_NotImplemented);
22962 return Py_NotImplemented;
22963 }
22964
22965
22966 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22967 PyObject *resultobj;
22968 wxDateTime *arg1 = (wxDateTime *) 0 ;
22969 wxDateTime *arg2 = 0 ;
22970 wxTimeSpan result;
22971 PyObject * obj0 = 0 ;
22972 PyObject * obj1 = 0 ;
22973
22974 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22976 if (SWIG_arg_fail(1)) SWIG_fail;
22977 {
22978 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22979 if (SWIG_arg_fail(2)) SWIG_fail;
22980 if (arg2 == NULL) {
22981 SWIG_null_ref("wxDateTime");
22982 }
22983 if (SWIG_arg_fail(2)) SWIG_fail;
22984 }
22985 {
22986 PyThreadState* __tstate = wxPyBeginAllowThreads();
22987 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22988
22989 wxPyEndAllowThreads(__tstate);
22990 if (PyErr_Occurred()) SWIG_fail;
22991 }
22992 {
22993 wxTimeSpan * resultptr;
22994 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22995 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22996 }
22997 return resultobj;
22998 fail:
22999 return NULL;
23000 }
23001
23002
23003 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23004 PyObject *resultobj;
23005 wxDateTime *arg1 = (wxDateTime *) 0 ;
23006 wxTimeSpan *arg2 = 0 ;
23007 wxDateTime result;
23008 PyObject * obj0 = 0 ;
23009 PyObject * obj1 = 0 ;
23010
23011 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23013 if (SWIG_arg_fail(1)) SWIG_fail;
23014 {
23015 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23016 if (SWIG_arg_fail(2)) SWIG_fail;
23017 if (arg2 == NULL) {
23018 SWIG_null_ref("wxTimeSpan");
23019 }
23020 if (SWIG_arg_fail(2)) SWIG_fail;
23021 }
23022 {
23023 PyThreadState* __tstate = wxPyBeginAllowThreads();
23024 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23025
23026 wxPyEndAllowThreads(__tstate);
23027 if (PyErr_Occurred()) SWIG_fail;
23028 }
23029 {
23030 wxDateTime * resultptr;
23031 resultptr = new wxDateTime((wxDateTime &)(result));
23032 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23033 }
23034 return resultobj;
23035 fail:
23036 return NULL;
23037 }
23038
23039
23040 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23041 PyObject *resultobj;
23042 wxDateTime *arg1 = (wxDateTime *) 0 ;
23043 wxDateSpan *arg2 = 0 ;
23044 wxDateTime result;
23045 PyObject * obj0 = 0 ;
23046 PyObject * obj1 = 0 ;
23047
23048 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23050 if (SWIG_arg_fail(1)) SWIG_fail;
23051 {
23052 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23053 if (SWIG_arg_fail(2)) SWIG_fail;
23054 if (arg2 == NULL) {
23055 SWIG_null_ref("wxDateSpan");
23056 }
23057 if (SWIG_arg_fail(2)) SWIG_fail;
23058 }
23059 {
23060 PyThreadState* __tstate = wxPyBeginAllowThreads();
23061 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23062
23063 wxPyEndAllowThreads(__tstate);
23064 if (PyErr_Occurred()) SWIG_fail;
23065 }
23066 {
23067 wxDateTime * resultptr;
23068 resultptr = new wxDateTime((wxDateTime &)(result));
23069 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23070 }
23071 return resultobj;
23072 fail:
23073 return NULL;
23074 }
23075
23076
23077 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23078 int argc;
23079 PyObject *argv[3];
23080 int ii;
23081
23082 argc = PyObject_Length(args);
23083 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23084 argv[ii] = PyTuple_GetItem(args,ii);
23085 }
23086 if (argc == 2) {
23087 int _v;
23088 {
23089 void *ptr;
23090 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23091 _v = 0;
23092 PyErr_Clear();
23093 } else {
23094 _v = 1;
23095 }
23096 }
23097 if (_v) {
23098 {
23099 void *ptr = 0;
23100 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23101 _v = 0;
23102 PyErr_Clear();
23103 } else {
23104 _v = (ptr != 0);
23105 }
23106 }
23107 if (_v) {
23108 return _wrap_DateTime___sub____SWIG_0(self,args);
23109 }
23110 }
23111 }
23112 if (argc == 2) {
23113 int _v;
23114 {
23115 void *ptr;
23116 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23117 _v = 0;
23118 PyErr_Clear();
23119 } else {
23120 _v = 1;
23121 }
23122 }
23123 if (_v) {
23124 {
23125 void *ptr = 0;
23126 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23127 _v = 0;
23128 PyErr_Clear();
23129 } else {
23130 _v = (ptr != 0);
23131 }
23132 }
23133 if (_v) {
23134 return _wrap_DateTime___sub____SWIG_1(self,args);
23135 }
23136 }
23137 }
23138 if (argc == 2) {
23139 int _v;
23140 {
23141 void *ptr;
23142 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23143 _v = 0;
23144 PyErr_Clear();
23145 } else {
23146 _v = 1;
23147 }
23148 }
23149 if (_v) {
23150 {
23151 void *ptr = 0;
23152 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23153 _v = 0;
23154 PyErr_Clear();
23155 } else {
23156 _v = (ptr != 0);
23157 }
23158 }
23159 if (_v) {
23160 return _wrap_DateTime___sub____SWIG_2(self,args);
23161 }
23162 }
23163 }
23164
23165 Py_INCREF(Py_NotImplemented);
23166 return Py_NotImplemented;
23167 }
23168
23169
23170 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23171 PyObject *resultobj;
23172 wxDateTime *arg1 = (wxDateTime *) 0 ;
23173 wxDateTime *arg2 = (wxDateTime *) 0 ;
23174 bool result;
23175 PyObject * obj0 = 0 ;
23176 PyObject * obj1 = 0 ;
23177 char *kwnames[] = {
23178 (char *) "self",(char *) "other", NULL
23179 };
23180
23181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23183 if (SWIG_arg_fail(1)) SWIG_fail;
23184 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23185 if (SWIG_arg_fail(2)) SWIG_fail;
23186 {
23187 PyThreadState* __tstate = wxPyBeginAllowThreads();
23188 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23189
23190 wxPyEndAllowThreads(__tstate);
23191 if (PyErr_Occurred()) SWIG_fail;
23192 }
23193 {
23194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23195 }
23196 return resultobj;
23197 fail:
23198 return NULL;
23199 }
23200
23201
23202 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23203 PyObject *resultobj;
23204 wxDateTime *arg1 = (wxDateTime *) 0 ;
23205 wxDateTime *arg2 = (wxDateTime *) 0 ;
23206 bool result;
23207 PyObject * obj0 = 0 ;
23208 PyObject * obj1 = 0 ;
23209 char *kwnames[] = {
23210 (char *) "self",(char *) "other", NULL
23211 };
23212
23213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23215 if (SWIG_arg_fail(1)) SWIG_fail;
23216 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23217 if (SWIG_arg_fail(2)) SWIG_fail;
23218 {
23219 PyThreadState* __tstate = wxPyBeginAllowThreads();
23220 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23221
23222 wxPyEndAllowThreads(__tstate);
23223 if (PyErr_Occurred()) SWIG_fail;
23224 }
23225 {
23226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23227 }
23228 return resultobj;
23229 fail:
23230 return NULL;
23231 }
23232
23233
23234 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23235 PyObject *resultobj;
23236 wxDateTime *arg1 = (wxDateTime *) 0 ;
23237 wxDateTime *arg2 = (wxDateTime *) 0 ;
23238 bool result;
23239 PyObject * obj0 = 0 ;
23240 PyObject * obj1 = 0 ;
23241 char *kwnames[] = {
23242 (char *) "self",(char *) "other", NULL
23243 };
23244
23245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23247 if (SWIG_arg_fail(1)) SWIG_fail;
23248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23249 if (SWIG_arg_fail(2)) SWIG_fail;
23250 {
23251 PyThreadState* __tstate = wxPyBeginAllowThreads();
23252 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23253
23254 wxPyEndAllowThreads(__tstate);
23255 if (PyErr_Occurred()) SWIG_fail;
23256 }
23257 {
23258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23259 }
23260 return resultobj;
23261 fail:
23262 return NULL;
23263 }
23264
23265
23266 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23267 PyObject *resultobj;
23268 wxDateTime *arg1 = (wxDateTime *) 0 ;
23269 wxDateTime *arg2 = (wxDateTime *) 0 ;
23270 bool result;
23271 PyObject * obj0 = 0 ;
23272 PyObject * obj1 = 0 ;
23273 char *kwnames[] = {
23274 (char *) "self",(char *) "other", NULL
23275 };
23276
23277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23279 if (SWIG_arg_fail(1)) SWIG_fail;
23280 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23281 if (SWIG_arg_fail(2)) SWIG_fail;
23282 {
23283 PyThreadState* __tstate = wxPyBeginAllowThreads();
23284 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23285
23286 wxPyEndAllowThreads(__tstate);
23287 if (PyErr_Occurred()) SWIG_fail;
23288 }
23289 {
23290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23291 }
23292 return resultobj;
23293 fail:
23294 return NULL;
23295 }
23296
23297
23298 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23299 PyObject *resultobj;
23300 wxDateTime *arg1 = (wxDateTime *) 0 ;
23301 wxDateTime *arg2 = (wxDateTime *) 0 ;
23302 bool result;
23303 PyObject * obj0 = 0 ;
23304 PyObject * obj1 = 0 ;
23305 char *kwnames[] = {
23306 (char *) "self",(char *) "other", NULL
23307 };
23308
23309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23311 if (SWIG_arg_fail(1)) SWIG_fail;
23312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23313 if (SWIG_arg_fail(2)) SWIG_fail;
23314 {
23315 PyThreadState* __tstate = wxPyBeginAllowThreads();
23316 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23317
23318 wxPyEndAllowThreads(__tstate);
23319 if (PyErr_Occurred()) SWIG_fail;
23320 }
23321 {
23322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23323 }
23324 return resultobj;
23325 fail:
23326 return NULL;
23327 }
23328
23329
23330 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23331 PyObject *resultobj;
23332 wxDateTime *arg1 = (wxDateTime *) 0 ;
23333 wxDateTime *arg2 = (wxDateTime *) 0 ;
23334 bool result;
23335 PyObject * obj0 = 0 ;
23336 PyObject * obj1 = 0 ;
23337 char *kwnames[] = {
23338 (char *) "self",(char *) "other", NULL
23339 };
23340
23341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23343 if (SWIG_arg_fail(1)) SWIG_fail;
23344 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23345 if (SWIG_arg_fail(2)) SWIG_fail;
23346 {
23347 PyThreadState* __tstate = wxPyBeginAllowThreads();
23348 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23349
23350 wxPyEndAllowThreads(__tstate);
23351 if (PyErr_Occurred()) SWIG_fail;
23352 }
23353 {
23354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23355 }
23356 return resultobj;
23357 fail:
23358 return NULL;
23359 }
23360
23361
23362 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23363 PyObject *resultobj;
23364 wxDateTime *arg1 = (wxDateTime *) 0 ;
23365 wxString *arg2 = 0 ;
23366 int result;
23367 bool temp2 = false ;
23368 PyObject * obj0 = 0 ;
23369 PyObject * obj1 = 0 ;
23370 char *kwnames[] = {
23371 (char *) "self",(char *) "date", NULL
23372 };
23373
23374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23376 if (SWIG_arg_fail(1)) SWIG_fail;
23377 {
23378 arg2 = wxString_in_helper(obj1);
23379 if (arg2 == NULL) SWIG_fail;
23380 temp2 = true;
23381 }
23382 {
23383 PyThreadState* __tstate = wxPyBeginAllowThreads();
23384 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23385
23386 wxPyEndAllowThreads(__tstate);
23387 if (PyErr_Occurred()) SWIG_fail;
23388 }
23389 {
23390 resultobj = SWIG_From_int((int)(result));
23391 }
23392 {
23393 if (temp2)
23394 delete arg2;
23395 }
23396 return resultobj;
23397 fail:
23398 {
23399 if (temp2)
23400 delete arg2;
23401 }
23402 return NULL;
23403 }
23404
23405
23406 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23407 PyObject *resultobj;
23408 wxDateTime *arg1 = (wxDateTime *) 0 ;
23409 wxString *arg2 = 0 ;
23410 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23411 wxString *arg3 = (wxString *) &arg3_defvalue ;
23412 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23413 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23414 int result;
23415 bool temp2 = false ;
23416 bool temp3 = false ;
23417 PyObject * obj0 = 0 ;
23418 PyObject * obj1 = 0 ;
23419 PyObject * obj2 = 0 ;
23420 PyObject * obj3 = 0 ;
23421 char *kwnames[] = {
23422 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23423 };
23424
23425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23427 if (SWIG_arg_fail(1)) SWIG_fail;
23428 {
23429 arg2 = wxString_in_helper(obj1);
23430 if (arg2 == NULL) SWIG_fail;
23431 temp2 = true;
23432 }
23433 if (obj2) {
23434 {
23435 arg3 = wxString_in_helper(obj2);
23436 if (arg3 == NULL) SWIG_fail;
23437 temp3 = true;
23438 }
23439 }
23440 if (obj3) {
23441 {
23442 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23443 if (SWIG_arg_fail(4)) SWIG_fail;
23444 if (arg4 == NULL) {
23445 SWIG_null_ref("wxDateTime");
23446 }
23447 if (SWIG_arg_fail(4)) SWIG_fail;
23448 }
23449 }
23450 {
23451 PyThreadState* __tstate = wxPyBeginAllowThreads();
23452 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23453
23454 wxPyEndAllowThreads(__tstate);
23455 if (PyErr_Occurred()) SWIG_fail;
23456 }
23457 {
23458 resultobj = SWIG_From_int((int)(result));
23459 }
23460 {
23461 if (temp2)
23462 delete arg2;
23463 }
23464 {
23465 if (temp3)
23466 delete arg3;
23467 }
23468 return resultobj;
23469 fail:
23470 {
23471 if (temp2)
23472 delete arg2;
23473 }
23474 {
23475 if (temp3)
23476 delete arg3;
23477 }
23478 return NULL;
23479 }
23480
23481
23482 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23483 PyObject *resultobj;
23484 wxDateTime *arg1 = (wxDateTime *) 0 ;
23485 wxString *arg2 = 0 ;
23486 int result;
23487 bool temp2 = false ;
23488 PyObject * obj0 = 0 ;
23489 PyObject * obj1 = 0 ;
23490 char *kwnames[] = {
23491 (char *) "self",(char *) "datetime", NULL
23492 };
23493
23494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23496 if (SWIG_arg_fail(1)) SWIG_fail;
23497 {
23498 arg2 = wxString_in_helper(obj1);
23499 if (arg2 == NULL) SWIG_fail;
23500 temp2 = true;
23501 }
23502 {
23503 PyThreadState* __tstate = wxPyBeginAllowThreads();
23504 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23505
23506 wxPyEndAllowThreads(__tstate);
23507 if (PyErr_Occurred()) SWIG_fail;
23508 }
23509 {
23510 resultobj = SWIG_From_int((int)(result));
23511 }
23512 {
23513 if (temp2)
23514 delete arg2;
23515 }
23516 return resultobj;
23517 fail:
23518 {
23519 if (temp2)
23520 delete arg2;
23521 }
23522 return NULL;
23523 }
23524
23525
23526 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23527 PyObject *resultobj;
23528 wxDateTime *arg1 = (wxDateTime *) 0 ;
23529 wxString *arg2 = 0 ;
23530 int result;
23531 bool temp2 = false ;
23532 PyObject * obj0 = 0 ;
23533 PyObject * obj1 = 0 ;
23534 char *kwnames[] = {
23535 (char *) "self",(char *) "date", NULL
23536 };
23537
23538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23540 if (SWIG_arg_fail(1)) SWIG_fail;
23541 {
23542 arg2 = wxString_in_helper(obj1);
23543 if (arg2 == NULL) SWIG_fail;
23544 temp2 = true;
23545 }
23546 {
23547 PyThreadState* __tstate = wxPyBeginAllowThreads();
23548 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23549
23550 wxPyEndAllowThreads(__tstate);
23551 if (PyErr_Occurred()) SWIG_fail;
23552 }
23553 {
23554 resultobj = SWIG_From_int((int)(result));
23555 }
23556 {
23557 if (temp2)
23558 delete arg2;
23559 }
23560 return resultobj;
23561 fail:
23562 {
23563 if (temp2)
23564 delete arg2;
23565 }
23566 return NULL;
23567 }
23568
23569
23570 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23571 PyObject *resultobj;
23572 wxDateTime *arg1 = (wxDateTime *) 0 ;
23573 wxString *arg2 = 0 ;
23574 int result;
23575 bool temp2 = false ;
23576 PyObject * obj0 = 0 ;
23577 PyObject * obj1 = 0 ;
23578 char *kwnames[] = {
23579 (char *) "self",(char *) "time", NULL
23580 };
23581
23582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23584 if (SWIG_arg_fail(1)) SWIG_fail;
23585 {
23586 arg2 = wxString_in_helper(obj1);
23587 if (arg2 == NULL) SWIG_fail;
23588 temp2 = true;
23589 }
23590 {
23591 PyThreadState* __tstate = wxPyBeginAllowThreads();
23592 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23593
23594 wxPyEndAllowThreads(__tstate);
23595 if (PyErr_Occurred()) SWIG_fail;
23596 }
23597 {
23598 resultobj = SWIG_From_int((int)(result));
23599 }
23600 {
23601 if (temp2)
23602 delete arg2;
23603 }
23604 return resultobj;
23605 fail:
23606 {
23607 if (temp2)
23608 delete arg2;
23609 }
23610 return NULL;
23611 }
23612
23613
23614 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23615 PyObject *resultobj;
23616 wxDateTime *arg1 = (wxDateTime *) 0 ;
23617 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23618 wxString *arg2 = (wxString *) &arg2_defvalue ;
23619 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23620 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23621 wxString result;
23622 bool temp2 = false ;
23623 bool temp3 = false ;
23624 PyObject * obj0 = 0 ;
23625 PyObject * obj1 = 0 ;
23626 PyObject * obj2 = 0 ;
23627 char *kwnames[] = {
23628 (char *) "self",(char *) "format",(char *) "tz", NULL
23629 };
23630
23631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23633 if (SWIG_arg_fail(1)) SWIG_fail;
23634 if (obj1) {
23635 {
23636 arg2 = wxString_in_helper(obj1);
23637 if (arg2 == NULL) SWIG_fail;
23638 temp2 = true;
23639 }
23640 }
23641 if (obj2) {
23642 {
23643 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23644 temp3 = true;
23645 }
23646 }
23647 {
23648 PyThreadState* __tstate = wxPyBeginAllowThreads();
23649 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23650
23651 wxPyEndAllowThreads(__tstate);
23652 if (PyErr_Occurred()) SWIG_fail;
23653 }
23654 {
23655 #if wxUSE_UNICODE
23656 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23657 #else
23658 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23659 #endif
23660 }
23661 {
23662 if (temp2)
23663 delete arg2;
23664 }
23665 {
23666 if (temp3) delete arg3;
23667 }
23668 return resultobj;
23669 fail:
23670 {
23671 if (temp2)
23672 delete arg2;
23673 }
23674 {
23675 if (temp3) delete arg3;
23676 }
23677 return NULL;
23678 }
23679
23680
23681 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23682 PyObject *resultobj;
23683 wxDateTime *arg1 = (wxDateTime *) 0 ;
23684 wxString result;
23685 PyObject * obj0 = 0 ;
23686 char *kwnames[] = {
23687 (char *) "self", NULL
23688 };
23689
23690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23692 if (SWIG_arg_fail(1)) SWIG_fail;
23693 {
23694 PyThreadState* __tstate = wxPyBeginAllowThreads();
23695 result = ((wxDateTime const *)arg1)->FormatDate();
23696
23697 wxPyEndAllowThreads(__tstate);
23698 if (PyErr_Occurred()) SWIG_fail;
23699 }
23700 {
23701 #if wxUSE_UNICODE
23702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23703 #else
23704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23705 #endif
23706 }
23707 return resultobj;
23708 fail:
23709 return NULL;
23710 }
23711
23712
23713 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23714 PyObject *resultobj;
23715 wxDateTime *arg1 = (wxDateTime *) 0 ;
23716 wxString result;
23717 PyObject * obj0 = 0 ;
23718 char *kwnames[] = {
23719 (char *) "self", NULL
23720 };
23721
23722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23724 if (SWIG_arg_fail(1)) SWIG_fail;
23725 {
23726 PyThreadState* __tstate = wxPyBeginAllowThreads();
23727 result = ((wxDateTime const *)arg1)->FormatTime();
23728
23729 wxPyEndAllowThreads(__tstate);
23730 if (PyErr_Occurred()) SWIG_fail;
23731 }
23732 {
23733 #if wxUSE_UNICODE
23734 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23735 #else
23736 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23737 #endif
23738 }
23739 return resultobj;
23740 fail:
23741 return NULL;
23742 }
23743
23744
23745 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23746 PyObject *resultobj;
23747 wxDateTime *arg1 = (wxDateTime *) 0 ;
23748 wxString result;
23749 PyObject * obj0 = 0 ;
23750 char *kwnames[] = {
23751 (char *) "self", NULL
23752 };
23753
23754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23756 if (SWIG_arg_fail(1)) SWIG_fail;
23757 {
23758 PyThreadState* __tstate = wxPyBeginAllowThreads();
23759 result = ((wxDateTime const *)arg1)->FormatISODate();
23760
23761 wxPyEndAllowThreads(__tstate);
23762 if (PyErr_Occurred()) SWIG_fail;
23763 }
23764 {
23765 #if wxUSE_UNICODE
23766 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23767 #else
23768 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23769 #endif
23770 }
23771 return resultobj;
23772 fail:
23773 return NULL;
23774 }
23775
23776
23777 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23778 PyObject *resultobj;
23779 wxDateTime *arg1 = (wxDateTime *) 0 ;
23780 wxString result;
23781 PyObject * obj0 = 0 ;
23782 char *kwnames[] = {
23783 (char *) "self", NULL
23784 };
23785
23786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23788 if (SWIG_arg_fail(1)) SWIG_fail;
23789 {
23790 PyThreadState* __tstate = wxPyBeginAllowThreads();
23791 result = ((wxDateTime const *)arg1)->FormatISOTime();
23792
23793 wxPyEndAllowThreads(__tstate);
23794 if (PyErr_Occurred()) SWIG_fail;
23795 }
23796 {
23797 #if wxUSE_UNICODE
23798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23799 #else
23800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23801 #endif
23802 }
23803 return resultobj;
23804 fail:
23805 return NULL;
23806 }
23807
23808
23809 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23810 PyObject *obj;
23811 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23812 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23813 Py_INCREF(obj);
23814 return Py_BuildValue((char *)"");
23815 }
23816 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23817 PyObject *resultobj;
23818 long arg1 ;
23819 wxTimeSpan result;
23820 PyObject * obj0 = 0 ;
23821 char *kwnames[] = {
23822 (char *) "sec", NULL
23823 };
23824
23825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23826 {
23827 arg1 = (long)(SWIG_As_long(obj0));
23828 if (SWIG_arg_fail(1)) SWIG_fail;
23829 }
23830 {
23831 PyThreadState* __tstate = wxPyBeginAllowThreads();
23832 result = wxTimeSpan::Seconds(arg1);
23833
23834 wxPyEndAllowThreads(__tstate);
23835 if (PyErr_Occurred()) SWIG_fail;
23836 }
23837 {
23838 wxTimeSpan * resultptr;
23839 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23840 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23841 }
23842 return resultobj;
23843 fail:
23844 return NULL;
23845 }
23846
23847
23848 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23849 PyObject *resultobj;
23850 wxTimeSpan result;
23851 char *kwnames[] = {
23852 NULL
23853 };
23854
23855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23856 {
23857 PyThreadState* __tstate = wxPyBeginAllowThreads();
23858 result = wxTimeSpan::Second();
23859
23860 wxPyEndAllowThreads(__tstate);
23861 if (PyErr_Occurred()) SWIG_fail;
23862 }
23863 {
23864 wxTimeSpan * resultptr;
23865 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23867 }
23868 return resultobj;
23869 fail:
23870 return NULL;
23871 }
23872
23873
23874 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23875 PyObject *resultobj;
23876 long arg1 ;
23877 wxTimeSpan result;
23878 PyObject * obj0 = 0 ;
23879 char *kwnames[] = {
23880 (char *) "min", NULL
23881 };
23882
23883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23884 {
23885 arg1 = (long)(SWIG_As_long(obj0));
23886 if (SWIG_arg_fail(1)) SWIG_fail;
23887 }
23888 {
23889 PyThreadState* __tstate = wxPyBeginAllowThreads();
23890 result = wxTimeSpan::Minutes(arg1);
23891
23892 wxPyEndAllowThreads(__tstate);
23893 if (PyErr_Occurred()) SWIG_fail;
23894 }
23895 {
23896 wxTimeSpan * resultptr;
23897 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23898 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23899 }
23900 return resultobj;
23901 fail:
23902 return NULL;
23903 }
23904
23905
23906 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23907 PyObject *resultobj;
23908 wxTimeSpan result;
23909 char *kwnames[] = {
23910 NULL
23911 };
23912
23913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23914 {
23915 PyThreadState* __tstate = wxPyBeginAllowThreads();
23916 result = wxTimeSpan::Minute();
23917
23918 wxPyEndAllowThreads(__tstate);
23919 if (PyErr_Occurred()) SWIG_fail;
23920 }
23921 {
23922 wxTimeSpan * resultptr;
23923 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23924 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23925 }
23926 return resultobj;
23927 fail:
23928 return NULL;
23929 }
23930
23931
23932 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23933 PyObject *resultobj;
23934 long arg1 ;
23935 wxTimeSpan result;
23936 PyObject * obj0 = 0 ;
23937 char *kwnames[] = {
23938 (char *) "hours", NULL
23939 };
23940
23941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23942 {
23943 arg1 = (long)(SWIG_As_long(obj0));
23944 if (SWIG_arg_fail(1)) SWIG_fail;
23945 }
23946 {
23947 PyThreadState* __tstate = wxPyBeginAllowThreads();
23948 result = wxTimeSpan::Hours(arg1);
23949
23950 wxPyEndAllowThreads(__tstate);
23951 if (PyErr_Occurred()) SWIG_fail;
23952 }
23953 {
23954 wxTimeSpan * resultptr;
23955 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23956 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23957 }
23958 return resultobj;
23959 fail:
23960 return NULL;
23961 }
23962
23963
23964 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23965 PyObject *resultobj;
23966 wxTimeSpan result;
23967 char *kwnames[] = {
23968 NULL
23969 };
23970
23971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23972 {
23973 PyThreadState* __tstate = wxPyBeginAllowThreads();
23974 result = wxTimeSpan::Hour();
23975
23976 wxPyEndAllowThreads(__tstate);
23977 if (PyErr_Occurred()) SWIG_fail;
23978 }
23979 {
23980 wxTimeSpan * resultptr;
23981 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23982 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23983 }
23984 return resultobj;
23985 fail:
23986 return NULL;
23987 }
23988
23989
23990 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23991 PyObject *resultobj;
23992 long arg1 ;
23993 wxTimeSpan result;
23994 PyObject * obj0 = 0 ;
23995 char *kwnames[] = {
23996 (char *) "days", NULL
23997 };
23998
23999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24000 {
24001 arg1 = (long)(SWIG_As_long(obj0));
24002 if (SWIG_arg_fail(1)) SWIG_fail;
24003 }
24004 {
24005 PyThreadState* __tstate = wxPyBeginAllowThreads();
24006 result = wxTimeSpan::Days(arg1);
24007
24008 wxPyEndAllowThreads(__tstate);
24009 if (PyErr_Occurred()) SWIG_fail;
24010 }
24011 {
24012 wxTimeSpan * resultptr;
24013 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24014 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24015 }
24016 return resultobj;
24017 fail:
24018 return NULL;
24019 }
24020
24021
24022 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24023 PyObject *resultobj;
24024 wxTimeSpan result;
24025 char *kwnames[] = {
24026 NULL
24027 };
24028
24029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24030 {
24031 PyThreadState* __tstate = wxPyBeginAllowThreads();
24032 result = wxTimeSpan::Day();
24033
24034 wxPyEndAllowThreads(__tstate);
24035 if (PyErr_Occurred()) SWIG_fail;
24036 }
24037 {
24038 wxTimeSpan * resultptr;
24039 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24040 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24041 }
24042 return resultobj;
24043 fail:
24044 return NULL;
24045 }
24046
24047
24048 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24049 PyObject *resultobj;
24050 long arg1 ;
24051 wxTimeSpan result;
24052 PyObject * obj0 = 0 ;
24053 char *kwnames[] = {
24054 (char *) "days", NULL
24055 };
24056
24057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24058 {
24059 arg1 = (long)(SWIG_As_long(obj0));
24060 if (SWIG_arg_fail(1)) SWIG_fail;
24061 }
24062 {
24063 PyThreadState* __tstate = wxPyBeginAllowThreads();
24064 result = wxTimeSpan::Weeks(arg1);
24065
24066 wxPyEndAllowThreads(__tstate);
24067 if (PyErr_Occurred()) SWIG_fail;
24068 }
24069 {
24070 wxTimeSpan * resultptr;
24071 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24072 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24073 }
24074 return resultobj;
24075 fail:
24076 return NULL;
24077 }
24078
24079
24080 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24081 PyObject *resultobj;
24082 wxTimeSpan result;
24083 char *kwnames[] = {
24084 NULL
24085 };
24086
24087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24088 {
24089 PyThreadState* __tstate = wxPyBeginAllowThreads();
24090 result = wxTimeSpan::Week();
24091
24092 wxPyEndAllowThreads(__tstate);
24093 if (PyErr_Occurred()) SWIG_fail;
24094 }
24095 {
24096 wxTimeSpan * resultptr;
24097 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24098 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24099 }
24100 return resultobj;
24101 fail:
24102 return NULL;
24103 }
24104
24105
24106 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24107 PyObject *resultobj;
24108 long arg1 = (long) 0 ;
24109 long arg2 = (long) 0 ;
24110 long arg3 = (long) 0 ;
24111 long arg4 = (long) 0 ;
24112 wxTimeSpan *result;
24113 PyObject * obj0 = 0 ;
24114 PyObject * obj1 = 0 ;
24115 PyObject * obj2 = 0 ;
24116 PyObject * obj3 = 0 ;
24117 char *kwnames[] = {
24118 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24119 };
24120
24121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24122 if (obj0) {
24123 {
24124 arg1 = (long)(SWIG_As_long(obj0));
24125 if (SWIG_arg_fail(1)) SWIG_fail;
24126 }
24127 }
24128 if (obj1) {
24129 {
24130 arg2 = (long)(SWIG_As_long(obj1));
24131 if (SWIG_arg_fail(2)) SWIG_fail;
24132 }
24133 }
24134 if (obj2) {
24135 {
24136 arg3 = (long)(SWIG_As_long(obj2));
24137 if (SWIG_arg_fail(3)) SWIG_fail;
24138 }
24139 }
24140 if (obj3) {
24141 {
24142 arg4 = (long)(SWIG_As_long(obj3));
24143 if (SWIG_arg_fail(4)) SWIG_fail;
24144 }
24145 }
24146 {
24147 PyThreadState* __tstate = wxPyBeginAllowThreads();
24148 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24149
24150 wxPyEndAllowThreads(__tstate);
24151 if (PyErr_Occurred()) SWIG_fail;
24152 }
24153 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24154 return resultobj;
24155 fail:
24156 return NULL;
24157 }
24158
24159
24160 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24161 PyObject *resultobj;
24162 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24163 PyObject * obj0 = 0 ;
24164 char *kwnames[] = {
24165 (char *) "self", NULL
24166 };
24167
24168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24170 if (SWIG_arg_fail(1)) SWIG_fail;
24171 {
24172 PyThreadState* __tstate = wxPyBeginAllowThreads();
24173 delete arg1;
24174
24175 wxPyEndAllowThreads(__tstate);
24176 if (PyErr_Occurred()) SWIG_fail;
24177 }
24178 Py_INCREF(Py_None); resultobj = Py_None;
24179 return resultobj;
24180 fail:
24181 return NULL;
24182 }
24183
24184
24185 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24186 PyObject *resultobj;
24187 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24188 wxTimeSpan *arg2 = 0 ;
24189 wxTimeSpan *result;
24190 PyObject * obj0 = 0 ;
24191 PyObject * obj1 = 0 ;
24192 char *kwnames[] = {
24193 (char *) "self",(char *) "diff", NULL
24194 };
24195
24196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24198 if (SWIG_arg_fail(1)) SWIG_fail;
24199 {
24200 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24201 if (SWIG_arg_fail(2)) SWIG_fail;
24202 if (arg2 == NULL) {
24203 SWIG_null_ref("wxTimeSpan");
24204 }
24205 if (SWIG_arg_fail(2)) SWIG_fail;
24206 }
24207 {
24208 PyThreadState* __tstate = wxPyBeginAllowThreads();
24209 {
24210 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24211 result = (wxTimeSpan *) &_result_ref;
24212 }
24213
24214 wxPyEndAllowThreads(__tstate);
24215 if (PyErr_Occurred()) SWIG_fail;
24216 }
24217 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24218 return resultobj;
24219 fail:
24220 return NULL;
24221 }
24222
24223
24224 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24225 PyObject *resultobj;
24226 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24227 wxTimeSpan *arg2 = 0 ;
24228 wxTimeSpan *result;
24229 PyObject * obj0 = 0 ;
24230 PyObject * obj1 = 0 ;
24231 char *kwnames[] = {
24232 (char *) "self",(char *) "diff", NULL
24233 };
24234
24235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24237 if (SWIG_arg_fail(1)) SWIG_fail;
24238 {
24239 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24240 if (SWIG_arg_fail(2)) SWIG_fail;
24241 if (arg2 == NULL) {
24242 SWIG_null_ref("wxTimeSpan");
24243 }
24244 if (SWIG_arg_fail(2)) SWIG_fail;
24245 }
24246 {
24247 PyThreadState* __tstate = wxPyBeginAllowThreads();
24248 {
24249 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24250 result = (wxTimeSpan *) &_result_ref;
24251 }
24252
24253 wxPyEndAllowThreads(__tstate);
24254 if (PyErr_Occurred()) SWIG_fail;
24255 }
24256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24257 return resultobj;
24258 fail:
24259 return NULL;
24260 }
24261
24262
24263 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24264 PyObject *resultobj;
24265 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24266 int arg2 ;
24267 wxTimeSpan *result;
24268 PyObject * obj0 = 0 ;
24269 PyObject * obj1 = 0 ;
24270 char *kwnames[] = {
24271 (char *) "self",(char *) "n", NULL
24272 };
24273
24274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24276 if (SWIG_arg_fail(1)) SWIG_fail;
24277 {
24278 arg2 = (int)(SWIG_As_int(obj1));
24279 if (SWIG_arg_fail(2)) SWIG_fail;
24280 }
24281 {
24282 PyThreadState* __tstate = wxPyBeginAllowThreads();
24283 {
24284 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24285 result = (wxTimeSpan *) &_result_ref;
24286 }
24287
24288 wxPyEndAllowThreads(__tstate);
24289 if (PyErr_Occurred()) SWIG_fail;
24290 }
24291 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24292 return resultobj;
24293 fail:
24294 return NULL;
24295 }
24296
24297
24298 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24299 PyObject *resultobj;
24300 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24301 wxTimeSpan *result;
24302 PyObject * obj0 = 0 ;
24303 char *kwnames[] = {
24304 (char *) "self", NULL
24305 };
24306
24307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24309 if (SWIG_arg_fail(1)) SWIG_fail;
24310 {
24311 PyThreadState* __tstate = wxPyBeginAllowThreads();
24312 {
24313 wxTimeSpan &_result_ref = (arg1)->Neg();
24314 result = (wxTimeSpan *) &_result_ref;
24315 }
24316
24317 wxPyEndAllowThreads(__tstate);
24318 if (PyErr_Occurred()) SWIG_fail;
24319 }
24320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24321 return resultobj;
24322 fail:
24323 return NULL;
24324 }
24325
24326
24327 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24328 PyObject *resultobj;
24329 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24330 wxTimeSpan result;
24331 PyObject * obj0 = 0 ;
24332 char *kwnames[] = {
24333 (char *) "self", NULL
24334 };
24335
24336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24338 if (SWIG_arg_fail(1)) SWIG_fail;
24339 {
24340 PyThreadState* __tstate = wxPyBeginAllowThreads();
24341 result = ((wxTimeSpan const *)arg1)->Abs();
24342
24343 wxPyEndAllowThreads(__tstate);
24344 if (PyErr_Occurred()) SWIG_fail;
24345 }
24346 {
24347 wxTimeSpan * resultptr;
24348 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24349 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24350 }
24351 return resultobj;
24352 fail:
24353 return NULL;
24354 }
24355
24356
24357 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24358 PyObject *resultobj;
24359 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24360 wxTimeSpan *arg2 = 0 ;
24361 wxTimeSpan *result;
24362 PyObject * obj0 = 0 ;
24363 PyObject * obj1 = 0 ;
24364 char *kwnames[] = {
24365 (char *) "self",(char *) "diff", NULL
24366 };
24367
24368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24370 if (SWIG_arg_fail(1)) SWIG_fail;
24371 {
24372 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24373 if (SWIG_arg_fail(2)) SWIG_fail;
24374 if (arg2 == NULL) {
24375 SWIG_null_ref("wxTimeSpan");
24376 }
24377 if (SWIG_arg_fail(2)) SWIG_fail;
24378 }
24379 {
24380 PyThreadState* __tstate = wxPyBeginAllowThreads();
24381 {
24382 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24383 result = (wxTimeSpan *) &_result_ref;
24384 }
24385
24386 wxPyEndAllowThreads(__tstate);
24387 if (PyErr_Occurred()) SWIG_fail;
24388 }
24389 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24390 return resultobj;
24391 fail:
24392 return NULL;
24393 }
24394
24395
24396 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24397 PyObject *resultobj;
24398 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24399 wxTimeSpan *arg2 = 0 ;
24400 wxTimeSpan *result;
24401 PyObject * obj0 = 0 ;
24402 PyObject * obj1 = 0 ;
24403 char *kwnames[] = {
24404 (char *) "self",(char *) "diff", NULL
24405 };
24406
24407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24409 if (SWIG_arg_fail(1)) SWIG_fail;
24410 {
24411 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24412 if (SWIG_arg_fail(2)) SWIG_fail;
24413 if (arg2 == NULL) {
24414 SWIG_null_ref("wxTimeSpan");
24415 }
24416 if (SWIG_arg_fail(2)) SWIG_fail;
24417 }
24418 {
24419 PyThreadState* __tstate = wxPyBeginAllowThreads();
24420 {
24421 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24422 result = (wxTimeSpan *) &_result_ref;
24423 }
24424
24425 wxPyEndAllowThreads(__tstate);
24426 if (PyErr_Occurred()) SWIG_fail;
24427 }
24428 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24429 return resultobj;
24430 fail:
24431 return NULL;
24432 }
24433
24434
24435 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24436 PyObject *resultobj;
24437 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24438 int arg2 ;
24439 wxTimeSpan *result;
24440 PyObject * obj0 = 0 ;
24441 PyObject * obj1 = 0 ;
24442 char *kwnames[] = {
24443 (char *) "self",(char *) "n", NULL
24444 };
24445
24446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24448 if (SWIG_arg_fail(1)) SWIG_fail;
24449 {
24450 arg2 = (int)(SWIG_As_int(obj1));
24451 if (SWIG_arg_fail(2)) SWIG_fail;
24452 }
24453 {
24454 PyThreadState* __tstate = wxPyBeginAllowThreads();
24455 {
24456 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24457 result = (wxTimeSpan *) &_result_ref;
24458 }
24459
24460 wxPyEndAllowThreads(__tstate);
24461 if (PyErr_Occurred()) SWIG_fail;
24462 }
24463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24464 return resultobj;
24465 fail:
24466 return NULL;
24467 }
24468
24469
24470 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24471 PyObject *resultobj;
24472 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24473 wxTimeSpan *result;
24474 PyObject * obj0 = 0 ;
24475 char *kwnames[] = {
24476 (char *) "self", NULL
24477 };
24478
24479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24481 if (SWIG_arg_fail(1)) SWIG_fail;
24482 {
24483 PyThreadState* __tstate = wxPyBeginAllowThreads();
24484 {
24485 wxTimeSpan &_result_ref = (arg1)->operator -();
24486 result = (wxTimeSpan *) &_result_ref;
24487 }
24488
24489 wxPyEndAllowThreads(__tstate);
24490 if (PyErr_Occurred()) SWIG_fail;
24491 }
24492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24493 return resultobj;
24494 fail:
24495 return NULL;
24496 }
24497
24498
24499 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24500 PyObject *resultobj;
24501 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24502 wxTimeSpan *arg2 = 0 ;
24503 wxTimeSpan result;
24504 PyObject * obj0 = 0 ;
24505 PyObject * obj1 = 0 ;
24506 char *kwnames[] = {
24507 (char *) "self",(char *) "other", NULL
24508 };
24509
24510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24512 if (SWIG_arg_fail(1)) SWIG_fail;
24513 {
24514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24515 if (SWIG_arg_fail(2)) SWIG_fail;
24516 if (arg2 == NULL) {
24517 SWIG_null_ref("wxTimeSpan");
24518 }
24519 if (SWIG_arg_fail(2)) SWIG_fail;
24520 }
24521 {
24522 PyThreadState* __tstate = wxPyBeginAllowThreads();
24523 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24524
24525 wxPyEndAllowThreads(__tstate);
24526 if (PyErr_Occurred()) SWIG_fail;
24527 }
24528 {
24529 wxTimeSpan * resultptr;
24530 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24531 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24532 }
24533 return resultobj;
24534 fail:
24535 return NULL;
24536 }
24537
24538
24539 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24540 PyObject *resultobj;
24541 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24542 wxTimeSpan *arg2 = 0 ;
24543 wxTimeSpan result;
24544 PyObject * obj0 = 0 ;
24545 PyObject * obj1 = 0 ;
24546 char *kwnames[] = {
24547 (char *) "self",(char *) "other", NULL
24548 };
24549
24550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24552 if (SWIG_arg_fail(1)) SWIG_fail;
24553 {
24554 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24555 if (SWIG_arg_fail(2)) SWIG_fail;
24556 if (arg2 == NULL) {
24557 SWIG_null_ref("wxTimeSpan");
24558 }
24559 if (SWIG_arg_fail(2)) SWIG_fail;
24560 }
24561 {
24562 PyThreadState* __tstate = wxPyBeginAllowThreads();
24563 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24564
24565 wxPyEndAllowThreads(__tstate);
24566 if (PyErr_Occurred()) SWIG_fail;
24567 }
24568 {
24569 wxTimeSpan * resultptr;
24570 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24571 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24572 }
24573 return resultobj;
24574 fail:
24575 return NULL;
24576 }
24577
24578
24579 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24580 PyObject *resultobj;
24581 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24582 int arg2 ;
24583 wxTimeSpan result;
24584 PyObject * obj0 = 0 ;
24585 PyObject * obj1 = 0 ;
24586 char *kwnames[] = {
24587 (char *) "self",(char *) "n", NULL
24588 };
24589
24590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24592 if (SWIG_arg_fail(1)) SWIG_fail;
24593 {
24594 arg2 = (int)(SWIG_As_int(obj1));
24595 if (SWIG_arg_fail(2)) SWIG_fail;
24596 }
24597 {
24598 PyThreadState* __tstate = wxPyBeginAllowThreads();
24599 result = wxTimeSpan___mul__(arg1,arg2);
24600
24601 wxPyEndAllowThreads(__tstate);
24602 if (PyErr_Occurred()) SWIG_fail;
24603 }
24604 {
24605 wxTimeSpan * resultptr;
24606 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24607 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24608 }
24609 return resultobj;
24610 fail:
24611 return NULL;
24612 }
24613
24614
24615 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24616 PyObject *resultobj;
24617 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24618 int arg2 ;
24619 wxTimeSpan result;
24620 PyObject * obj0 = 0 ;
24621 PyObject * obj1 = 0 ;
24622 char *kwnames[] = {
24623 (char *) "self",(char *) "n", NULL
24624 };
24625
24626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24628 if (SWIG_arg_fail(1)) SWIG_fail;
24629 {
24630 arg2 = (int)(SWIG_As_int(obj1));
24631 if (SWIG_arg_fail(2)) SWIG_fail;
24632 }
24633 {
24634 PyThreadState* __tstate = wxPyBeginAllowThreads();
24635 result = wxTimeSpan___rmul__(arg1,arg2);
24636
24637 wxPyEndAllowThreads(__tstate);
24638 if (PyErr_Occurred()) SWIG_fail;
24639 }
24640 {
24641 wxTimeSpan * resultptr;
24642 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24643 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24644 }
24645 return resultobj;
24646 fail:
24647 return NULL;
24648 }
24649
24650
24651 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24652 PyObject *resultobj;
24653 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24654 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24655 bool result;
24656 PyObject * obj0 = 0 ;
24657 PyObject * obj1 = 0 ;
24658 char *kwnames[] = {
24659 (char *) "self",(char *) "other", NULL
24660 };
24661
24662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24664 if (SWIG_arg_fail(1)) SWIG_fail;
24665 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24666 if (SWIG_arg_fail(2)) SWIG_fail;
24667 {
24668 PyThreadState* __tstate = wxPyBeginAllowThreads();
24669 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24670
24671 wxPyEndAllowThreads(__tstate);
24672 if (PyErr_Occurred()) SWIG_fail;
24673 }
24674 {
24675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24676 }
24677 return resultobj;
24678 fail:
24679 return NULL;
24680 }
24681
24682
24683 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24684 PyObject *resultobj;
24685 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24686 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24687 bool result;
24688 PyObject * obj0 = 0 ;
24689 PyObject * obj1 = 0 ;
24690 char *kwnames[] = {
24691 (char *) "self",(char *) "other", NULL
24692 };
24693
24694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24696 if (SWIG_arg_fail(1)) SWIG_fail;
24697 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24698 if (SWIG_arg_fail(2)) SWIG_fail;
24699 {
24700 PyThreadState* __tstate = wxPyBeginAllowThreads();
24701 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24702
24703 wxPyEndAllowThreads(__tstate);
24704 if (PyErr_Occurred()) SWIG_fail;
24705 }
24706 {
24707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24708 }
24709 return resultobj;
24710 fail:
24711 return NULL;
24712 }
24713
24714
24715 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24716 PyObject *resultobj;
24717 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24718 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24719 bool result;
24720 PyObject * obj0 = 0 ;
24721 PyObject * obj1 = 0 ;
24722 char *kwnames[] = {
24723 (char *) "self",(char *) "other", NULL
24724 };
24725
24726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24728 if (SWIG_arg_fail(1)) SWIG_fail;
24729 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24730 if (SWIG_arg_fail(2)) SWIG_fail;
24731 {
24732 PyThreadState* __tstate = wxPyBeginAllowThreads();
24733 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24734
24735 wxPyEndAllowThreads(__tstate);
24736 if (PyErr_Occurred()) SWIG_fail;
24737 }
24738 {
24739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24740 }
24741 return resultobj;
24742 fail:
24743 return NULL;
24744 }
24745
24746
24747 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24748 PyObject *resultobj;
24749 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24750 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24751 bool result;
24752 PyObject * obj0 = 0 ;
24753 PyObject * obj1 = 0 ;
24754 char *kwnames[] = {
24755 (char *) "self",(char *) "other", NULL
24756 };
24757
24758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24760 if (SWIG_arg_fail(1)) SWIG_fail;
24761 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24762 if (SWIG_arg_fail(2)) SWIG_fail;
24763 {
24764 PyThreadState* __tstate = wxPyBeginAllowThreads();
24765 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24766
24767 wxPyEndAllowThreads(__tstate);
24768 if (PyErr_Occurred()) SWIG_fail;
24769 }
24770 {
24771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24772 }
24773 return resultobj;
24774 fail:
24775 return NULL;
24776 }
24777
24778
24779 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24780 PyObject *resultobj;
24781 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24782 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24783 bool result;
24784 PyObject * obj0 = 0 ;
24785 PyObject * obj1 = 0 ;
24786 char *kwnames[] = {
24787 (char *) "self",(char *) "other", NULL
24788 };
24789
24790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24792 if (SWIG_arg_fail(1)) SWIG_fail;
24793 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24794 if (SWIG_arg_fail(2)) SWIG_fail;
24795 {
24796 PyThreadState* __tstate = wxPyBeginAllowThreads();
24797 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24798
24799 wxPyEndAllowThreads(__tstate);
24800 if (PyErr_Occurred()) SWIG_fail;
24801 }
24802 {
24803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24804 }
24805 return resultobj;
24806 fail:
24807 return NULL;
24808 }
24809
24810
24811 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24812 PyObject *resultobj;
24813 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24814 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24815 bool result;
24816 PyObject * obj0 = 0 ;
24817 PyObject * obj1 = 0 ;
24818 char *kwnames[] = {
24819 (char *) "self",(char *) "other", NULL
24820 };
24821
24822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24824 if (SWIG_arg_fail(1)) SWIG_fail;
24825 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24826 if (SWIG_arg_fail(2)) SWIG_fail;
24827 {
24828 PyThreadState* __tstate = wxPyBeginAllowThreads();
24829 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24830
24831 wxPyEndAllowThreads(__tstate);
24832 if (PyErr_Occurred()) SWIG_fail;
24833 }
24834 {
24835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24836 }
24837 return resultobj;
24838 fail:
24839 return NULL;
24840 }
24841
24842
24843 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24844 PyObject *resultobj;
24845 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24846 bool result;
24847 PyObject * obj0 = 0 ;
24848 char *kwnames[] = {
24849 (char *) "self", NULL
24850 };
24851
24852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24854 if (SWIG_arg_fail(1)) SWIG_fail;
24855 {
24856 PyThreadState* __tstate = wxPyBeginAllowThreads();
24857 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24858
24859 wxPyEndAllowThreads(__tstate);
24860 if (PyErr_Occurred()) SWIG_fail;
24861 }
24862 {
24863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24864 }
24865 return resultobj;
24866 fail:
24867 return NULL;
24868 }
24869
24870
24871 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24872 PyObject *resultobj;
24873 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24874 bool result;
24875 PyObject * obj0 = 0 ;
24876 char *kwnames[] = {
24877 (char *) "self", NULL
24878 };
24879
24880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24882 if (SWIG_arg_fail(1)) SWIG_fail;
24883 {
24884 PyThreadState* __tstate = wxPyBeginAllowThreads();
24885 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24886
24887 wxPyEndAllowThreads(__tstate);
24888 if (PyErr_Occurred()) SWIG_fail;
24889 }
24890 {
24891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24892 }
24893 return resultobj;
24894 fail:
24895 return NULL;
24896 }
24897
24898
24899 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24900 PyObject *resultobj;
24901 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24902 bool result;
24903 PyObject * obj0 = 0 ;
24904 char *kwnames[] = {
24905 (char *) "self", NULL
24906 };
24907
24908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24910 if (SWIG_arg_fail(1)) SWIG_fail;
24911 {
24912 PyThreadState* __tstate = wxPyBeginAllowThreads();
24913 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24914
24915 wxPyEndAllowThreads(__tstate);
24916 if (PyErr_Occurred()) SWIG_fail;
24917 }
24918 {
24919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24920 }
24921 return resultobj;
24922 fail:
24923 return NULL;
24924 }
24925
24926
24927 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24928 PyObject *resultobj;
24929 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24930 wxTimeSpan *arg2 = 0 ;
24931 bool result;
24932 PyObject * obj0 = 0 ;
24933 PyObject * obj1 = 0 ;
24934 char *kwnames[] = {
24935 (char *) "self",(char *) "ts", NULL
24936 };
24937
24938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24940 if (SWIG_arg_fail(1)) SWIG_fail;
24941 {
24942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24943 if (SWIG_arg_fail(2)) SWIG_fail;
24944 if (arg2 == NULL) {
24945 SWIG_null_ref("wxTimeSpan");
24946 }
24947 if (SWIG_arg_fail(2)) SWIG_fail;
24948 }
24949 {
24950 PyThreadState* __tstate = wxPyBeginAllowThreads();
24951 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24952
24953 wxPyEndAllowThreads(__tstate);
24954 if (PyErr_Occurred()) SWIG_fail;
24955 }
24956 {
24957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24958 }
24959 return resultobj;
24960 fail:
24961 return NULL;
24962 }
24963
24964
24965 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24966 PyObject *resultobj;
24967 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24968 wxTimeSpan *arg2 = 0 ;
24969 bool result;
24970 PyObject * obj0 = 0 ;
24971 PyObject * obj1 = 0 ;
24972 char *kwnames[] = {
24973 (char *) "self",(char *) "ts", NULL
24974 };
24975
24976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24978 if (SWIG_arg_fail(1)) SWIG_fail;
24979 {
24980 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24981 if (SWIG_arg_fail(2)) SWIG_fail;
24982 if (arg2 == NULL) {
24983 SWIG_null_ref("wxTimeSpan");
24984 }
24985 if (SWIG_arg_fail(2)) SWIG_fail;
24986 }
24987 {
24988 PyThreadState* __tstate = wxPyBeginAllowThreads();
24989 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24990
24991 wxPyEndAllowThreads(__tstate);
24992 if (PyErr_Occurred()) SWIG_fail;
24993 }
24994 {
24995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24996 }
24997 return resultobj;
24998 fail:
24999 return NULL;
25000 }
25001
25002
25003 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25004 PyObject *resultobj;
25005 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25006 wxTimeSpan *arg2 = 0 ;
25007 bool result;
25008 PyObject * obj0 = 0 ;
25009 PyObject * obj1 = 0 ;
25010 char *kwnames[] = {
25011 (char *) "self",(char *) "t", NULL
25012 };
25013
25014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25016 if (SWIG_arg_fail(1)) SWIG_fail;
25017 {
25018 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25019 if (SWIG_arg_fail(2)) SWIG_fail;
25020 if (arg2 == NULL) {
25021 SWIG_null_ref("wxTimeSpan");
25022 }
25023 if (SWIG_arg_fail(2)) SWIG_fail;
25024 }
25025 {
25026 PyThreadState* __tstate = wxPyBeginAllowThreads();
25027 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25028
25029 wxPyEndAllowThreads(__tstate);
25030 if (PyErr_Occurred()) SWIG_fail;
25031 }
25032 {
25033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25034 }
25035 return resultobj;
25036 fail:
25037 return NULL;
25038 }
25039
25040
25041 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25042 PyObject *resultobj;
25043 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25044 int result;
25045 PyObject * obj0 = 0 ;
25046 char *kwnames[] = {
25047 (char *) "self", NULL
25048 };
25049
25050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25052 if (SWIG_arg_fail(1)) SWIG_fail;
25053 {
25054 PyThreadState* __tstate = wxPyBeginAllowThreads();
25055 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25056
25057 wxPyEndAllowThreads(__tstate);
25058 if (PyErr_Occurred()) SWIG_fail;
25059 }
25060 {
25061 resultobj = SWIG_From_int((int)(result));
25062 }
25063 return resultobj;
25064 fail:
25065 return NULL;
25066 }
25067
25068
25069 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25070 PyObject *resultobj;
25071 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25072 int result;
25073 PyObject * obj0 = 0 ;
25074 char *kwnames[] = {
25075 (char *) "self", NULL
25076 };
25077
25078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25080 if (SWIG_arg_fail(1)) SWIG_fail;
25081 {
25082 PyThreadState* __tstate = wxPyBeginAllowThreads();
25083 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25084
25085 wxPyEndAllowThreads(__tstate);
25086 if (PyErr_Occurred()) SWIG_fail;
25087 }
25088 {
25089 resultobj = SWIG_From_int((int)(result));
25090 }
25091 return resultobj;
25092 fail:
25093 return NULL;
25094 }
25095
25096
25097 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25098 PyObject *resultobj;
25099 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25100 int result;
25101 PyObject * obj0 = 0 ;
25102 char *kwnames[] = {
25103 (char *) "self", NULL
25104 };
25105
25106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25108 if (SWIG_arg_fail(1)) SWIG_fail;
25109 {
25110 PyThreadState* __tstate = wxPyBeginAllowThreads();
25111 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25112
25113 wxPyEndAllowThreads(__tstate);
25114 if (PyErr_Occurred()) SWIG_fail;
25115 }
25116 {
25117 resultobj = SWIG_From_int((int)(result));
25118 }
25119 return resultobj;
25120 fail:
25121 return NULL;
25122 }
25123
25124
25125 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25126 PyObject *resultobj;
25127 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25128 int result;
25129 PyObject * obj0 = 0 ;
25130 char *kwnames[] = {
25131 (char *) "self", NULL
25132 };
25133
25134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25136 if (SWIG_arg_fail(1)) SWIG_fail;
25137 {
25138 PyThreadState* __tstate = wxPyBeginAllowThreads();
25139 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25140
25141 wxPyEndAllowThreads(__tstate);
25142 if (PyErr_Occurred()) SWIG_fail;
25143 }
25144 {
25145 resultobj = SWIG_From_int((int)(result));
25146 }
25147 return resultobj;
25148 fail:
25149 return NULL;
25150 }
25151
25152
25153 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25154 PyObject *resultobj;
25155 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25156 wxLongLong result;
25157 PyObject * obj0 = 0 ;
25158 char *kwnames[] = {
25159 (char *) "self", NULL
25160 };
25161
25162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25164 if (SWIG_arg_fail(1)) SWIG_fail;
25165 {
25166 PyThreadState* __tstate = wxPyBeginAllowThreads();
25167 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25168
25169 wxPyEndAllowThreads(__tstate);
25170 if (PyErr_Occurred()) SWIG_fail;
25171 }
25172 {
25173 PyObject *hi, *lo, *shifter, *shifted;
25174 hi = PyLong_FromLong( (&result)->GetHi() );
25175 lo = PyLong_FromLong( (&result)->GetLo() );
25176 shifter = PyLong_FromLong(32);
25177 shifted = PyNumber_Lshift(hi, shifter);
25178 resultobj = PyNumber_Or(shifted, lo);
25179 Py_DECREF(hi);
25180 Py_DECREF(lo);
25181 Py_DECREF(shifter);
25182 Py_DECREF(shifted);
25183 }
25184 return resultobj;
25185 fail:
25186 return NULL;
25187 }
25188
25189
25190 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25191 PyObject *resultobj;
25192 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25193 wxLongLong result;
25194 PyObject * obj0 = 0 ;
25195 char *kwnames[] = {
25196 (char *) "self", NULL
25197 };
25198
25199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25201 if (SWIG_arg_fail(1)) SWIG_fail;
25202 {
25203 PyThreadState* __tstate = wxPyBeginAllowThreads();
25204 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25205
25206 wxPyEndAllowThreads(__tstate);
25207 if (PyErr_Occurred()) SWIG_fail;
25208 }
25209 {
25210 PyObject *hi, *lo, *shifter, *shifted;
25211 hi = PyLong_FromLong( (&result)->GetHi() );
25212 lo = PyLong_FromLong( (&result)->GetLo() );
25213 shifter = PyLong_FromLong(32);
25214 shifted = PyNumber_Lshift(hi, shifter);
25215 resultobj = PyNumber_Or(shifted, lo);
25216 Py_DECREF(hi);
25217 Py_DECREF(lo);
25218 Py_DECREF(shifter);
25219 Py_DECREF(shifted);
25220 }
25221 return resultobj;
25222 fail:
25223 return NULL;
25224 }
25225
25226
25227 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25228 PyObject *resultobj;
25229 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25230 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25231 wxString *arg2 = (wxString *) &arg2_defvalue ;
25232 wxString result;
25233 bool temp2 = false ;
25234 PyObject * obj0 = 0 ;
25235 PyObject * obj1 = 0 ;
25236 char *kwnames[] = {
25237 (char *) "self",(char *) "format", NULL
25238 };
25239
25240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) 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 if (obj1) {
25244 {
25245 arg2 = wxString_in_helper(obj1);
25246 if (arg2 == NULL) SWIG_fail;
25247 temp2 = true;
25248 }
25249 }
25250 {
25251 PyThreadState* __tstate = wxPyBeginAllowThreads();
25252 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25253
25254 wxPyEndAllowThreads(__tstate);
25255 if (PyErr_Occurred()) SWIG_fail;
25256 }
25257 {
25258 #if wxUSE_UNICODE
25259 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25260 #else
25261 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25262 #endif
25263 }
25264 {
25265 if (temp2)
25266 delete arg2;
25267 }
25268 return resultobj;
25269 fail:
25270 {
25271 if (temp2)
25272 delete arg2;
25273 }
25274 return NULL;
25275 }
25276
25277
25278 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25279 PyObject *obj;
25280 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25281 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25282 Py_INCREF(obj);
25283 return Py_BuildValue((char *)"");
25284 }
25285 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25286 PyObject *resultobj;
25287 int arg1 = (int) 0 ;
25288 int arg2 = (int) 0 ;
25289 int arg3 = (int) 0 ;
25290 int arg4 = (int) 0 ;
25291 wxDateSpan *result;
25292 PyObject * obj0 = 0 ;
25293 PyObject * obj1 = 0 ;
25294 PyObject * obj2 = 0 ;
25295 PyObject * obj3 = 0 ;
25296 char *kwnames[] = {
25297 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25298 };
25299
25300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25301 if (obj0) {
25302 {
25303 arg1 = (int)(SWIG_As_int(obj0));
25304 if (SWIG_arg_fail(1)) SWIG_fail;
25305 }
25306 }
25307 if (obj1) {
25308 {
25309 arg2 = (int)(SWIG_As_int(obj1));
25310 if (SWIG_arg_fail(2)) SWIG_fail;
25311 }
25312 }
25313 if (obj2) {
25314 {
25315 arg3 = (int)(SWIG_As_int(obj2));
25316 if (SWIG_arg_fail(3)) SWIG_fail;
25317 }
25318 }
25319 if (obj3) {
25320 {
25321 arg4 = (int)(SWIG_As_int(obj3));
25322 if (SWIG_arg_fail(4)) SWIG_fail;
25323 }
25324 }
25325 {
25326 PyThreadState* __tstate = wxPyBeginAllowThreads();
25327 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25328
25329 wxPyEndAllowThreads(__tstate);
25330 if (PyErr_Occurred()) SWIG_fail;
25331 }
25332 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25333 return resultobj;
25334 fail:
25335 return NULL;
25336 }
25337
25338
25339 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25340 PyObject *resultobj;
25341 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25342 PyObject * obj0 = 0 ;
25343 char *kwnames[] = {
25344 (char *) "self", NULL
25345 };
25346
25347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25349 if (SWIG_arg_fail(1)) SWIG_fail;
25350 {
25351 PyThreadState* __tstate = wxPyBeginAllowThreads();
25352 delete arg1;
25353
25354 wxPyEndAllowThreads(__tstate);
25355 if (PyErr_Occurred()) SWIG_fail;
25356 }
25357 Py_INCREF(Py_None); resultobj = Py_None;
25358 return resultobj;
25359 fail:
25360 return NULL;
25361 }
25362
25363
25364 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25365 PyObject *resultobj;
25366 int arg1 ;
25367 wxDateSpan result;
25368 PyObject * obj0 = 0 ;
25369 char *kwnames[] = {
25370 (char *) "days", NULL
25371 };
25372
25373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25374 {
25375 arg1 = (int)(SWIG_As_int(obj0));
25376 if (SWIG_arg_fail(1)) SWIG_fail;
25377 }
25378 {
25379 PyThreadState* __tstate = wxPyBeginAllowThreads();
25380 result = wxDateSpan::Days(arg1);
25381
25382 wxPyEndAllowThreads(__tstate);
25383 if (PyErr_Occurred()) SWIG_fail;
25384 }
25385 {
25386 wxDateSpan * resultptr;
25387 resultptr = new wxDateSpan((wxDateSpan &)(result));
25388 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25389 }
25390 return resultobj;
25391 fail:
25392 return NULL;
25393 }
25394
25395
25396 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25397 PyObject *resultobj;
25398 wxDateSpan result;
25399 char *kwnames[] = {
25400 NULL
25401 };
25402
25403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25404 {
25405 PyThreadState* __tstate = wxPyBeginAllowThreads();
25406 result = wxDateSpan::Day();
25407
25408 wxPyEndAllowThreads(__tstate);
25409 if (PyErr_Occurred()) SWIG_fail;
25410 }
25411 {
25412 wxDateSpan * resultptr;
25413 resultptr = new wxDateSpan((wxDateSpan &)(result));
25414 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25415 }
25416 return resultobj;
25417 fail:
25418 return NULL;
25419 }
25420
25421
25422 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25423 PyObject *resultobj;
25424 int arg1 ;
25425 wxDateSpan result;
25426 PyObject * obj0 = 0 ;
25427 char *kwnames[] = {
25428 (char *) "weeks", NULL
25429 };
25430
25431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25432 {
25433 arg1 = (int)(SWIG_As_int(obj0));
25434 if (SWIG_arg_fail(1)) SWIG_fail;
25435 }
25436 {
25437 PyThreadState* __tstate = wxPyBeginAllowThreads();
25438 result = wxDateSpan::Weeks(arg1);
25439
25440 wxPyEndAllowThreads(__tstate);
25441 if (PyErr_Occurred()) SWIG_fail;
25442 }
25443 {
25444 wxDateSpan * resultptr;
25445 resultptr = new wxDateSpan((wxDateSpan &)(result));
25446 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25447 }
25448 return resultobj;
25449 fail:
25450 return NULL;
25451 }
25452
25453
25454 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25455 PyObject *resultobj;
25456 wxDateSpan result;
25457 char *kwnames[] = {
25458 NULL
25459 };
25460
25461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25462 {
25463 PyThreadState* __tstate = wxPyBeginAllowThreads();
25464 result = wxDateSpan::Week();
25465
25466 wxPyEndAllowThreads(__tstate);
25467 if (PyErr_Occurred()) SWIG_fail;
25468 }
25469 {
25470 wxDateSpan * resultptr;
25471 resultptr = new wxDateSpan((wxDateSpan &)(result));
25472 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25473 }
25474 return resultobj;
25475 fail:
25476 return NULL;
25477 }
25478
25479
25480 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25481 PyObject *resultobj;
25482 int arg1 ;
25483 wxDateSpan result;
25484 PyObject * obj0 = 0 ;
25485 char *kwnames[] = {
25486 (char *) "mon", NULL
25487 };
25488
25489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25490 {
25491 arg1 = (int)(SWIG_As_int(obj0));
25492 if (SWIG_arg_fail(1)) SWIG_fail;
25493 }
25494 {
25495 PyThreadState* __tstate = wxPyBeginAllowThreads();
25496 result = wxDateSpan::Months(arg1);
25497
25498 wxPyEndAllowThreads(__tstate);
25499 if (PyErr_Occurred()) SWIG_fail;
25500 }
25501 {
25502 wxDateSpan * resultptr;
25503 resultptr = new wxDateSpan((wxDateSpan &)(result));
25504 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25505 }
25506 return resultobj;
25507 fail:
25508 return NULL;
25509 }
25510
25511
25512 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25513 PyObject *resultobj;
25514 wxDateSpan result;
25515 char *kwnames[] = {
25516 NULL
25517 };
25518
25519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25520 {
25521 PyThreadState* __tstate = wxPyBeginAllowThreads();
25522 result = wxDateSpan::Month();
25523
25524 wxPyEndAllowThreads(__tstate);
25525 if (PyErr_Occurred()) SWIG_fail;
25526 }
25527 {
25528 wxDateSpan * resultptr;
25529 resultptr = new wxDateSpan((wxDateSpan &)(result));
25530 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25531 }
25532 return resultobj;
25533 fail:
25534 return NULL;
25535 }
25536
25537
25538 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25539 PyObject *resultobj;
25540 int arg1 ;
25541 wxDateSpan result;
25542 PyObject * obj0 = 0 ;
25543 char *kwnames[] = {
25544 (char *) "years", NULL
25545 };
25546
25547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25548 {
25549 arg1 = (int)(SWIG_As_int(obj0));
25550 if (SWIG_arg_fail(1)) SWIG_fail;
25551 }
25552 {
25553 PyThreadState* __tstate = wxPyBeginAllowThreads();
25554 result = wxDateSpan::Years(arg1);
25555
25556 wxPyEndAllowThreads(__tstate);
25557 if (PyErr_Occurred()) SWIG_fail;
25558 }
25559 {
25560 wxDateSpan * resultptr;
25561 resultptr = new wxDateSpan((wxDateSpan &)(result));
25562 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25563 }
25564 return resultobj;
25565 fail:
25566 return NULL;
25567 }
25568
25569
25570 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25571 PyObject *resultobj;
25572 wxDateSpan result;
25573 char *kwnames[] = {
25574 NULL
25575 };
25576
25577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25578 {
25579 PyThreadState* __tstate = wxPyBeginAllowThreads();
25580 result = wxDateSpan::Year();
25581
25582 wxPyEndAllowThreads(__tstate);
25583 if (PyErr_Occurred()) SWIG_fail;
25584 }
25585 {
25586 wxDateSpan * resultptr;
25587 resultptr = new wxDateSpan((wxDateSpan &)(result));
25588 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25589 }
25590 return resultobj;
25591 fail:
25592 return NULL;
25593 }
25594
25595
25596 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25597 PyObject *resultobj;
25598 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25599 int arg2 ;
25600 wxDateSpan *result;
25601 PyObject * obj0 = 0 ;
25602 PyObject * obj1 = 0 ;
25603 char *kwnames[] = {
25604 (char *) "self",(char *) "n", NULL
25605 };
25606
25607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25609 if (SWIG_arg_fail(1)) SWIG_fail;
25610 {
25611 arg2 = (int)(SWIG_As_int(obj1));
25612 if (SWIG_arg_fail(2)) SWIG_fail;
25613 }
25614 {
25615 PyThreadState* __tstate = wxPyBeginAllowThreads();
25616 {
25617 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25618 result = (wxDateSpan *) &_result_ref;
25619 }
25620
25621 wxPyEndAllowThreads(__tstate);
25622 if (PyErr_Occurred()) SWIG_fail;
25623 }
25624 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25625 return resultobj;
25626 fail:
25627 return NULL;
25628 }
25629
25630
25631 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25632 PyObject *resultobj;
25633 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25634 int arg2 ;
25635 wxDateSpan *result;
25636 PyObject * obj0 = 0 ;
25637 PyObject * obj1 = 0 ;
25638 char *kwnames[] = {
25639 (char *) "self",(char *) "n", NULL
25640 };
25641
25642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25644 if (SWIG_arg_fail(1)) SWIG_fail;
25645 {
25646 arg2 = (int)(SWIG_As_int(obj1));
25647 if (SWIG_arg_fail(2)) SWIG_fail;
25648 }
25649 {
25650 PyThreadState* __tstate = wxPyBeginAllowThreads();
25651 {
25652 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25653 result = (wxDateSpan *) &_result_ref;
25654 }
25655
25656 wxPyEndAllowThreads(__tstate);
25657 if (PyErr_Occurred()) SWIG_fail;
25658 }
25659 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25660 return resultobj;
25661 fail:
25662 return NULL;
25663 }
25664
25665
25666 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25667 PyObject *resultobj;
25668 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25669 int arg2 ;
25670 wxDateSpan *result;
25671 PyObject * obj0 = 0 ;
25672 PyObject * obj1 = 0 ;
25673 char *kwnames[] = {
25674 (char *) "self",(char *) "n", NULL
25675 };
25676
25677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25679 if (SWIG_arg_fail(1)) SWIG_fail;
25680 {
25681 arg2 = (int)(SWIG_As_int(obj1));
25682 if (SWIG_arg_fail(2)) SWIG_fail;
25683 }
25684 {
25685 PyThreadState* __tstate = wxPyBeginAllowThreads();
25686 {
25687 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25688 result = (wxDateSpan *) &_result_ref;
25689 }
25690
25691 wxPyEndAllowThreads(__tstate);
25692 if (PyErr_Occurred()) SWIG_fail;
25693 }
25694 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25695 return resultobj;
25696 fail:
25697 return NULL;
25698 }
25699
25700
25701 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25702 PyObject *resultobj;
25703 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25704 int arg2 ;
25705 wxDateSpan *result;
25706 PyObject * obj0 = 0 ;
25707 PyObject * obj1 = 0 ;
25708 char *kwnames[] = {
25709 (char *) "self",(char *) "n", NULL
25710 };
25711
25712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25714 if (SWIG_arg_fail(1)) SWIG_fail;
25715 {
25716 arg2 = (int)(SWIG_As_int(obj1));
25717 if (SWIG_arg_fail(2)) SWIG_fail;
25718 }
25719 {
25720 PyThreadState* __tstate = wxPyBeginAllowThreads();
25721 {
25722 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25723 result = (wxDateSpan *) &_result_ref;
25724 }
25725
25726 wxPyEndAllowThreads(__tstate);
25727 if (PyErr_Occurred()) SWIG_fail;
25728 }
25729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25730 return resultobj;
25731 fail:
25732 return NULL;
25733 }
25734
25735
25736 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25737 PyObject *resultobj;
25738 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25739 int result;
25740 PyObject * obj0 = 0 ;
25741 char *kwnames[] = {
25742 (char *) "self", NULL
25743 };
25744
25745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25747 if (SWIG_arg_fail(1)) SWIG_fail;
25748 {
25749 PyThreadState* __tstate = wxPyBeginAllowThreads();
25750 result = (int)((wxDateSpan const *)arg1)->GetYears();
25751
25752 wxPyEndAllowThreads(__tstate);
25753 if (PyErr_Occurred()) SWIG_fail;
25754 }
25755 {
25756 resultobj = SWIG_From_int((int)(result));
25757 }
25758 return resultobj;
25759 fail:
25760 return NULL;
25761 }
25762
25763
25764 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25765 PyObject *resultobj;
25766 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25767 int result;
25768 PyObject * obj0 = 0 ;
25769 char *kwnames[] = {
25770 (char *) "self", NULL
25771 };
25772
25773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25775 if (SWIG_arg_fail(1)) SWIG_fail;
25776 {
25777 PyThreadState* __tstate = wxPyBeginAllowThreads();
25778 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25779
25780 wxPyEndAllowThreads(__tstate);
25781 if (PyErr_Occurred()) SWIG_fail;
25782 }
25783 {
25784 resultobj = SWIG_From_int((int)(result));
25785 }
25786 return resultobj;
25787 fail:
25788 return NULL;
25789 }
25790
25791
25792 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25793 PyObject *resultobj;
25794 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25795 int result;
25796 PyObject * obj0 = 0 ;
25797 char *kwnames[] = {
25798 (char *) "self", NULL
25799 };
25800
25801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25803 if (SWIG_arg_fail(1)) SWIG_fail;
25804 {
25805 PyThreadState* __tstate = wxPyBeginAllowThreads();
25806 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25807
25808 wxPyEndAllowThreads(__tstate);
25809 if (PyErr_Occurred()) SWIG_fail;
25810 }
25811 {
25812 resultobj = SWIG_From_int((int)(result));
25813 }
25814 return resultobj;
25815 fail:
25816 return NULL;
25817 }
25818
25819
25820 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25821 PyObject *resultobj;
25822 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25823 int result;
25824 PyObject * obj0 = 0 ;
25825 char *kwnames[] = {
25826 (char *) "self", NULL
25827 };
25828
25829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25831 if (SWIG_arg_fail(1)) SWIG_fail;
25832 {
25833 PyThreadState* __tstate = wxPyBeginAllowThreads();
25834 result = (int)((wxDateSpan const *)arg1)->GetDays();
25835
25836 wxPyEndAllowThreads(__tstate);
25837 if (PyErr_Occurred()) SWIG_fail;
25838 }
25839 {
25840 resultobj = SWIG_From_int((int)(result));
25841 }
25842 return resultobj;
25843 fail:
25844 return NULL;
25845 }
25846
25847
25848 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25849 PyObject *resultobj;
25850 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25851 int result;
25852 PyObject * obj0 = 0 ;
25853 char *kwnames[] = {
25854 (char *) "self", NULL
25855 };
25856
25857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25859 if (SWIG_arg_fail(1)) SWIG_fail;
25860 {
25861 PyThreadState* __tstate = wxPyBeginAllowThreads();
25862 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25863
25864 wxPyEndAllowThreads(__tstate);
25865 if (PyErr_Occurred()) SWIG_fail;
25866 }
25867 {
25868 resultobj = SWIG_From_int((int)(result));
25869 }
25870 return resultobj;
25871 fail:
25872 return NULL;
25873 }
25874
25875
25876 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25877 PyObject *resultobj;
25878 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25879 wxDateSpan *arg2 = 0 ;
25880 wxDateSpan *result;
25881 PyObject * obj0 = 0 ;
25882 PyObject * obj1 = 0 ;
25883 char *kwnames[] = {
25884 (char *) "self",(char *) "other", NULL
25885 };
25886
25887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25889 if (SWIG_arg_fail(1)) SWIG_fail;
25890 {
25891 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25892 if (SWIG_arg_fail(2)) SWIG_fail;
25893 if (arg2 == NULL) {
25894 SWIG_null_ref("wxDateSpan");
25895 }
25896 if (SWIG_arg_fail(2)) SWIG_fail;
25897 }
25898 {
25899 PyThreadState* __tstate = wxPyBeginAllowThreads();
25900 {
25901 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25902 result = (wxDateSpan *) &_result_ref;
25903 }
25904
25905 wxPyEndAllowThreads(__tstate);
25906 if (PyErr_Occurred()) SWIG_fail;
25907 }
25908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25909 return resultobj;
25910 fail:
25911 return NULL;
25912 }
25913
25914
25915 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25916 PyObject *resultobj;
25917 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25918 wxDateSpan *arg2 = 0 ;
25919 wxDateSpan *result;
25920 PyObject * obj0 = 0 ;
25921 PyObject * obj1 = 0 ;
25922 char *kwnames[] = {
25923 (char *) "self",(char *) "other", NULL
25924 };
25925
25926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25928 if (SWIG_arg_fail(1)) SWIG_fail;
25929 {
25930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25931 if (SWIG_arg_fail(2)) SWIG_fail;
25932 if (arg2 == NULL) {
25933 SWIG_null_ref("wxDateSpan");
25934 }
25935 if (SWIG_arg_fail(2)) SWIG_fail;
25936 }
25937 {
25938 PyThreadState* __tstate = wxPyBeginAllowThreads();
25939 {
25940 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25941 result = (wxDateSpan *) &_result_ref;
25942 }
25943
25944 wxPyEndAllowThreads(__tstate);
25945 if (PyErr_Occurred()) SWIG_fail;
25946 }
25947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25948 return resultobj;
25949 fail:
25950 return NULL;
25951 }
25952
25953
25954 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25955 PyObject *resultobj;
25956 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25957 wxDateSpan *result;
25958 PyObject * obj0 = 0 ;
25959 char *kwnames[] = {
25960 (char *) "self", NULL
25961 };
25962
25963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25965 if (SWIG_arg_fail(1)) SWIG_fail;
25966 {
25967 PyThreadState* __tstate = wxPyBeginAllowThreads();
25968 {
25969 wxDateSpan &_result_ref = (arg1)->Neg();
25970 result = (wxDateSpan *) &_result_ref;
25971 }
25972
25973 wxPyEndAllowThreads(__tstate);
25974 if (PyErr_Occurred()) SWIG_fail;
25975 }
25976 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25977 return resultobj;
25978 fail:
25979 return NULL;
25980 }
25981
25982
25983 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25984 PyObject *resultobj;
25985 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25986 int arg2 ;
25987 wxDateSpan *result;
25988 PyObject * obj0 = 0 ;
25989 PyObject * obj1 = 0 ;
25990 char *kwnames[] = {
25991 (char *) "self",(char *) "factor", NULL
25992 };
25993
25994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25996 if (SWIG_arg_fail(1)) SWIG_fail;
25997 {
25998 arg2 = (int)(SWIG_As_int(obj1));
25999 if (SWIG_arg_fail(2)) SWIG_fail;
26000 }
26001 {
26002 PyThreadState* __tstate = wxPyBeginAllowThreads();
26003 {
26004 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26005 result = (wxDateSpan *) &_result_ref;
26006 }
26007
26008 wxPyEndAllowThreads(__tstate);
26009 if (PyErr_Occurred()) SWIG_fail;
26010 }
26011 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26012 return resultobj;
26013 fail:
26014 return NULL;
26015 }
26016
26017
26018 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26019 PyObject *resultobj;
26020 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26021 wxDateSpan *arg2 = 0 ;
26022 wxDateSpan *result;
26023 PyObject * obj0 = 0 ;
26024 PyObject * obj1 = 0 ;
26025 char *kwnames[] = {
26026 (char *) "self",(char *) "other", NULL
26027 };
26028
26029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26031 if (SWIG_arg_fail(1)) SWIG_fail;
26032 {
26033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26034 if (SWIG_arg_fail(2)) SWIG_fail;
26035 if (arg2 == NULL) {
26036 SWIG_null_ref("wxDateSpan");
26037 }
26038 if (SWIG_arg_fail(2)) SWIG_fail;
26039 }
26040 {
26041 PyThreadState* __tstate = wxPyBeginAllowThreads();
26042 {
26043 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26044 result = (wxDateSpan *) &_result_ref;
26045 }
26046
26047 wxPyEndAllowThreads(__tstate);
26048 if (PyErr_Occurred()) SWIG_fail;
26049 }
26050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26051 return resultobj;
26052 fail:
26053 return NULL;
26054 }
26055
26056
26057 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26058 PyObject *resultobj;
26059 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26060 wxDateSpan *arg2 = 0 ;
26061 wxDateSpan *result;
26062 PyObject * obj0 = 0 ;
26063 PyObject * obj1 = 0 ;
26064 char *kwnames[] = {
26065 (char *) "self",(char *) "other", NULL
26066 };
26067
26068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26070 if (SWIG_arg_fail(1)) SWIG_fail;
26071 {
26072 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26073 if (SWIG_arg_fail(2)) SWIG_fail;
26074 if (arg2 == NULL) {
26075 SWIG_null_ref("wxDateSpan");
26076 }
26077 if (SWIG_arg_fail(2)) SWIG_fail;
26078 }
26079 {
26080 PyThreadState* __tstate = wxPyBeginAllowThreads();
26081 {
26082 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26083 result = (wxDateSpan *) &_result_ref;
26084 }
26085
26086 wxPyEndAllowThreads(__tstate);
26087 if (PyErr_Occurred()) SWIG_fail;
26088 }
26089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26090 return resultobj;
26091 fail:
26092 return NULL;
26093 }
26094
26095
26096 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26097 PyObject *resultobj;
26098 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26099 wxDateSpan *result;
26100 PyObject * obj0 = 0 ;
26101 char *kwnames[] = {
26102 (char *) "self", NULL
26103 };
26104
26105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26107 if (SWIG_arg_fail(1)) SWIG_fail;
26108 {
26109 PyThreadState* __tstate = wxPyBeginAllowThreads();
26110 {
26111 wxDateSpan &_result_ref = (arg1)->operator -();
26112 result = (wxDateSpan *) &_result_ref;
26113 }
26114
26115 wxPyEndAllowThreads(__tstate);
26116 if (PyErr_Occurred()) SWIG_fail;
26117 }
26118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26119 return resultobj;
26120 fail:
26121 return NULL;
26122 }
26123
26124
26125 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26126 PyObject *resultobj;
26127 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26128 int arg2 ;
26129 wxDateSpan *result;
26130 PyObject * obj0 = 0 ;
26131 PyObject * obj1 = 0 ;
26132 char *kwnames[] = {
26133 (char *) "self",(char *) "factor", NULL
26134 };
26135
26136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26138 if (SWIG_arg_fail(1)) SWIG_fail;
26139 {
26140 arg2 = (int)(SWIG_As_int(obj1));
26141 if (SWIG_arg_fail(2)) SWIG_fail;
26142 }
26143 {
26144 PyThreadState* __tstate = wxPyBeginAllowThreads();
26145 {
26146 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26147 result = (wxDateSpan *) &_result_ref;
26148 }
26149
26150 wxPyEndAllowThreads(__tstate);
26151 if (PyErr_Occurred()) SWIG_fail;
26152 }
26153 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26154 return resultobj;
26155 fail:
26156 return NULL;
26157 }
26158
26159
26160 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26161 PyObject *resultobj;
26162 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26163 wxDateSpan *arg2 = 0 ;
26164 wxDateSpan result;
26165 PyObject * obj0 = 0 ;
26166 PyObject * obj1 = 0 ;
26167 char *kwnames[] = {
26168 (char *) "self",(char *) "other", NULL
26169 };
26170
26171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26173 if (SWIG_arg_fail(1)) SWIG_fail;
26174 {
26175 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26176 if (SWIG_arg_fail(2)) SWIG_fail;
26177 if (arg2 == NULL) {
26178 SWIG_null_ref("wxDateSpan");
26179 }
26180 if (SWIG_arg_fail(2)) SWIG_fail;
26181 }
26182 {
26183 PyThreadState* __tstate = wxPyBeginAllowThreads();
26184 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26185
26186 wxPyEndAllowThreads(__tstate);
26187 if (PyErr_Occurred()) SWIG_fail;
26188 }
26189 {
26190 wxDateSpan * resultptr;
26191 resultptr = new wxDateSpan((wxDateSpan &)(result));
26192 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26193 }
26194 return resultobj;
26195 fail:
26196 return NULL;
26197 }
26198
26199
26200 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26201 PyObject *resultobj;
26202 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26203 wxDateSpan *arg2 = 0 ;
26204 wxDateSpan result;
26205 PyObject * obj0 = 0 ;
26206 PyObject * obj1 = 0 ;
26207 char *kwnames[] = {
26208 (char *) "self",(char *) "other", NULL
26209 };
26210
26211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26213 if (SWIG_arg_fail(1)) SWIG_fail;
26214 {
26215 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26216 if (SWIG_arg_fail(2)) SWIG_fail;
26217 if (arg2 == NULL) {
26218 SWIG_null_ref("wxDateSpan");
26219 }
26220 if (SWIG_arg_fail(2)) SWIG_fail;
26221 }
26222 {
26223 PyThreadState* __tstate = wxPyBeginAllowThreads();
26224 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26225
26226 wxPyEndAllowThreads(__tstate);
26227 if (PyErr_Occurred()) SWIG_fail;
26228 }
26229 {
26230 wxDateSpan * resultptr;
26231 resultptr = new wxDateSpan((wxDateSpan &)(result));
26232 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26233 }
26234 return resultobj;
26235 fail:
26236 return NULL;
26237 }
26238
26239
26240 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26241 PyObject *resultobj;
26242 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26243 int arg2 ;
26244 wxDateSpan result;
26245 PyObject * obj0 = 0 ;
26246 PyObject * obj1 = 0 ;
26247 char *kwnames[] = {
26248 (char *) "self",(char *) "n", NULL
26249 };
26250
26251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26253 if (SWIG_arg_fail(1)) SWIG_fail;
26254 {
26255 arg2 = (int)(SWIG_As_int(obj1));
26256 if (SWIG_arg_fail(2)) SWIG_fail;
26257 }
26258 {
26259 PyThreadState* __tstate = wxPyBeginAllowThreads();
26260 result = wxDateSpan___mul__(arg1,arg2);
26261
26262 wxPyEndAllowThreads(__tstate);
26263 if (PyErr_Occurred()) SWIG_fail;
26264 }
26265 {
26266 wxDateSpan * resultptr;
26267 resultptr = new wxDateSpan((wxDateSpan &)(result));
26268 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26269 }
26270 return resultobj;
26271 fail:
26272 return NULL;
26273 }
26274
26275
26276 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26277 PyObject *resultobj;
26278 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26279 int arg2 ;
26280 wxDateSpan result;
26281 PyObject * obj0 = 0 ;
26282 PyObject * obj1 = 0 ;
26283 char *kwnames[] = {
26284 (char *) "self",(char *) "n", NULL
26285 };
26286
26287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26289 if (SWIG_arg_fail(1)) SWIG_fail;
26290 {
26291 arg2 = (int)(SWIG_As_int(obj1));
26292 if (SWIG_arg_fail(2)) SWIG_fail;
26293 }
26294 {
26295 PyThreadState* __tstate = wxPyBeginAllowThreads();
26296 result = wxDateSpan___rmul__(arg1,arg2);
26297
26298 wxPyEndAllowThreads(__tstate);
26299 if (PyErr_Occurred()) SWIG_fail;
26300 }
26301 {
26302 wxDateSpan * resultptr;
26303 resultptr = new wxDateSpan((wxDateSpan &)(result));
26304 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26305 }
26306 return resultobj;
26307 fail:
26308 return NULL;
26309 }
26310
26311
26312 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26313 PyObject *resultobj;
26314 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26315 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26316 bool result;
26317 PyObject * obj0 = 0 ;
26318 PyObject * obj1 = 0 ;
26319 char *kwnames[] = {
26320 (char *) "self",(char *) "other", NULL
26321 };
26322
26323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26325 if (SWIG_arg_fail(1)) SWIG_fail;
26326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26327 if (SWIG_arg_fail(2)) SWIG_fail;
26328 {
26329 PyThreadState* __tstate = wxPyBeginAllowThreads();
26330 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26331
26332 wxPyEndAllowThreads(__tstate);
26333 if (PyErr_Occurred()) SWIG_fail;
26334 }
26335 {
26336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26337 }
26338 return resultobj;
26339 fail:
26340 return NULL;
26341 }
26342
26343
26344 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26345 PyObject *resultobj;
26346 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26347 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26348 bool result;
26349 PyObject * obj0 = 0 ;
26350 PyObject * obj1 = 0 ;
26351 char *kwnames[] = {
26352 (char *) "self",(char *) "other", NULL
26353 };
26354
26355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26357 if (SWIG_arg_fail(1)) SWIG_fail;
26358 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26359 if (SWIG_arg_fail(2)) SWIG_fail;
26360 {
26361 PyThreadState* __tstate = wxPyBeginAllowThreads();
26362 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26363
26364 wxPyEndAllowThreads(__tstate);
26365 if (PyErr_Occurred()) SWIG_fail;
26366 }
26367 {
26368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26369 }
26370 return resultobj;
26371 fail:
26372 return NULL;
26373 }
26374
26375
26376 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26377 PyObject *obj;
26378 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26379 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26380 Py_INCREF(obj);
26381 return Py_BuildValue((char *)"");
26382 }
26383 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26384 PyObject *resultobj;
26385 long result;
26386 char *kwnames[] = {
26387 NULL
26388 };
26389
26390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26391 {
26392 PyThreadState* __tstate = wxPyBeginAllowThreads();
26393 result = (long)wxGetLocalTime();
26394
26395 wxPyEndAllowThreads(__tstate);
26396 if (PyErr_Occurred()) SWIG_fail;
26397 }
26398 {
26399 resultobj = SWIG_From_long((long)(result));
26400 }
26401 return resultobj;
26402 fail:
26403 return NULL;
26404 }
26405
26406
26407 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26408 PyObject *resultobj;
26409 long result;
26410 char *kwnames[] = {
26411 NULL
26412 };
26413
26414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26415 {
26416 PyThreadState* __tstate = wxPyBeginAllowThreads();
26417 result = (long)wxGetUTCTime();
26418
26419 wxPyEndAllowThreads(__tstate);
26420 if (PyErr_Occurred()) SWIG_fail;
26421 }
26422 {
26423 resultobj = SWIG_From_long((long)(result));
26424 }
26425 return resultobj;
26426 fail:
26427 return NULL;
26428 }
26429
26430
26431 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26432 PyObject *resultobj;
26433 long result;
26434 char *kwnames[] = {
26435 NULL
26436 };
26437
26438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26439 {
26440 PyThreadState* __tstate = wxPyBeginAllowThreads();
26441 result = (long)wxGetCurrentTime();
26442
26443 wxPyEndAllowThreads(__tstate);
26444 if (PyErr_Occurred()) SWIG_fail;
26445 }
26446 {
26447 resultobj = SWIG_From_long((long)(result));
26448 }
26449 return resultobj;
26450 fail:
26451 return NULL;
26452 }
26453
26454
26455 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26456 PyObject *resultobj;
26457 wxLongLong result;
26458 char *kwnames[] = {
26459 NULL
26460 };
26461
26462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26463 {
26464 PyThreadState* __tstate = wxPyBeginAllowThreads();
26465 result = wxGetLocalTimeMillis();
26466
26467 wxPyEndAllowThreads(__tstate);
26468 if (PyErr_Occurred()) SWIG_fail;
26469 }
26470 {
26471 PyObject *hi, *lo, *shifter, *shifted;
26472 hi = PyLong_FromLong( (&result)->GetHi() );
26473 lo = PyLong_FromLong( (&result)->GetLo() );
26474 shifter = PyLong_FromLong(32);
26475 shifted = PyNumber_Lshift(hi, shifter);
26476 resultobj = PyNumber_Or(shifted, lo);
26477 Py_DECREF(hi);
26478 Py_DECREF(lo);
26479 Py_DECREF(shifter);
26480 Py_DECREF(shifted);
26481 }
26482 return resultobj;
26483 fail:
26484 return NULL;
26485 }
26486
26487
26488 static int _wrap_DefaultDateTime_set(PyObject *) {
26489 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26490 return 1;
26491 }
26492
26493
26494 static PyObject *_wrap_DefaultDateTime_get(void) {
26495 PyObject *pyobj;
26496
26497 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26498 return pyobj;
26499 }
26500
26501
26502 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26503 PyObject *resultobj;
26504 wxDataFormatId arg1 ;
26505 wxDataFormat *result;
26506 PyObject * obj0 = 0 ;
26507 char *kwnames[] = {
26508 (char *) "type", NULL
26509 };
26510
26511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26512 {
26513 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26514 if (SWIG_arg_fail(1)) SWIG_fail;
26515 }
26516 {
26517 PyThreadState* __tstate = wxPyBeginAllowThreads();
26518 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26519
26520 wxPyEndAllowThreads(__tstate);
26521 if (PyErr_Occurred()) SWIG_fail;
26522 }
26523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26524 return resultobj;
26525 fail:
26526 return NULL;
26527 }
26528
26529
26530 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26531 PyObject *resultobj;
26532 wxString *arg1 = 0 ;
26533 wxDataFormat *result;
26534 bool temp1 = false ;
26535 PyObject * obj0 = 0 ;
26536 char *kwnames[] = {
26537 (char *) "format", NULL
26538 };
26539
26540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26541 {
26542 arg1 = wxString_in_helper(obj0);
26543 if (arg1 == NULL) SWIG_fail;
26544 temp1 = true;
26545 }
26546 {
26547 PyThreadState* __tstate = wxPyBeginAllowThreads();
26548 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26549
26550 wxPyEndAllowThreads(__tstate);
26551 if (PyErr_Occurred()) SWIG_fail;
26552 }
26553 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26554 {
26555 if (temp1)
26556 delete arg1;
26557 }
26558 return resultobj;
26559 fail:
26560 {
26561 if (temp1)
26562 delete arg1;
26563 }
26564 return NULL;
26565 }
26566
26567
26568 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26569 PyObject *resultobj;
26570 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26571 PyObject * obj0 = 0 ;
26572 char *kwnames[] = {
26573 (char *) "self", NULL
26574 };
26575
26576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26578 if (SWIG_arg_fail(1)) SWIG_fail;
26579 {
26580 PyThreadState* __tstate = wxPyBeginAllowThreads();
26581 delete arg1;
26582
26583 wxPyEndAllowThreads(__tstate);
26584 if (PyErr_Occurred()) SWIG_fail;
26585 }
26586 Py_INCREF(Py_None); resultobj = Py_None;
26587 return resultobj;
26588 fail:
26589 return NULL;
26590 }
26591
26592
26593 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26594 PyObject *resultobj;
26595 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26596 wxDataFormatId arg2 ;
26597 bool result;
26598 PyObject * obj0 = 0 ;
26599 PyObject * obj1 = 0 ;
26600
26601 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26603 if (SWIG_arg_fail(1)) SWIG_fail;
26604 {
26605 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26606 if (SWIG_arg_fail(2)) SWIG_fail;
26607 }
26608 {
26609 PyThreadState* __tstate = wxPyBeginAllowThreads();
26610 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26611
26612 wxPyEndAllowThreads(__tstate);
26613 if (PyErr_Occurred()) SWIG_fail;
26614 }
26615 {
26616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26617 }
26618 return resultobj;
26619 fail:
26620 return NULL;
26621 }
26622
26623
26624 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26625 PyObject *resultobj;
26626 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26627 wxDataFormatId arg2 ;
26628 bool result;
26629 PyObject * obj0 = 0 ;
26630 PyObject * obj1 = 0 ;
26631
26632 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26634 if (SWIG_arg_fail(1)) SWIG_fail;
26635 {
26636 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26637 if (SWIG_arg_fail(2)) SWIG_fail;
26638 }
26639 {
26640 PyThreadState* __tstate = wxPyBeginAllowThreads();
26641 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26642
26643 wxPyEndAllowThreads(__tstate);
26644 if (PyErr_Occurred()) SWIG_fail;
26645 }
26646 {
26647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26648 }
26649 return resultobj;
26650 fail:
26651 return NULL;
26652 }
26653
26654
26655 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26656 PyObject *resultobj;
26657 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26658 wxDataFormat *arg2 = 0 ;
26659 bool result;
26660 PyObject * obj0 = 0 ;
26661 PyObject * obj1 = 0 ;
26662
26663 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26665 if (SWIG_arg_fail(1)) SWIG_fail;
26666 {
26667 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26668 if (SWIG_arg_fail(2)) SWIG_fail;
26669 if (arg2 == NULL) {
26670 SWIG_null_ref("wxDataFormat");
26671 }
26672 if (SWIG_arg_fail(2)) SWIG_fail;
26673 }
26674 {
26675 PyThreadState* __tstate = wxPyBeginAllowThreads();
26676 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26677
26678 wxPyEndAllowThreads(__tstate);
26679 if (PyErr_Occurred()) SWIG_fail;
26680 }
26681 {
26682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26683 }
26684 return resultobj;
26685 fail:
26686 return NULL;
26687 }
26688
26689
26690 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26691 int argc;
26692 PyObject *argv[3];
26693 int ii;
26694
26695 argc = PyObject_Length(args);
26696 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26697 argv[ii] = PyTuple_GetItem(args,ii);
26698 }
26699 if (argc == 2) {
26700 int _v;
26701 {
26702 void *ptr;
26703 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26704 _v = 0;
26705 PyErr_Clear();
26706 } else {
26707 _v = 1;
26708 }
26709 }
26710 if (_v) {
26711 {
26712 void *ptr = 0;
26713 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26714 _v = 0;
26715 PyErr_Clear();
26716 } else {
26717 _v = (ptr != 0);
26718 }
26719 }
26720 if (_v) {
26721 return _wrap_DataFormat___eq____SWIG_1(self,args);
26722 }
26723 }
26724 }
26725 if (argc == 2) {
26726 int _v;
26727 {
26728 void *ptr;
26729 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26730 _v = 0;
26731 PyErr_Clear();
26732 } else {
26733 _v = 1;
26734 }
26735 }
26736 if (_v) {
26737 _v = SWIG_Check_int(argv[1]);
26738 if (_v) {
26739 return _wrap_DataFormat___eq____SWIG_0(self,args);
26740 }
26741 }
26742 }
26743
26744 Py_INCREF(Py_NotImplemented);
26745 return Py_NotImplemented;
26746 }
26747
26748
26749 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26750 PyObject *resultobj;
26751 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26752 wxDataFormat *arg2 = 0 ;
26753 bool result;
26754 PyObject * obj0 = 0 ;
26755 PyObject * obj1 = 0 ;
26756
26757 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26759 if (SWIG_arg_fail(1)) SWIG_fail;
26760 {
26761 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26762 if (SWIG_arg_fail(2)) SWIG_fail;
26763 if (arg2 == NULL) {
26764 SWIG_null_ref("wxDataFormat");
26765 }
26766 if (SWIG_arg_fail(2)) SWIG_fail;
26767 }
26768 {
26769 PyThreadState* __tstate = wxPyBeginAllowThreads();
26770 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26771
26772 wxPyEndAllowThreads(__tstate);
26773 if (PyErr_Occurred()) SWIG_fail;
26774 }
26775 {
26776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26777 }
26778 return resultobj;
26779 fail:
26780 return NULL;
26781 }
26782
26783
26784 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26785 int argc;
26786 PyObject *argv[3];
26787 int ii;
26788
26789 argc = PyObject_Length(args);
26790 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26791 argv[ii] = PyTuple_GetItem(args,ii);
26792 }
26793 if (argc == 2) {
26794 int _v;
26795 {
26796 void *ptr;
26797 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26798 _v = 0;
26799 PyErr_Clear();
26800 } else {
26801 _v = 1;
26802 }
26803 }
26804 if (_v) {
26805 {
26806 void *ptr = 0;
26807 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26808 _v = 0;
26809 PyErr_Clear();
26810 } else {
26811 _v = (ptr != 0);
26812 }
26813 }
26814 if (_v) {
26815 return _wrap_DataFormat___ne____SWIG_1(self,args);
26816 }
26817 }
26818 }
26819 if (argc == 2) {
26820 int _v;
26821 {
26822 void *ptr;
26823 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26824 _v = 0;
26825 PyErr_Clear();
26826 } else {
26827 _v = 1;
26828 }
26829 }
26830 if (_v) {
26831 _v = SWIG_Check_int(argv[1]);
26832 if (_v) {
26833 return _wrap_DataFormat___ne____SWIG_0(self,args);
26834 }
26835 }
26836 }
26837
26838 Py_INCREF(Py_NotImplemented);
26839 return Py_NotImplemented;
26840 }
26841
26842
26843 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26844 PyObject *resultobj;
26845 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26846 wxDataFormatId arg2 ;
26847 PyObject * obj0 = 0 ;
26848 PyObject * obj1 = 0 ;
26849 char *kwnames[] = {
26850 (char *) "self",(char *) "format", NULL
26851 };
26852
26853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26855 if (SWIG_arg_fail(1)) SWIG_fail;
26856 {
26857 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26858 if (SWIG_arg_fail(2)) SWIG_fail;
26859 }
26860 {
26861 PyThreadState* __tstate = wxPyBeginAllowThreads();
26862 (arg1)->SetType((wxDataFormatId )arg2);
26863
26864 wxPyEndAllowThreads(__tstate);
26865 if (PyErr_Occurred()) SWIG_fail;
26866 }
26867 Py_INCREF(Py_None); resultobj = Py_None;
26868 return resultobj;
26869 fail:
26870 return NULL;
26871 }
26872
26873
26874 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26875 PyObject *resultobj;
26876 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26877 wxDataFormatId result;
26878 PyObject * obj0 = 0 ;
26879 char *kwnames[] = {
26880 (char *) "self", NULL
26881 };
26882
26883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26885 if (SWIG_arg_fail(1)) SWIG_fail;
26886 {
26887 PyThreadState* __tstate = wxPyBeginAllowThreads();
26888 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26889
26890 wxPyEndAllowThreads(__tstate);
26891 if (PyErr_Occurred()) SWIG_fail;
26892 }
26893 resultobj = SWIG_From_int((result));
26894 return resultobj;
26895 fail:
26896 return NULL;
26897 }
26898
26899
26900 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26901 PyObject *resultobj;
26902 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26903 wxString result;
26904 PyObject * obj0 = 0 ;
26905 char *kwnames[] = {
26906 (char *) "self", NULL
26907 };
26908
26909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26911 if (SWIG_arg_fail(1)) SWIG_fail;
26912 {
26913 PyThreadState* __tstate = wxPyBeginAllowThreads();
26914 result = ((wxDataFormat const *)arg1)->GetId();
26915
26916 wxPyEndAllowThreads(__tstate);
26917 if (PyErr_Occurred()) SWIG_fail;
26918 }
26919 {
26920 #if wxUSE_UNICODE
26921 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26922 #else
26923 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26924 #endif
26925 }
26926 return resultobj;
26927 fail:
26928 return NULL;
26929 }
26930
26931
26932 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26933 PyObject *resultobj;
26934 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26935 wxString *arg2 = 0 ;
26936 bool temp2 = false ;
26937 PyObject * obj0 = 0 ;
26938 PyObject * obj1 = 0 ;
26939 char *kwnames[] = {
26940 (char *) "self",(char *) "format", NULL
26941 };
26942
26943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26945 if (SWIG_arg_fail(1)) SWIG_fail;
26946 {
26947 arg2 = wxString_in_helper(obj1);
26948 if (arg2 == NULL) SWIG_fail;
26949 temp2 = true;
26950 }
26951 {
26952 PyThreadState* __tstate = wxPyBeginAllowThreads();
26953 (arg1)->SetId((wxString const &)*arg2);
26954
26955 wxPyEndAllowThreads(__tstate);
26956 if (PyErr_Occurred()) SWIG_fail;
26957 }
26958 Py_INCREF(Py_None); resultobj = Py_None;
26959 {
26960 if (temp2)
26961 delete arg2;
26962 }
26963 return resultobj;
26964 fail:
26965 {
26966 if (temp2)
26967 delete arg2;
26968 }
26969 return NULL;
26970 }
26971
26972
26973 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26974 PyObject *obj;
26975 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26976 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26977 Py_INCREF(obj);
26978 return Py_BuildValue((char *)"");
26979 }
26980 static int _wrap_FormatInvalid_set(PyObject *) {
26981 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26982 return 1;
26983 }
26984
26985
26986 static PyObject *_wrap_FormatInvalid_get(void) {
26987 PyObject *pyobj;
26988
26989 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26990 return pyobj;
26991 }
26992
26993
26994 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26995 PyObject *resultobj;
26996 wxDataObject *arg1 = (wxDataObject *) 0 ;
26997 PyObject * obj0 = 0 ;
26998 char *kwnames[] = {
26999 (char *) "self", NULL
27000 };
27001
27002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27004 if (SWIG_arg_fail(1)) SWIG_fail;
27005 {
27006 PyThreadState* __tstate = wxPyBeginAllowThreads();
27007 delete arg1;
27008
27009 wxPyEndAllowThreads(__tstate);
27010 if (PyErr_Occurred()) SWIG_fail;
27011 }
27012 Py_INCREF(Py_None); resultobj = Py_None;
27013 return resultobj;
27014 fail:
27015 return NULL;
27016 }
27017
27018
27019 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27020 PyObject *resultobj;
27021 wxDataObject *arg1 = (wxDataObject *) 0 ;
27022 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27023 SwigValueWrapper<wxDataFormat > result;
27024 PyObject * obj0 = 0 ;
27025 PyObject * obj1 = 0 ;
27026 char *kwnames[] = {
27027 (char *) "self",(char *) "dir", NULL
27028 };
27029
27030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27032 if (SWIG_arg_fail(1)) SWIG_fail;
27033 if (obj1) {
27034 {
27035 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27036 if (SWIG_arg_fail(2)) SWIG_fail;
27037 }
27038 }
27039 {
27040 PyThreadState* __tstate = wxPyBeginAllowThreads();
27041 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27042
27043 wxPyEndAllowThreads(__tstate);
27044 if (PyErr_Occurred()) SWIG_fail;
27045 }
27046 {
27047 wxDataFormat * resultptr;
27048 resultptr = new wxDataFormat((wxDataFormat &)(result));
27049 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27050 }
27051 return resultobj;
27052 fail:
27053 return NULL;
27054 }
27055
27056
27057 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27058 PyObject *resultobj;
27059 wxDataObject *arg1 = (wxDataObject *) 0 ;
27060 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27061 size_t result;
27062 PyObject * obj0 = 0 ;
27063 PyObject * obj1 = 0 ;
27064 char *kwnames[] = {
27065 (char *) "self",(char *) "dir", NULL
27066 };
27067
27068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27070 if (SWIG_arg_fail(1)) SWIG_fail;
27071 if (obj1) {
27072 {
27073 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27074 if (SWIG_arg_fail(2)) SWIG_fail;
27075 }
27076 }
27077 {
27078 PyThreadState* __tstate = wxPyBeginAllowThreads();
27079 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27080
27081 wxPyEndAllowThreads(__tstate);
27082 if (PyErr_Occurred()) SWIG_fail;
27083 }
27084 {
27085 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27086 }
27087 return resultobj;
27088 fail:
27089 return NULL;
27090 }
27091
27092
27093 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27094 PyObject *resultobj;
27095 wxDataObject *arg1 = (wxDataObject *) 0 ;
27096 wxDataFormat *arg2 = 0 ;
27097 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27098 bool result;
27099 PyObject * obj0 = 0 ;
27100 PyObject * obj1 = 0 ;
27101 PyObject * obj2 = 0 ;
27102 char *kwnames[] = {
27103 (char *) "self",(char *) "format",(char *) "dir", NULL
27104 };
27105
27106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27108 if (SWIG_arg_fail(1)) SWIG_fail;
27109 {
27110 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27111 if (SWIG_arg_fail(2)) SWIG_fail;
27112 if (arg2 == NULL) {
27113 SWIG_null_ref("wxDataFormat");
27114 }
27115 if (SWIG_arg_fail(2)) SWIG_fail;
27116 }
27117 if (obj2) {
27118 {
27119 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27120 if (SWIG_arg_fail(3)) SWIG_fail;
27121 }
27122 }
27123 {
27124 PyThreadState* __tstate = wxPyBeginAllowThreads();
27125 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27126
27127 wxPyEndAllowThreads(__tstate);
27128 if (PyErr_Occurred()) SWIG_fail;
27129 }
27130 {
27131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27132 }
27133 return resultobj;
27134 fail:
27135 return NULL;
27136 }
27137
27138
27139 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27140 PyObject *resultobj;
27141 wxDataObject *arg1 = (wxDataObject *) 0 ;
27142 wxDataFormat *arg2 = 0 ;
27143 size_t result;
27144 PyObject * obj0 = 0 ;
27145 PyObject * obj1 = 0 ;
27146 char *kwnames[] = {
27147 (char *) "self",(char *) "format", NULL
27148 };
27149
27150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27152 if (SWIG_arg_fail(1)) SWIG_fail;
27153 {
27154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27155 if (SWIG_arg_fail(2)) SWIG_fail;
27156 if (arg2 == NULL) {
27157 SWIG_null_ref("wxDataFormat");
27158 }
27159 if (SWIG_arg_fail(2)) SWIG_fail;
27160 }
27161 {
27162 PyThreadState* __tstate = wxPyBeginAllowThreads();
27163 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27164
27165 wxPyEndAllowThreads(__tstate);
27166 if (PyErr_Occurred()) SWIG_fail;
27167 }
27168 {
27169 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27170 }
27171 return resultobj;
27172 fail:
27173 return NULL;
27174 }
27175
27176
27177 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27178 PyObject *resultobj;
27179 wxDataObject *arg1 = (wxDataObject *) 0 ;
27180 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27181 PyObject *result;
27182 PyObject * obj0 = 0 ;
27183 PyObject * obj1 = 0 ;
27184 char *kwnames[] = {
27185 (char *) "self",(char *) "dir", NULL
27186 };
27187
27188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27190 if (SWIG_arg_fail(1)) SWIG_fail;
27191 if (obj1) {
27192 {
27193 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27194 if (SWIG_arg_fail(2)) SWIG_fail;
27195 }
27196 }
27197 {
27198 PyThreadState* __tstate = wxPyBeginAllowThreads();
27199 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27200
27201 wxPyEndAllowThreads(__tstate);
27202 if (PyErr_Occurred()) SWIG_fail;
27203 }
27204 resultobj = result;
27205 return resultobj;
27206 fail:
27207 return NULL;
27208 }
27209
27210
27211 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27212 PyObject *resultobj;
27213 wxDataObject *arg1 = (wxDataObject *) 0 ;
27214 wxDataFormat *arg2 = 0 ;
27215 PyObject *result;
27216 PyObject * obj0 = 0 ;
27217 PyObject * obj1 = 0 ;
27218 char *kwnames[] = {
27219 (char *) "self",(char *) "format", NULL
27220 };
27221
27222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27224 if (SWIG_arg_fail(1)) SWIG_fail;
27225 {
27226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27227 if (SWIG_arg_fail(2)) SWIG_fail;
27228 if (arg2 == NULL) {
27229 SWIG_null_ref("wxDataFormat");
27230 }
27231 if (SWIG_arg_fail(2)) SWIG_fail;
27232 }
27233 {
27234 PyThreadState* __tstate = wxPyBeginAllowThreads();
27235 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27236
27237 wxPyEndAllowThreads(__tstate);
27238 if (PyErr_Occurred()) SWIG_fail;
27239 }
27240 resultobj = result;
27241 return resultobj;
27242 fail:
27243 return NULL;
27244 }
27245
27246
27247 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27248 PyObject *resultobj;
27249 wxDataObject *arg1 = (wxDataObject *) 0 ;
27250 wxDataFormat *arg2 = 0 ;
27251 PyObject *arg3 = (PyObject *) 0 ;
27252 bool result;
27253 PyObject * obj0 = 0 ;
27254 PyObject * obj1 = 0 ;
27255 PyObject * obj2 = 0 ;
27256 char *kwnames[] = {
27257 (char *) "self",(char *) "format",(char *) "data", NULL
27258 };
27259
27260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27262 if (SWIG_arg_fail(1)) SWIG_fail;
27263 {
27264 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27265 if (SWIG_arg_fail(2)) SWIG_fail;
27266 if (arg2 == NULL) {
27267 SWIG_null_ref("wxDataFormat");
27268 }
27269 if (SWIG_arg_fail(2)) SWIG_fail;
27270 }
27271 arg3 = obj2;
27272 {
27273 PyThreadState* __tstate = wxPyBeginAllowThreads();
27274 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27275
27276 wxPyEndAllowThreads(__tstate);
27277 if (PyErr_Occurred()) SWIG_fail;
27278 }
27279 {
27280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27281 }
27282 return resultobj;
27283 fail:
27284 return NULL;
27285 }
27286
27287
27288 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27289 PyObject *obj;
27290 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27291 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27292 Py_INCREF(obj);
27293 return Py_BuildValue((char *)"");
27294 }
27295 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27296 PyObject *resultobj;
27297 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27298 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27299 wxDataObjectSimple *result;
27300 PyObject * obj0 = 0 ;
27301 char *kwnames[] = {
27302 (char *) "format", NULL
27303 };
27304
27305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27306 if (obj0) {
27307 {
27308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27309 if (SWIG_arg_fail(1)) SWIG_fail;
27310 if (arg1 == NULL) {
27311 SWIG_null_ref("wxDataFormat");
27312 }
27313 if (SWIG_arg_fail(1)) SWIG_fail;
27314 }
27315 }
27316 {
27317 PyThreadState* __tstate = wxPyBeginAllowThreads();
27318 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27319
27320 wxPyEndAllowThreads(__tstate);
27321 if (PyErr_Occurred()) SWIG_fail;
27322 }
27323 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27324 return resultobj;
27325 fail:
27326 return NULL;
27327 }
27328
27329
27330 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27331 PyObject *resultobj;
27332 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27333 wxDataFormat *result;
27334 PyObject * obj0 = 0 ;
27335 char *kwnames[] = {
27336 (char *) "self", NULL
27337 };
27338
27339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27341 if (SWIG_arg_fail(1)) SWIG_fail;
27342 {
27343 PyThreadState* __tstate = wxPyBeginAllowThreads();
27344 {
27345 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27346 result = (wxDataFormat *) &_result_ref;
27347 }
27348
27349 wxPyEndAllowThreads(__tstate);
27350 if (PyErr_Occurred()) SWIG_fail;
27351 }
27352 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27353 return resultobj;
27354 fail:
27355 return NULL;
27356 }
27357
27358
27359 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27360 PyObject *resultobj;
27361 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27362 wxDataFormat *arg2 = 0 ;
27363 PyObject * obj0 = 0 ;
27364 PyObject * obj1 = 0 ;
27365 char *kwnames[] = {
27366 (char *) "self",(char *) "format", NULL
27367 };
27368
27369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27371 if (SWIG_arg_fail(1)) SWIG_fail;
27372 {
27373 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27374 if (SWIG_arg_fail(2)) SWIG_fail;
27375 if (arg2 == NULL) {
27376 SWIG_null_ref("wxDataFormat");
27377 }
27378 if (SWIG_arg_fail(2)) SWIG_fail;
27379 }
27380 {
27381 PyThreadState* __tstate = wxPyBeginAllowThreads();
27382 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27383
27384 wxPyEndAllowThreads(__tstate);
27385 if (PyErr_Occurred()) SWIG_fail;
27386 }
27387 Py_INCREF(Py_None); resultobj = Py_None;
27388 return resultobj;
27389 fail:
27390 return NULL;
27391 }
27392
27393
27394 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27395 PyObject *resultobj;
27396 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27397 size_t result;
27398 PyObject * obj0 = 0 ;
27399 char *kwnames[] = {
27400 (char *) "self", NULL
27401 };
27402
27403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27405 if (SWIG_arg_fail(1)) SWIG_fail;
27406 {
27407 PyThreadState* __tstate = wxPyBeginAllowThreads();
27408 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27409
27410 wxPyEndAllowThreads(__tstate);
27411 if (PyErr_Occurred()) SWIG_fail;
27412 }
27413 {
27414 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27415 }
27416 return resultobj;
27417 fail:
27418 return NULL;
27419 }
27420
27421
27422 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27423 PyObject *resultobj;
27424 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27425 PyObject *result;
27426 PyObject * obj0 = 0 ;
27427 char *kwnames[] = {
27428 (char *) "self", NULL
27429 };
27430
27431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27433 if (SWIG_arg_fail(1)) SWIG_fail;
27434 {
27435 PyThreadState* __tstate = wxPyBeginAllowThreads();
27436 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27437
27438 wxPyEndAllowThreads(__tstate);
27439 if (PyErr_Occurred()) SWIG_fail;
27440 }
27441 resultobj = result;
27442 return resultobj;
27443 fail:
27444 return NULL;
27445 }
27446
27447
27448 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27449 PyObject *resultobj;
27450 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27451 PyObject *arg2 = (PyObject *) 0 ;
27452 bool result;
27453 PyObject * obj0 = 0 ;
27454 PyObject * obj1 = 0 ;
27455 char *kwnames[] = {
27456 (char *) "self",(char *) "data", NULL
27457 };
27458
27459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27461 if (SWIG_arg_fail(1)) SWIG_fail;
27462 arg2 = obj1;
27463 {
27464 PyThreadState* __tstate = wxPyBeginAllowThreads();
27465 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27466
27467 wxPyEndAllowThreads(__tstate);
27468 if (PyErr_Occurred()) SWIG_fail;
27469 }
27470 {
27471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27472 }
27473 return resultobj;
27474 fail:
27475 return NULL;
27476 }
27477
27478
27479 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27480 PyObject *obj;
27481 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27482 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27483 Py_INCREF(obj);
27484 return Py_BuildValue((char *)"");
27485 }
27486 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27487 PyObject *resultobj;
27488 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27489 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27490 wxPyDataObjectSimple *result;
27491 PyObject * obj0 = 0 ;
27492 char *kwnames[] = {
27493 (char *) "format", NULL
27494 };
27495
27496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27497 if (obj0) {
27498 {
27499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27500 if (SWIG_arg_fail(1)) SWIG_fail;
27501 if (arg1 == NULL) {
27502 SWIG_null_ref("wxDataFormat");
27503 }
27504 if (SWIG_arg_fail(1)) SWIG_fail;
27505 }
27506 }
27507 {
27508 PyThreadState* __tstate = wxPyBeginAllowThreads();
27509 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27510
27511 wxPyEndAllowThreads(__tstate);
27512 if (PyErr_Occurred()) SWIG_fail;
27513 }
27514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27515 return resultobj;
27516 fail:
27517 return NULL;
27518 }
27519
27520
27521 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27522 PyObject *resultobj;
27523 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27524 PyObject *arg2 = (PyObject *) 0 ;
27525 PyObject *arg3 = (PyObject *) 0 ;
27526 PyObject * obj0 = 0 ;
27527 PyObject * obj1 = 0 ;
27528 PyObject * obj2 = 0 ;
27529 char *kwnames[] = {
27530 (char *) "self",(char *) "self",(char *) "_class", NULL
27531 };
27532
27533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27535 if (SWIG_arg_fail(1)) SWIG_fail;
27536 arg2 = obj1;
27537 arg3 = obj2;
27538 {
27539 PyThreadState* __tstate = wxPyBeginAllowThreads();
27540 (arg1)->_setCallbackInfo(arg2,arg3);
27541
27542 wxPyEndAllowThreads(__tstate);
27543 if (PyErr_Occurred()) SWIG_fail;
27544 }
27545 Py_INCREF(Py_None); resultobj = Py_None;
27546 return resultobj;
27547 fail:
27548 return NULL;
27549 }
27550
27551
27552 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27553 PyObject *obj;
27554 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27555 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27556 Py_INCREF(obj);
27557 return Py_BuildValue((char *)"");
27558 }
27559 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27560 PyObject *resultobj;
27561 wxDataObjectComposite *result;
27562 char *kwnames[] = {
27563 NULL
27564 };
27565
27566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27567 {
27568 PyThreadState* __tstate = wxPyBeginAllowThreads();
27569 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27570
27571 wxPyEndAllowThreads(__tstate);
27572 if (PyErr_Occurred()) SWIG_fail;
27573 }
27574 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27575 return resultobj;
27576 fail:
27577 return NULL;
27578 }
27579
27580
27581 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27582 PyObject *resultobj;
27583 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27584 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27585 bool arg3 = (bool) false ;
27586 PyObject * obj0 = 0 ;
27587 PyObject * obj1 = 0 ;
27588 PyObject * obj2 = 0 ;
27589 char *kwnames[] = {
27590 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27591 };
27592
27593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27595 if (SWIG_arg_fail(1)) SWIG_fail;
27596 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27597 if (SWIG_arg_fail(2)) SWIG_fail;
27598 if (obj2) {
27599 {
27600 arg3 = (bool)(SWIG_As_bool(obj2));
27601 if (SWIG_arg_fail(3)) SWIG_fail;
27602 }
27603 }
27604 {
27605 PyThreadState* __tstate = wxPyBeginAllowThreads();
27606 (arg1)->Add(arg2,arg3);
27607
27608 wxPyEndAllowThreads(__tstate);
27609 if (PyErr_Occurred()) SWIG_fail;
27610 }
27611 Py_INCREF(Py_None); resultobj = Py_None;
27612 return resultobj;
27613 fail:
27614 return NULL;
27615 }
27616
27617
27618 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27619 PyObject *obj;
27620 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27621 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27622 Py_INCREF(obj);
27623 return Py_BuildValue((char *)"");
27624 }
27625 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27626 PyObject *resultobj;
27627 wxString const &arg1_defvalue = wxPyEmptyString ;
27628 wxString *arg1 = (wxString *) &arg1_defvalue ;
27629 wxTextDataObject *result;
27630 bool temp1 = false ;
27631 PyObject * obj0 = 0 ;
27632 char *kwnames[] = {
27633 (char *) "text", NULL
27634 };
27635
27636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27637 if (obj0) {
27638 {
27639 arg1 = wxString_in_helper(obj0);
27640 if (arg1 == NULL) SWIG_fail;
27641 temp1 = true;
27642 }
27643 }
27644 {
27645 PyThreadState* __tstate = wxPyBeginAllowThreads();
27646 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27647
27648 wxPyEndAllowThreads(__tstate);
27649 if (PyErr_Occurred()) SWIG_fail;
27650 }
27651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27652 {
27653 if (temp1)
27654 delete arg1;
27655 }
27656 return resultobj;
27657 fail:
27658 {
27659 if (temp1)
27660 delete arg1;
27661 }
27662 return NULL;
27663 }
27664
27665
27666 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27667 PyObject *resultobj;
27668 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27669 size_t result;
27670 PyObject * obj0 = 0 ;
27671 char *kwnames[] = {
27672 (char *) "self", NULL
27673 };
27674
27675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27677 if (SWIG_arg_fail(1)) SWIG_fail;
27678 {
27679 PyThreadState* __tstate = wxPyBeginAllowThreads();
27680 result = (size_t)(arg1)->GetTextLength();
27681
27682 wxPyEndAllowThreads(__tstate);
27683 if (PyErr_Occurred()) SWIG_fail;
27684 }
27685 {
27686 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27687 }
27688 return resultobj;
27689 fail:
27690 return NULL;
27691 }
27692
27693
27694 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27695 PyObject *resultobj;
27696 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27697 wxString result;
27698 PyObject * obj0 = 0 ;
27699 char *kwnames[] = {
27700 (char *) "self", NULL
27701 };
27702
27703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27705 if (SWIG_arg_fail(1)) SWIG_fail;
27706 {
27707 PyThreadState* __tstate = wxPyBeginAllowThreads();
27708 result = (arg1)->GetText();
27709
27710 wxPyEndAllowThreads(__tstate);
27711 if (PyErr_Occurred()) SWIG_fail;
27712 }
27713 {
27714 #if wxUSE_UNICODE
27715 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27716 #else
27717 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27718 #endif
27719 }
27720 return resultobj;
27721 fail:
27722 return NULL;
27723 }
27724
27725
27726 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27727 PyObject *resultobj;
27728 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27729 wxString *arg2 = 0 ;
27730 bool temp2 = false ;
27731 PyObject * obj0 = 0 ;
27732 PyObject * obj1 = 0 ;
27733 char *kwnames[] = {
27734 (char *) "self",(char *) "text", NULL
27735 };
27736
27737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27739 if (SWIG_arg_fail(1)) SWIG_fail;
27740 {
27741 arg2 = wxString_in_helper(obj1);
27742 if (arg2 == NULL) SWIG_fail;
27743 temp2 = true;
27744 }
27745 {
27746 PyThreadState* __tstate = wxPyBeginAllowThreads();
27747 (arg1)->SetText((wxString const &)*arg2);
27748
27749 wxPyEndAllowThreads(__tstate);
27750 if (PyErr_Occurred()) SWIG_fail;
27751 }
27752 Py_INCREF(Py_None); resultobj = Py_None;
27753 {
27754 if (temp2)
27755 delete arg2;
27756 }
27757 return resultobj;
27758 fail:
27759 {
27760 if (temp2)
27761 delete arg2;
27762 }
27763 return NULL;
27764 }
27765
27766
27767 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27768 PyObject *obj;
27769 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27770 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27771 Py_INCREF(obj);
27772 return Py_BuildValue((char *)"");
27773 }
27774 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27775 PyObject *resultobj;
27776 wxString const &arg1_defvalue = wxPyEmptyString ;
27777 wxString *arg1 = (wxString *) &arg1_defvalue ;
27778 wxPyTextDataObject *result;
27779 bool temp1 = false ;
27780 PyObject * obj0 = 0 ;
27781 char *kwnames[] = {
27782 (char *) "text", NULL
27783 };
27784
27785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27786 if (obj0) {
27787 {
27788 arg1 = wxString_in_helper(obj0);
27789 if (arg1 == NULL) SWIG_fail;
27790 temp1 = true;
27791 }
27792 }
27793 {
27794 PyThreadState* __tstate = wxPyBeginAllowThreads();
27795 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27796
27797 wxPyEndAllowThreads(__tstate);
27798 if (PyErr_Occurred()) SWIG_fail;
27799 }
27800 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27801 {
27802 if (temp1)
27803 delete arg1;
27804 }
27805 return resultobj;
27806 fail:
27807 {
27808 if (temp1)
27809 delete arg1;
27810 }
27811 return NULL;
27812 }
27813
27814
27815 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27816 PyObject *resultobj;
27817 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27818 PyObject *arg2 = (PyObject *) 0 ;
27819 PyObject *arg3 = (PyObject *) 0 ;
27820 PyObject * obj0 = 0 ;
27821 PyObject * obj1 = 0 ;
27822 PyObject * obj2 = 0 ;
27823 char *kwnames[] = {
27824 (char *) "self",(char *) "self",(char *) "_class", NULL
27825 };
27826
27827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27829 if (SWIG_arg_fail(1)) SWIG_fail;
27830 arg2 = obj1;
27831 arg3 = obj2;
27832 {
27833 PyThreadState* __tstate = wxPyBeginAllowThreads();
27834 (arg1)->_setCallbackInfo(arg2,arg3);
27835
27836 wxPyEndAllowThreads(__tstate);
27837 if (PyErr_Occurred()) SWIG_fail;
27838 }
27839 Py_INCREF(Py_None); resultobj = Py_None;
27840 return resultobj;
27841 fail:
27842 return NULL;
27843 }
27844
27845
27846 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27847 PyObject *obj;
27848 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27849 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27850 Py_INCREF(obj);
27851 return Py_BuildValue((char *)"");
27852 }
27853 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27854 PyObject *resultobj;
27855 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27856 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27857 wxBitmapDataObject *result;
27858 PyObject * obj0 = 0 ;
27859 char *kwnames[] = {
27860 (char *) "bitmap", NULL
27861 };
27862
27863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27864 if (obj0) {
27865 {
27866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27867 if (SWIG_arg_fail(1)) SWIG_fail;
27868 if (arg1 == NULL) {
27869 SWIG_null_ref("wxBitmap");
27870 }
27871 if (SWIG_arg_fail(1)) SWIG_fail;
27872 }
27873 }
27874 {
27875 PyThreadState* __tstate = wxPyBeginAllowThreads();
27876 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27877
27878 wxPyEndAllowThreads(__tstate);
27879 if (PyErr_Occurred()) SWIG_fail;
27880 }
27881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27882 return resultobj;
27883 fail:
27884 return NULL;
27885 }
27886
27887
27888 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27889 PyObject *resultobj;
27890 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27891 wxBitmap result;
27892 PyObject * obj0 = 0 ;
27893 char *kwnames[] = {
27894 (char *) "self", NULL
27895 };
27896
27897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27899 if (SWIG_arg_fail(1)) SWIG_fail;
27900 {
27901 PyThreadState* __tstate = wxPyBeginAllowThreads();
27902 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27903
27904 wxPyEndAllowThreads(__tstate);
27905 if (PyErr_Occurred()) SWIG_fail;
27906 }
27907 {
27908 wxBitmap * resultptr;
27909 resultptr = new wxBitmap((wxBitmap &)(result));
27910 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27911 }
27912 return resultobj;
27913 fail:
27914 return NULL;
27915 }
27916
27917
27918 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27919 PyObject *resultobj;
27920 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27921 wxBitmap *arg2 = 0 ;
27922 PyObject * obj0 = 0 ;
27923 PyObject * obj1 = 0 ;
27924 char *kwnames[] = {
27925 (char *) "self",(char *) "bitmap", NULL
27926 };
27927
27928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27930 if (SWIG_arg_fail(1)) SWIG_fail;
27931 {
27932 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27933 if (SWIG_arg_fail(2)) SWIG_fail;
27934 if (arg2 == NULL) {
27935 SWIG_null_ref("wxBitmap");
27936 }
27937 if (SWIG_arg_fail(2)) SWIG_fail;
27938 }
27939 {
27940 PyThreadState* __tstate = wxPyBeginAllowThreads();
27941 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27942
27943 wxPyEndAllowThreads(__tstate);
27944 if (PyErr_Occurred()) SWIG_fail;
27945 }
27946 Py_INCREF(Py_None); resultobj = Py_None;
27947 return resultobj;
27948 fail:
27949 return NULL;
27950 }
27951
27952
27953 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27954 PyObject *obj;
27955 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27956 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27957 Py_INCREF(obj);
27958 return Py_BuildValue((char *)"");
27959 }
27960 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27961 PyObject *resultobj;
27962 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27963 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27964 wxPyBitmapDataObject *result;
27965 PyObject * obj0 = 0 ;
27966 char *kwnames[] = {
27967 (char *) "bitmap", NULL
27968 };
27969
27970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27971 if (obj0) {
27972 {
27973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27974 if (SWIG_arg_fail(1)) SWIG_fail;
27975 if (arg1 == NULL) {
27976 SWIG_null_ref("wxBitmap");
27977 }
27978 if (SWIG_arg_fail(1)) SWIG_fail;
27979 }
27980 }
27981 {
27982 PyThreadState* __tstate = wxPyBeginAllowThreads();
27983 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27984
27985 wxPyEndAllowThreads(__tstate);
27986 if (PyErr_Occurred()) SWIG_fail;
27987 }
27988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27989 return resultobj;
27990 fail:
27991 return NULL;
27992 }
27993
27994
27995 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27996 PyObject *resultobj;
27997 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27998 PyObject *arg2 = (PyObject *) 0 ;
27999 PyObject *arg3 = (PyObject *) 0 ;
28000 PyObject * obj0 = 0 ;
28001 PyObject * obj1 = 0 ;
28002 PyObject * obj2 = 0 ;
28003 char *kwnames[] = {
28004 (char *) "self",(char *) "self",(char *) "_class", NULL
28005 };
28006
28007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28009 if (SWIG_arg_fail(1)) SWIG_fail;
28010 arg2 = obj1;
28011 arg3 = obj2;
28012 {
28013 PyThreadState* __tstate = wxPyBeginAllowThreads();
28014 (arg1)->_setCallbackInfo(arg2,arg3);
28015
28016 wxPyEndAllowThreads(__tstate);
28017 if (PyErr_Occurred()) SWIG_fail;
28018 }
28019 Py_INCREF(Py_None); resultobj = Py_None;
28020 return resultobj;
28021 fail:
28022 return NULL;
28023 }
28024
28025
28026 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28027 PyObject *obj;
28028 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28029 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28030 Py_INCREF(obj);
28031 return Py_BuildValue((char *)"");
28032 }
28033 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28034 PyObject *resultobj;
28035 wxFileDataObject *result;
28036 char *kwnames[] = {
28037 NULL
28038 };
28039
28040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28041 {
28042 PyThreadState* __tstate = wxPyBeginAllowThreads();
28043 result = (wxFileDataObject *)new wxFileDataObject();
28044
28045 wxPyEndAllowThreads(__tstate);
28046 if (PyErr_Occurred()) SWIG_fail;
28047 }
28048 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28049 return resultobj;
28050 fail:
28051 return NULL;
28052 }
28053
28054
28055 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28056 PyObject *resultobj;
28057 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28058 wxArrayString *result;
28059 PyObject * obj0 = 0 ;
28060 char *kwnames[] = {
28061 (char *) "self", NULL
28062 };
28063
28064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28066 if (SWIG_arg_fail(1)) SWIG_fail;
28067 {
28068 PyThreadState* __tstate = wxPyBeginAllowThreads();
28069 {
28070 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28071 result = (wxArrayString *) &_result_ref;
28072 }
28073
28074 wxPyEndAllowThreads(__tstate);
28075 if (PyErr_Occurred()) SWIG_fail;
28076 }
28077 {
28078 resultobj = wxArrayString2PyList_helper(*result);
28079 }
28080 return resultobj;
28081 fail:
28082 return NULL;
28083 }
28084
28085
28086 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28087 PyObject *resultobj;
28088 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28089 wxString *arg2 = 0 ;
28090 bool temp2 = false ;
28091 PyObject * obj0 = 0 ;
28092 PyObject * obj1 = 0 ;
28093 char *kwnames[] = {
28094 (char *) "self",(char *) "filename", NULL
28095 };
28096
28097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28099 if (SWIG_arg_fail(1)) SWIG_fail;
28100 {
28101 arg2 = wxString_in_helper(obj1);
28102 if (arg2 == NULL) SWIG_fail;
28103 temp2 = true;
28104 }
28105 {
28106 PyThreadState* __tstate = wxPyBeginAllowThreads();
28107 (arg1)->AddFile((wxString const &)*arg2);
28108
28109 wxPyEndAllowThreads(__tstate);
28110 if (PyErr_Occurred()) SWIG_fail;
28111 }
28112 Py_INCREF(Py_None); resultobj = Py_None;
28113 {
28114 if (temp2)
28115 delete arg2;
28116 }
28117 return resultobj;
28118 fail:
28119 {
28120 if (temp2)
28121 delete arg2;
28122 }
28123 return NULL;
28124 }
28125
28126
28127 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28128 PyObject *obj;
28129 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28130 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28131 Py_INCREF(obj);
28132 return Py_BuildValue((char *)"");
28133 }
28134 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28135 PyObject *resultobj;
28136 wxDataFormat *arg1 = 0 ;
28137 wxCustomDataObject *result;
28138 PyObject * obj0 = 0 ;
28139
28140 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28141 {
28142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28143 if (SWIG_arg_fail(1)) SWIG_fail;
28144 if (arg1 == NULL) {
28145 SWIG_null_ref("wxDataFormat");
28146 }
28147 if (SWIG_arg_fail(1)) SWIG_fail;
28148 }
28149 {
28150 PyThreadState* __tstate = wxPyBeginAllowThreads();
28151 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28152
28153 wxPyEndAllowThreads(__tstate);
28154 if (PyErr_Occurred()) SWIG_fail;
28155 }
28156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28157 return resultobj;
28158 fail:
28159 return NULL;
28160 }
28161
28162
28163 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28164 PyObject *resultobj;
28165 wxString *arg1 = 0 ;
28166 wxCustomDataObject *result;
28167 bool temp1 = false ;
28168 PyObject * obj0 = 0 ;
28169
28170 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28171 {
28172 arg1 = wxString_in_helper(obj0);
28173 if (arg1 == NULL) SWIG_fail;
28174 temp1 = true;
28175 }
28176 {
28177 PyThreadState* __tstate = wxPyBeginAllowThreads();
28178 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28179
28180 wxPyEndAllowThreads(__tstate);
28181 if (PyErr_Occurred()) SWIG_fail;
28182 }
28183 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28184 {
28185 if (temp1)
28186 delete arg1;
28187 }
28188 return resultobj;
28189 fail:
28190 {
28191 if (temp1)
28192 delete arg1;
28193 }
28194 return NULL;
28195 }
28196
28197
28198 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28199 PyObject *resultobj;
28200 wxCustomDataObject *result;
28201
28202 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28203 {
28204 PyThreadState* __tstate = wxPyBeginAllowThreads();
28205 result = (wxCustomDataObject *)new wxCustomDataObject();
28206
28207 wxPyEndAllowThreads(__tstate);
28208 if (PyErr_Occurred()) SWIG_fail;
28209 }
28210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28211 return resultobj;
28212 fail:
28213 return NULL;
28214 }
28215
28216
28217 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28218 int argc;
28219 PyObject *argv[2];
28220 int ii;
28221
28222 argc = PyObject_Length(args);
28223 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28224 argv[ii] = PyTuple_GetItem(args,ii);
28225 }
28226 if (argc == 0) {
28227 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28228 }
28229 if (argc == 1) {
28230 int _v;
28231 {
28232 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28233 }
28234 if (_v) {
28235 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28236 }
28237 }
28238 if (argc == 1) {
28239 int _v;
28240 {
28241 void *ptr = 0;
28242 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28243 _v = 0;
28244 PyErr_Clear();
28245 } else {
28246 _v = (ptr != 0);
28247 }
28248 }
28249 if (_v) {
28250 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28251 }
28252 }
28253
28254 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28255 return NULL;
28256 }
28257
28258
28259 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28260 PyObject *resultobj;
28261 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28262 PyObject *arg2 = (PyObject *) 0 ;
28263 bool result;
28264 PyObject * obj0 = 0 ;
28265 PyObject * obj1 = 0 ;
28266 char *kwnames[] = {
28267 (char *) "self",(char *) "data", NULL
28268 };
28269
28270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28272 if (SWIG_arg_fail(1)) SWIG_fail;
28273 arg2 = obj1;
28274 {
28275 PyThreadState* __tstate = wxPyBeginAllowThreads();
28276 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28277
28278 wxPyEndAllowThreads(__tstate);
28279 if (PyErr_Occurred()) SWIG_fail;
28280 }
28281 {
28282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28283 }
28284 return resultobj;
28285 fail:
28286 return NULL;
28287 }
28288
28289
28290 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28291 PyObject *resultobj;
28292 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28293 size_t result;
28294 PyObject * obj0 = 0 ;
28295 char *kwnames[] = {
28296 (char *) "self", NULL
28297 };
28298
28299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28301 if (SWIG_arg_fail(1)) SWIG_fail;
28302 {
28303 PyThreadState* __tstate = wxPyBeginAllowThreads();
28304 result = (size_t)(arg1)->GetSize();
28305
28306 wxPyEndAllowThreads(__tstate);
28307 if (PyErr_Occurred()) SWIG_fail;
28308 }
28309 {
28310 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28311 }
28312 return resultobj;
28313 fail:
28314 return NULL;
28315 }
28316
28317
28318 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28319 PyObject *resultobj;
28320 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28321 PyObject *result;
28322 PyObject * obj0 = 0 ;
28323 char *kwnames[] = {
28324 (char *) "self", NULL
28325 };
28326
28327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28329 if (SWIG_arg_fail(1)) SWIG_fail;
28330 {
28331 PyThreadState* __tstate = wxPyBeginAllowThreads();
28332 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28333
28334 wxPyEndAllowThreads(__tstate);
28335 if (PyErr_Occurred()) SWIG_fail;
28336 }
28337 resultobj = result;
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28345 PyObject *obj;
28346 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28347 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28348 Py_INCREF(obj);
28349 return Py_BuildValue((char *)"");
28350 }
28351 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28352 PyObject *resultobj;
28353 wxURLDataObject *result;
28354 char *kwnames[] = {
28355 NULL
28356 };
28357
28358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28359 {
28360 PyThreadState* __tstate = wxPyBeginAllowThreads();
28361 result = (wxURLDataObject *)new wxURLDataObject();
28362
28363 wxPyEndAllowThreads(__tstate);
28364 if (PyErr_Occurred()) SWIG_fail;
28365 }
28366 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28367 return resultobj;
28368 fail:
28369 return NULL;
28370 }
28371
28372
28373 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28374 PyObject *resultobj;
28375 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28376 wxString result;
28377 PyObject * obj0 = 0 ;
28378 char *kwnames[] = {
28379 (char *) "self", NULL
28380 };
28381
28382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28384 if (SWIG_arg_fail(1)) SWIG_fail;
28385 {
28386 PyThreadState* __tstate = wxPyBeginAllowThreads();
28387 result = (arg1)->GetURL();
28388
28389 wxPyEndAllowThreads(__tstate);
28390 if (PyErr_Occurred()) SWIG_fail;
28391 }
28392 {
28393 #if wxUSE_UNICODE
28394 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28395 #else
28396 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28397 #endif
28398 }
28399 return resultobj;
28400 fail:
28401 return NULL;
28402 }
28403
28404
28405 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28406 PyObject *resultobj;
28407 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28408 wxString *arg2 = 0 ;
28409 bool temp2 = false ;
28410 PyObject * obj0 = 0 ;
28411 PyObject * obj1 = 0 ;
28412 char *kwnames[] = {
28413 (char *) "self",(char *) "url", NULL
28414 };
28415
28416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28418 if (SWIG_arg_fail(1)) SWIG_fail;
28419 {
28420 arg2 = wxString_in_helper(obj1);
28421 if (arg2 == NULL) SWIG_fail;
28422 temp2 = true;
28423 }
28424 {
28425 PyThreadState* __tstate = wxPyBeginAllowThreads();
28426 (arg1)->SetURL((wxString const &)*arg2);
28427
28428 wxPyEndAllowThreads(__tstate);
28429 if (PyErr_Occurred()) SWIG_fail;
28430 }
28431 Py_INCREF(Py_None); resultobj = Py_None;
28432 {
28433 if (temp2)
28434 delete arg2;
28435 }
28436 return resultobj;
28437 fail:
28438 {
28439 if (temp2)
28440 delete arg2;
28441 }
28442 return NULL;
28443 }
28444
28445
28446 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28447 PyObject *obj;
28448 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28449 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28450 Py_INCREF(obj);
28451 return Py_BuildValue((char *)"");
28452 }
28453 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28454 PyObject *resultobj;
28455 wxMetafileDataObject *result;
28456 char *kwnames[] = {
28457 NULL
28458 };
28459
28460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28461 {
28462 PyThreadState* __tstate = wxPyBeginAllowThreads();
28463 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28464
28465 wxPyEndAllowThreads(__tstate);
28466 if (PyErr_Occurred()) SWIG_fail;
28467 }
28468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28469 return resultobj;
28470 fail:
28471 return NULL;
28472 }
28473
28474
28475 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28476 PyObject *resultobj;
28477 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28478 wxMetafile *arg2 = 0 ;
28479 PyObject * obj0 = 0 ;
28480 PyObject * obj1 = 0 ;
28481 char *kwnames[] = {
28482 (char *) "self",(char *) "metafile", NULL
28483 };
28484
28485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28487 if (SWIG_arg_fail(1)) SWIG_fail;
28488 {
28489 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28490 if (SWIG_arg_fail(2)) SWIG_fail;
28491 if (arg2 == NULL) {
28492 SWIG_null_ref("wxMetafile");
28493 }
28494 if (SWIG_arg_fail(2)) SWIG_fail;
28495 }
28496 {
28497 PyThreadState* __tstate = wxPyBeginAllowThreads();
28498 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28499
28500 wxPyEndAllowThreads(__tstate);
28501 if (PyErr_Occurred()) SWIG_fail;
28502 }
28503 Py_INCREF(Py_None); resultobj = Py_None;
28504 return resultobj;
28505 fail:
28506 return NULL;
28507 }
28508
28509
28510 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28511 PyObject *resultobj;
28512 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28513 wxMetafile result;
28514 PyObject * obj0 = 0 ;
28515 char *kwnames[] = {
28516 (char *) "self", NULL
28517 };
28518
28519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28521 if (SWIG_arg_fail(1)) SWIG_fail;
28522 {
28523 PyThreadState* __tstate = wxPyBeginAllowThreads();
28524 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28525
28526 wxPyEndAllowThreads(__tstate);
28527 if (PyErr_Occurred()) SWIG_fail;
28528 }
28529 {
28530 wxMetafile * resultptr;
28531 resultptr = new wxMetafile((wxMetafile &)(result));
28532 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28533 }
28534 return resultobj;
28535 fail:
28536 return NULL;
28537 }
28538
28539
28540 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28541 PyObject *obj;
28542 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28543 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28544 Py_INCREF(obj);
28545 return Py_BuildValue((char *)"");
28546 }
28547 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28548 PyObject *resultobj;
28549 wxDragResult arg1 ;
28550 bool result;
28551 PyObject * obj0 = 0 ;
28552 char *kwnames[] = {
28553 (char *) "res", NULL
28554 };
28555
28556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28557 {
28558 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28559 if (SWIG_arg_fail(1)) SWIG_fail;
28560 }
28561 {
28562 PyThreadState* __tstate = wxPyBeginAllowThreads();
28563 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28564
28565 wxPyEndAllowThreads(__tstate);
28566 if (PyErr_Occurred()) SWIG_fail;
28567 }
28568 {
28569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28570 }
28571 return resultobj;
28572 fail:
28573 return NULL;
28574 }
28575
28576
28577 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28578 PyObject *resultobj;
28579 wxWindow *arg1 = (wxWindow *) 0 ;
28580 wxCursor const &arg2_defvalue = wxNullCursor ;
28581 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28582 wxCursor const &arg3_defvalue = wxNullCursor ;
28583 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28584 wxCursor const &arg4_defvalue = wxNullCursor ;
28585 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28586 wxPyDropSource *result;
28587 PyObject * obj0 = 0 ;
28588 PyObject * obj1 = 0 ;
28589 PyObject * obj2 = 0 ;
28590 PyObject * obj3 = 0 ;
28591 char *kwnames[] = {
28592 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28593 };
28594
28595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28597 if (SWIG_arg_fail(1)) SWIG_fail;
28598 if (obj1) {
28599 {
28600 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28601 if (SWIG_arg_fail(2)) SWIG_fail;
28602 if (arg2 == NULL) {
28603 SWIG_null_ref("wxCursor");
28604 }
28605 if (SWIG_arg_fail(2)) SWIG_fail;
28606 }
28607 }
28608 if (obj2) {
28609 {
28610 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28611 if (SWIG_arg_fail(3)) SWIG_fail;
28612 if (arg3 == NULL) {
28613 SWIG_null_ref("wxCursor");
28614 }
28615 if (SWIG_arg_fail(3)) SWIG_fail;
28616 }
28617 }
28618 if (obj3) {
28619 {
28620 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28621 if (SWIG_arg_fail(4)) SWIG_fail;
28622 if (arg4 == NULL) {
28623 SWIG_null_ref("wxCursor");
28624 }
28625 if (SWIG_arg_fail(4)) SWIG_fail;
28626 }
28627 }
28628 {
28629 PyThreadState* __tstate = wxPyBeginAllowThreads();
28630 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28631
28632 wxPyEndAllowThreads(__tstate);
28633 if (PyErr_Occurred()) SWIG_fail;
28634 }
28635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28636 return resultobj;
28637 fail:
28638 return NULL;
28639 }
28640
28641
28642 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28643 PyObject *resultobj;
28644 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28645 PyObject *arg2 = (PyObject *) 0 ;
28646 PyObject *arg3 = (PyObject *) 0 ;
28647 int arg4 ;
28648 PyObject * obj0 = 0 ;
28649 PyObject * obj1 = 0 ;
28650 PyObject * obj2 = 0 ;
28651 PyObject * obj3 = 0 ;
28652 char *kwnames[] = {
28653 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28654 };
28655
28656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28658 if (SWIG_arg_fail(1)) SWIG_fail;
28659 arg2 = obj1;
28660 arg3 = obj2;
28661 {
28662 arg4 = (int)(SWIG_As_int(obj3));
28663 if (SWIG_arg_fail(4)) SWIG_fail;
28664 }
28665 {
28666 PyThreadState* __tstate = wxPyBeginAllowThreads();
28667 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28668
28669 wxPyEndAllowThreads(__tstate);
28670 if (PyErr_Occurred()) SWIG_fail;
28671 }
28672 Py_INCREF(Py_None); resultobj = Py_None;
28673 return resultobj;
28674 fail:
28675 return NULL;
28676 }
28677
28678
28679 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28680 PyObject *resultobj;
28681 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28682 PyObject * obj0 = 0 ;
28683 char *kwnames[] = {
28684 (char *) "self", NULL
28685 };
28686
28687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28689 if (SWIG_arg_fail(1)) SWIG_fail;
28690 {
28691 PyThreadState* __tstate = wxPyBeginAllowThreads();
28692 delete arg1;
28693
28694 wxPyEndAllowThreads(__tstate);
28695 if (PyErr_Occurred()) SWIG_fail;
28696 }
28697 Py_INCREF(Py_None); resultobj = Py_None;
28698 return resultobj;
28699 fail:
28700 return NULL;
28701 }
28702
28703
28704 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28705 PyObject *resultobj;
28706 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28707 wxDataObject *arg2 = 0 ;
28708 PyObject * obj0 = 0 ;
28709 PyObject * obj1 = 0 ;
28710 char *kwnames[] = {
28711 (char *) "self",(char *) "data", NULL
28712 };
28713
28714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28716 if (SWIG_arg_fail(1)) SWIG_fail;
28717 {
28718 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28719 if (SWIG_arg_fail(2)) SWIG_fail;
28720 if (arg2 == NULL) {
28721 SWIG_null_ref("wxDataObject");
28722 }
28723 if (SWIG_arg_fail(2)) SWIG_fail;
28724 }
28725 {
28726 PyThreadState* __tstate = wxPyBeginAllowThreads();
28727 (arg1)->SetData(*arg2);
28728
28729 wxPyEndAllowThreads(__tstate);
28730 if (PyErr_Occurred()) SWIG_fail;
28731 }
28732 Py_INCREF(Py_None); resultobj = Py_None;
28733 return resultobj;
28734 fail:
28735 return NULL;
28736 }
28737
28738
28739 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28740 PyObject *resultobj;
28741 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28742 wxDataObject *result;
28743 PyObject * obj0 = 0 ;
28744 char *kwnames[] = {
28745 (char *) "self", NULL
28746 };
28747
28748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28750 if (SWIG_arg_fail(1)) SWIG_fail;
28751 {
28752 PyThreadState* __tstate = wxPyBeginAllowThreads();
28753 result = (wxDataObject *)(arg1)->GetDataObject();
28754
28755 wxPyEndAllowThreads(__tstate);
28756 if (PyErr_Occurred()) SWIG_fail;
28757 }
28758 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28759 return resultobj;
28760 fail:
28761 return NULL;
28762 }
28763
28764
28765 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28766 PyObject *resultobj;
28767 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28768 wxDragResult arg2 ;
28769 wxCursor *arg3 = 0 ;
28770 PyObject * obj0 = 0 ;
28771 PyObject * obj1 = 0 ;
28772 PyObject * obj2 = 0 ;
28773 char *kwnames[] = {
28774 (char *) "self",(char *) "res",(char *) "cursor", NULL
28775 };
28776
28777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28779 if (SWIG_arg_fail(1)) SWIG_fail;
28780 {
28781 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28782 if (SWIG_arg_fail(2)) SWIG_fail;
28783 }
28784 {
28785 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28786 if (SWIG_arg_fail(3)) SWIG_fail;
28787 if (arg3 == NULL) {
28788 SWIG_null_ref("wxCursor");
28789 }
28790 if (SWIG_arg_fail(3)) SWIG_fail;
28791 }
28792 {
28793 PyThreadState* __tstate = wxPyBeginAllowThreads();
28794 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28795
28796 wxPyEndAllowThreads(__tstate);
28797 if (PyErr_Occurred()) SWIG_fail;
28798 }
28799 Py_INCREF(Py_None); resultobj = Py_None;
28800 return resultobj;
28801 fail:
28802 return NULL;
28803 }
28804
28805
28806 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28807 PyObject *resultobj;
28808 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28809 int arg2 = (int) wxDrag_CopyOnly ;
28810 wxDragResult result;
28811 PyObject * obj0 = 0 ;
28812 PyObject * obj1 = 0 ;
28813 char *kwnames[] = {
28814 (char *) "self",(char *) "flags", NULL
28815 };
28816
28817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28819 if (SWIG_arg_fail(1)) SWIG_fail;
28820 if (obj1) {
28821 {
28822 arg2 = (int)(SWIG_As_int(obj1));
28823 if (SWIG_arg_fail(2)) SWIG_fail;
28824 }
28825 }
28826 {
28827 PyThreadState* __tstate = wxPyBeginAllowThreads();
28828 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28829
28830 wxPyEndAllowThreads(__tstate);
28831 if (PyErr_Occurred()) SWIG_fail;
28832 }
28833 resultobj = SWIG_From_int((result));
28834 return resultobj;
28835 fail:
28836 return NULL;
28837 }
28838
28839
28840 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28841 PyObject *resultobj;
28842 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28843 wxDragResult arg2 ;
28844 bool result;
28845 PyObject * obj0 = 0 ;
28846 PyObject * obj1 = 0 ;
28847 char *kwnames[] = {
28848 (char *) "self",(char *) "effect", NULL
28849 };
28850
28851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28853 if (SWIG_arg_fail(1)) SWIG_fail;
28854 {
28855 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28856 if (SWIG_arg_fail(2)) SWIG_fail;
28857 }
28858 {
28859 PyThreadState* __tstate = wxPyBeginAllowThreads();
28860 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28861
28862 wxPyEndAllowThreads(__tstate);
28863 if (PyErr_Occurred()) SWIG_fail;
28864 }
28865 {
28866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28867 }
28868 return resultobj;
28869 fail:
28870 return NULL;
28871 }
28872
28873
28874 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28875 PyObject *obj;
28876 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28877 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28878 Py_INCREF(obj);
28879 return Py_BuildValue((char *)"");
28880 }
28881 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28882 PyObject *resultobj;
28883 wxDataObject *arg1 = (wxDataObject *) NULL ;
28884 wxPyDropTarget *result;
28885 PyObject * obj0 = 0 ;
28886 char *kwnames[] = {
28887 (char *) "dataObject", NULL
28888 };
28889
28890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28891 if (obj0) {
28892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28893 if (SWIG_arg_fail(1)) SWIG_fail;
28894 }
28895 {
28896 PyThreadState* __tstate = wxPyBeginAllowThreads();
28897 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28898
28899 wxPyEndAllowThreads(__tstate);
28900 if (PyErr_Occurred()) SWIG_fail;
28901 }
28902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28903 return resultobj;
28904 fail:
28905 return NULL;
28906 }
28907
28908
28909 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28910 PyObject *resultobj;
28911 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28912 PyObject *arg2 = (PyObject *) 0 ;
28913 PyObject *arg3 = (PyObject *) 0 ;
28914 PyObject * obj0 = 0 ;
28915 PyObject * obj1 = 0 ;
28916 PyObject * obj2 = 0 ;
28917 char *kwnames[] = {
28918 (char *) "self",(char *) "self",(char *) "_class", NULL
28919 };
28920
28921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28923 if (SWIG_arg_fail(1)) SWIG_fail;
28924 arg2 = obj1;
28925 arg3 = obj2;
28926 {
28927 PyThreadState* __tstate = wxPyBeginAllowThreads();
28928 (arg1)->_setCallbackInfo(arg2,arg3);
28929
28930 wxPyEndAllowThreads(__tstate);
28931 if (PyErr_Occurred()) SWIG_fail;
28932 }
28933 Py_INCREF(Py_None); resultobj = Py_None;
28934 return resultobj;
28935 fail:
28936 return NULL;
28937 }
28938
28939
28940 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28941 PyObject *resultobj;
28942 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28943 PyObject * obj0 = 0 ;
28944 char *kwnames[] = {
28945 (char *) "self", NULL
28946 };
28947
28948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28950 if (SWIG_arg_fail(1)) SWIG_fail;
28951 {
28952 PyThreadState* __tstate = wxPyBeginAllowThreads();
28953 delete arg1;
28954
28955 wxPyEndAllowThreads(__tstate);
28956 if (PyErr_Occurred()) SWIG_fail;
28957 }
28958 Py_INCREF(Py_None); resultobj = Py_None;
28959 return resultobj;
28960 fail:
28961 return NULL;
28962 }
28963
28964
28965 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28966 PyObject *resultobj;
28967 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28968 wxDataObject *result;
28969 PyObject * obj0 = 0 ;
28970 char *kwnames[] = {
28971 (char *) "self", NULL
28972 };
28973
28974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28976 if (SWIG_arg_fail(1)) SWIG_fail;
28977 {
28978 PyThreadState* __tstate = wxPyBeginAllowThreads();
28979 result = (wxDataObject *)(arg1)->GetDataObject();
28980
28981 wxPyEndAllowThreads(__tstate);
28982 if (PyErr_Occurred()) SWIG_fail;
28983 }
28984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28985 return resultobj;
28986 fail:
28987 return NULL;
28988 }
28989
28990
28991 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28992 PyObject *resultobj;
28993 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28994 wxDataObject *arg2 = (wxDataObject *) 0 ;
28995 PyObject * obj0 = 0 ;
28996 PyObject * obj1 = 0 ;
28997 char *kwnames[] = {
28998 (char *) "self",(char *) "dataObject", NULL
28999 };
29000
29001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
29002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29003 if (SWIG_arg_fail(1)) SWIG_fail;
29004 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29005 if (SWIG_arg_fail(2)) SWIG_fail;
29006 {
29007 PyThreadState* __tstate = wxPyBeginAllowThreads();
29008 (arg1)->SetDataObject(arg2);
29009
29010 wxPyEndAllowThreads(__tstate);
29011 if (PyErr_Occurred()) SWIG_fail;
29012 }
29013 Py_INCREF(Py_None); resultobj = Py_None;
29014 return resultobj;
29015 fail:
29016 return NULL;
29017 }
29018
29019
29020 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29021 PyObject *resultobj;
29022 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29023 int arg2 ;
29024 int arg3 ;
29025 wxDragResult arg4 ;
29026 wxDragResult result;
29027 PyObject * obj0 = 0 ;
29028 PyObject * obj1 = 0 ;
29029 PyObject * obj2 = 0 ;
29030 PyObject * obj3 = 0 ;
29031 char *kwnames[] = {
29032 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29033 };
29034
29035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29037 if (SWIG_arg_fail(1)) SWIG_fail;
29038 {
29039 arg2 = (int)(SWIG_As_int(obj1));
29040 if (SWIG_arg_fail(2)) SWIG_fail;
29041 }
29042 {
29043 arg3 = (int)(SWIG_As_int(obj2));
29044 if (SWIG_arg_fail(3)) SWIG_fail;
29045 }
29046 {
29047 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29048 if (SWIG_arg_fail(4)) SWIG_fail;
29049 }
29050 {
29051 PyThreadState* __tstate = wxPyBeginAllowThreads();
29052 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29053
29054 wxPyEndAllowThreads(__tstate);
29055 if (PyErr_Occurred()) SWIG_fail;
29056 }
29057 resultobj = SWIG_From_int((result));
29058 return resultobj;
29059 fail:
29060 return NULL;
29061 }
29062
29063
29064 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29065 PyObject *resultobj;
29066 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29067 int arg2 ;
29068 int arg3 ;
29069 wxDragResult arg4 ;
29070 wxDragResult result;
29071 PyObject * obj0 = 0 ;
29072 PyObject * obj1 = 0 ;
29073 PyObject * obj2 = 0 ;
29074 PyObject * obj3 = 0 ;
29075 char *kwnames[] = {
29076 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29077 };
29078
29079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29081 if (SWIG_arg_fail(1)) SWIG_fail;
29082 {
29083 arg2 = (int)(SWIG_As_int(obj1));
29084 if (SWIG_arg_fail(2)) SWIG_fail;
29085 }
29086 {
29087 arg3 = (int)(SWIG_As_int(obj2));
29088 if (SWIG_arg_fail(3)) SWIG_fail;
29089 }
29090 {
29091 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29092 if (SWIG_arg_fail(4)) SWIG_fail;
29093 }
29094 {
29095 PyThreadState* __tstate = wxPyBeginAllowThreads();
29096 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29097
29098 wxPyEndAllowThreads(__tstate);
29099 if (PyErr_Occurred()) SWIG_fail;
29100 }
29101 resultobj = SWIG_From_int((result));
29102 return resultobj;
29103 fail:
29104 return NULL;
29105 }
29106
29107
29108 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29109 PyObject *resultobj;
29110 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29111 PyObject * obj0 = 0 ;
29112 char *kwnames[] = {
29113 (char *) "self", NULL
29114 };
29115
29116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29118 if (SWIG_arg_fail(1)) SWIG_fail;
29119 {
29120 PyThreadState* __tstate = wxPyBeginAllowThreads();
29121 (arg1)->base_OnLeave();
29122
29123 wxPyEndAllowThreads(__tstate);
29124 if (PyErr_Occurred()) SWIG_fail;
29125 }
29126 Py_INCREF(Py_None); resultobj = Py_None;
29127 return resultobj;
29128 fail:
29129 return NULL;
29130 }
29131
29132
29133 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29134 PyObject *resultobj;
29135 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29136 int arg2 ;
29137 int arg3 ;
29138 bool result;
29139 PyObject * obj0 = 0 ;
29140 PyObject * obj1 = 0 ;
29141 PyObject * obj2 = 0 ;
29142 char *kwnames[] = {
29143 (char *) "self",(char *) "x",(char *) "y", NULL
29144 };
29145
29146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29148 if (SWIG_arg_fail(1)) SWIG_fail;
29149 {
29150 arg2 = (int)(SWIG_As_int(obj1));
29151 if (SWIG_arg_fail(2)) SWIG_fail;
29152 }
29153 {
29154 arg3 = (int)(SWIG_As_int(obj2));
29155 if (SWIG_arg_fail(3)) SWIG_fail;
29156 }
29157 {
29158 PyThreadState* __tstate = wxPyBeginAllowThreads();
29159 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29160
29161 wxPyEndAllowThreads(__tstate);
29162 if (PyErr_Occurred()) SWIG_fail;
29163 }
29164 {
29165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29166 }
29167 return resultobj;
29168 fail:
29169 return NULL;
29170 }
29171
29172
29173 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29174 PyObject *resultobj;
29175 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29176 bool result;
29177 PyObject * obj0 = 0 ;
29178 char *kwnames[] = {
29179 (char *) "self", NULL
29180 };
29181
29182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29184 if (SWIG_arg_fail(1)) SWIG_fail;
29185 {
29186 PyThreadState* __tstate = wxPyBeginAllowThreads();
29187 result = (bool)(arg1)->GetData();
29188
29189 wxPyEndAllowThreads(__tstate);
29190 if (PyErr_Occurred()) SWIG_fail;
29191 }
29192 {
29193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29194 }
29195 return resultobj;
29196 fail:
29197 return NULL;
29198 }
29199
29200
29201 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29202 PyObject *resultobj;
29203 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29204 wxDragResult arg2 ;
29205 PyObject * obj0 = 0 ;
29206 PyObject * obj1 = 0 ;
29207 char *kwnames[] = {
29208 (char *) "self",(char *) "action", NULL
29209 };
29210
29211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29213 if (SWIG_arg_fail(1)) SWIG_fail;
29214 {
29215 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29216 if (SWIG_arg_fail(2)) SWIG_fail;
29217 }
29218 {
29219 PyThreadState* __tstate = wxPyBeginAllowThreads();
29220 (arg1)->SetDefaultAction((wxDragResult )arg2);
29221
29222 wxPyEndAllowThreads(__tstate);
29223 if (PyErr_Occurred()) SWIG_fail;
29224 }
29225 Py_INCREF(Py_None); resultobj = Py_None;
29226 return resultobj;
29227 fail:
29228 return NULL;
29229 }
29230
29231
29232 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29233 PyObject *resultobj;
29234 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29235 wxDragResult result;
29236 PyObject * obj0 = 0 ;
29237 char *kwnames[] = {
29238 (char *) "self", NULL
29239 };
29240
29241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29243 if (SWIG_arg_fail(1)) SWIG_fail;
29244 {
29245 PyThreadState* __tstate = wxPyBeginAllowThreads();
29246 result = (wxDragResult)(arg1)->GetDefaultAction();
29247
29248 wxPyEndAllowThreads(__tstate);
29249 if (PyErr_Occurred()) SWIG_fail;
29250 }
29251 resultobj = SWIG_From_int((result));
29252 return resultobj;
29253 fail:
29254 return NULL;
29255 }
29256
29257
29258 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29259 PyObject *obj;
29260 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29261 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29262 Py_INCREF(obj);
29263 return Py_BuildValue((char *)"");
29264 }
29265 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29266 PyObject *resultobj;
29267 wxPyTextDropTarget *result;
29268 char *kwnames[] = {
29269 NULL
29270 };
29271
29272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29273 {
29274 PyThreadState* __tstate = wxPyBeginAllowThreads();
29275 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29276
29277 wxPyEndAllowThreads(__tstate);
29278 if (PyErr_Occurred()) SWIG_fail;
29279 }
29280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29281 return resultobj;
29282 fail:
29283 return NULL;
29284 }
29285
29286
29287 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29288 PyObject *resultobj;
29289 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29290 PyObject *arg2 = (PyObject *) 0 ;
29291 PyObject *arg3 = (PyObject *) 0 ;
29292 PyObject * obj0 = 0 ;
29293 PyObject * obj1 = 0 ;
29294 PyObject * obj2 = 0 ;
29295 char *kwnames[] = {
29296 (char *) "self",(char *) "self",(char *) "_class", NULL
29297 };
29298
29299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29301 if (SWIG_arg_fail(1)) SWIG_fail;
29302 arg2 = obj1;
29303 arg3 = obj2;
29304 {
29305 PyThreadState* __tstate = wxPyBeginAllowThreads();
29306 (arg1)->_setCallbackInfo(arg2,arg3);
29307
29308 wxPyEndAllowThreads(__tstate);
29309 if (PyErr_Occurred()) SWIG_fail;
29310 }
29311 Py_INCREF(Py_None); resultobj = Py_None;
29312 return resultobj;
29313 fail:
29314 return NULL;
29315 }
29316
29317
29318 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29319 PyObject *resultobj;
29320 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29321 int arg2 ;
29322 int arg3 ;
29323 wxDragResult arg4 ;
29324 wxDragResult result;
29325 PyObject * obj0 = 0 ;
29326 PyObject * obj1 = 0 ;
29327 PyObject * obj2 = 0 ;
29328 PyObject * obj3 = 0 ;
29329 char *kwnames[] = {
29330 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29331 };
29332
29333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29335 if (SWIG_arg_fail(1)) SWIG_fail;
29336 {
29337 arg2 = (int)(SWIG_As_int(obj1));
29338 if (SWIG_arg_fail(2)) SWIG_fail;
29339 }
29340 {
29341 arg3 = (int)(SWIG_As_int(obj2));
29342 if (SWIG_arg_fail(3)) SWIG_fail;
29343 }
29344 {
29345 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29346 if (SWIG_arg_fail(4)) SWIG_fail;
29347 }
29348 {
29349 PyThreadState* __tstate = wxPyBeginAllowThreads();
29350 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29351
29352 wxPyEndAllowThreads(__tstate);
29353 if (PyErr_Occurred()) SWIG_fail;
29354 }
29355 resultobj = SWIG_From_int((result));
29356 return resultobj;
29357 fail:
29358 return NULL;
29359 }
29360
29361
29362 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29363 PyObject *resultobj;
29364 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29365 int arg2 ;
29366 int arg3 ;
29367 wxDragResult arg4 ;
29368 wxDragResult result;
29369 PyObject * obj0 = 0 ;
29370 PyObject * obj1 = 0 ;
29371 PyObject * obj2 = 0 ;
29372 PyObject * obj3 = 0 ;
29373 char *kwnames[] = {
29374 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29375 };
29376
29377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29379 if (SWIG_arg_fail(1)) SWIG_fail;
29380 {
29381 arg2 = (int)(SWIG_As_int(obj1));
29382 if (SWIG_arg_fail(2)) SWIG_fail;
29383 }
29384 {
29385 arg3 = (int)(SWIG_As_int(obj2));
29386 if (SWIG_arg_fail(3)) SWIG_fail;
29387 }
29388 {
29389 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29390 if (SWIG_arg_fail(4)) SWIG_fail;
29391 }
29392 {
29393 PyThreadState* __tstate = wxPyBeginAllowThreads();
29394 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29395
29396 wxPyEndAllowThreads(__tstate);
29397 if (PyErr_Occurred()) SWIG_fail;
29398 }
29399 resultobj = SWIG_From_int((result));
29400 return resultobj;
29401 fail:
29402 return NULL;
29403 }
29404
29405
29406 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29407 PyObject *resultobj;
29408 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29409 PyObject * obj0 = 0 ;
29410 char *kwnames[] = {
29411 (char *) "self", NULL
29412 };
29413
29414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29416 if (SWIG_arg_fail(1)) SWIG_fail;
29417 {
29418 PyThreadState* __tstate = wxPyBeginAllowThreads();
29419 (arg1)->base_OnLeave();
29420
29421 wxPyEndAllowThreads(__tstate);
29422 if (PyErr_Occurred()) SWIG_fail;
29423 }
29424 Py_INCREF(Py_None); resultobj = Py_None;
29425 return resultobj;
29426 fail:
29427 return NULL;
29428 }
29429
29430
29431 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29432 PyObject *resultobj;
29433 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29434 int arg2 ;
29435 int arg3 ;
29436 bool result;
29437 PyObject * obj0 = 0 ;
29438 PyObject * obj1 = 0 ;
29439 PyObject * obj2 = 0 ;
29440 char *kwnames[] = {
29441 (char *) "self",(char *) "x",(char *) "y", NULL
29442 };
29443
29444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29446 if (SWIG_arg_fail(1)) SWIG_fail;
29447 {
29448 arg2 = (int)(SWIG_As_int(obj1));
29449 if (SWIG_arg_fail(2)) SWIG_fail;
29450 }
29451 {
29452 arg3 = (int)(SWIG_As_int(obj2));
29453 if (SWIG_arg_fail(3)) SWIG_fail;
29454 }
29455 {
29456 PyThreadState* __tstate = wxPyBeginAllowThreads();
29457 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29458
29459 wxPyEndAllowThreads(__tstate);
29460 if (PyErr_Occurred()) SWIG_fail;
29461 }
29462 {
29463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29464 }
29465 return resultobj;
29466 fail:
29467 return NULL;
29468 }
29469
29470
29471 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29472 PyObject *resultobj;
29473 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29474 int arg2 ;
29475 int arg3 ;
29476 wxDragResult arg4 ;
29477 wxDragResult result;
29478 PyObject * obj0 = 0 ;
29479 PyObject * obj1 = 0 ;
29480 PyObject * obj2 = 0 ;
29481 PyObject * obj3 = 0 ;
29482 char *kwnames[] = {
29483 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29484 };
29485
29486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29488 if (SWIG_arg_fail(1)) SWIG_fail;
29489 {
29490 arg2 = (int)(SWIG_As_int(obj1));
29491 if (SWIG_arg_fail(2)) SWIG_fail;
29492 }
29493 {
29494 arg3 = (int)(SWIG_As_int(obj2));
29495 if (SWIG_arg_fail(3)) SWIG_fail;
29496 }
29497 {
29498 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29499 if (SWIG_arg_fail(4)) SWIG_fail;
29500 }
29501 {
29502 PyThreadState* __tstate = wxPyBeginAllowThreads();
29503 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29504
29505 wxPyEndAllowThreads(__tstate);
29506 if (PyErr_Occurred()) SWIG_fail;
29507 }
29508 resultobj = SWIG_From_int((result));
29509 return resultobj;
29510 fail:
29511 return NULL;
29512 }
29513
29514
29515 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29516 PyObject *obj;
29517 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29518 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29519 Py_INCREF(obj);
29520 return Py_BuildValue((char *)"");
29521 }
29522 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29523 PyObject *resultobj;
29524 wxPyFileDropTarget *result;
29525 char *kwnames[] = {
29526 NULL
29527 };
29528
29529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29530 {
29531 PyThreadState* __tstate = wxPyBeginAllowThreads();
29532 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29533
29534 wxPyEndAllowThreads(__tstate);
29535 if (PyErr_Occurred()) SWIG_fail;
29536 }
29537 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29538 return resultobj;
29539 fail:
29540 return NULL;
29541 }
29542
29543
29544 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29545 PyObject *resultobj;
29546 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29547 PyObject *arg2 = (PyObject *) 0 ;
29548 PyObject *arg3 = (PyObject *) 0 ;
29549 PyObject * obj0 = 0 ;
29550 PyObject * obj1 = 0 ;
29551 PyObject * obj2 = 0 ;
29552 char *kwnames[] = {
29553 (char *) "self",(char *) "self",(char *) "_class", NULL
29554 };
29555
29556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29558 if (SWIG_arg_fail(1)) SWIG_fail;
29559 arg2 = obj1;
29560 arg3 = obj2;
29561 {
29562 PyThreadState* __tstate = wxPyBeginAllowThreads();
29563 (arg1)->_setCallbackInfo(arg2,arg3);
29564
29565 wxPyEndAllowThreads(__tstate);
29566 if (PyErr_Occurred()) SWIG_fail;
29567 }
29568 Py_INCREF(Py_None); resultobj = Py_None;
29569 return resultobj;
29570 fail:
29571 return NULL;
29572 }
29573
29574
29575 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29576 PyObject *resultobj;
29577 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29578 int arg2 ;
29579 int arg3 ;
29580 wxDragResult arg4 ;
29581 wxDragResult result;
29582 PyObject * obj0 = 0 ;
29583 PyObject * obj1 = 0 ;
29584 PyObject * obj2 = 0 ;
29585 PyObject * obj3 = 0 ;
29586 char *kwnames[] = {
29587 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29588 };
29589
29590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29592 if (SWIG_arg_fail(1)) SWIG_fail;
29593 {
29594 arg2 = (int)(SWIG_As_int(obj1));
29595 if (SWIG_arg_fail(2)) SWIG_fail;
29596 }
29597 {
29598 arg3 = (int)(SWIG_As_int(obj2));
29599 if (SWIG_arg_fail(3)) SWIG_fail;
29600 }
29601 {
29602 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29603 if (SWIG_arg_fail(4)) SWIG_fail;
29604 }
29605 {
29606 PyThreadState* __tstate = wxPyBeginAllowThreads();
29607 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29608
29609 wxPyEndAllowThreads(__tstate);
29610 if (PyErr_Occurred()) SWIG_fail;
29611 }
29612 resultobj = SWIG_From_int((result));
29613 return resultobj;
29614 fail:
29615 return NULL;
29616 }
29617
29618
29619 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29620 PyObject *resultobj;
29621 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29622 int arg2 ;
29623 int arg3 ;
29624 wxDragResult arg4 ;
29625 wxDragResult result;
29626 PyObject * obj0 = 0 ;
29627 PyObject * obj1 = 0 ;
29628 PyObject * obj2 = 0 ;
29629 PyObject * obj3 = 0 ;
29630 char *kwnames[] = {
29631 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29632 };
29633
29634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29636 if (SWIG_arg_fail(1)) SWIG_fail;
29637 {
29638 arg2 = (int)(SWIG_As_int(obj1));
29639 if (SWIG_arg_fail(2)) SWIG_fail;
29640 }
29641 {
29642 arg3 = (int)(SWIG_As_int(obj2));
29643 if (SWIG_arg_fail(3)) SWIG_fail;
29644 }
29645 {
29646 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29647 if (SWIG_arg_fail(4)) SWIG_fail;
29648 }
29649 {
29650 PyThreadState* __tstate = wxPyBeginAllowThreads();
29651 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29652
29653 wxPyEndAllowThreads(__tstate);
29654 if (PyErr_Occurred()) SWIG_fail;
29655 }
29656 resultobj = SWIG_From_int((result));
29657 return resultobj;
29658 fail:
29659 return NULL;
29660 }
29661
29662
29663 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29664 PyObject *resultobj;
29665 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29666 PyObject * obj0 = 0 ;
29667 char *kwnames[] = {
29668 (char *) "self", NULL
29669 };
29670
29671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29673 if (SWIG_arg_fail(1)) SWIG_fail;
29674 {
29675 PyThreadState* __tstate = wxPyBeginAllowThreads();
29676 (arg1)->base_OnLeave();
29677
29678 wxPyEndAllowThreads(__tstate);
29679 if (PyErr_Occurred()) SWIG_fail;
29680 }
29681 Py_INCREF(Py_None); resultobj = Py_None;
29682 return resultobj;
29683 fail:
29684 return NULL;
29685 }
29686
29687
29688 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29689 PyObject *resultobj;
29690 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29691 int arg2 ;
29692 int arg3 ;
29693 bool result;
29694 PyObject * obj0 = 0 ;
29695 PyObject * obj1 = 0 ;
29696 PyObject * obj2 = 0 ;
29697 char *kwnames[] = {
29698 (char *) "self",(char *) "x",(char *) "y", NULL
29699 };
29700
29701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29703 if (SWIG_arg_fail(1)) SWIG_fail;
29704 {
29705 arg2 = (int)(SWIG_As_int(obj1));
29706 if (SWIG_arg_fail(2)) SWIG_fail;
29707 }
29708 {
29709 arg3 = (int)(SWIG_As_int(obj2));
29710 if (SWIG_arg_fail(3)) SWIG_fail;
29711 }
29712 {
29713 PyThreadState* __tstate = wxPyBeginAllowThreads();
29714 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29715
29716 wxPyEndAllowThreads(__tstate);
29717 if (PyErr_Occurred()) SWIG_fail;
29718 }
29719 {
29720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29721 }
29722 return resultobj;
29723 fail:
29724 return NULL;
29725 }
29726
29727
29728 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29729 PyObject *resultobj;
29730 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29731 int arg2 ;
29732 int arg3 ;
29733 wxDragResult arg4 ;
29734 wxDragResult result;
29735 PyObject * obj0 = 0 ;
29736 PyObject * obj1 = 0 ;
29737 PyObject * obj2 = 0 ;
29738 PyObject * obj3 = 0 ;
29739 char *kwnames[] = {
29740 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29741 };
29742
29743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29745 if (SWIG_arg_fail(1)) SWIG_fail;
29746 {
29747 arg2 = (int)(SWIG_As_int(obj1));
29748 if (SWIG_arg_fail(2)) SWIG_fail;
29749 }
29750 {
29751 arg3 = (int)(SWIG_As_int(obj2));
29752 if (SWIG_arg_fail(3)) SWIG_fail;
29753 }
29754 {
29755 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29756 if (SWIG_arg_fail(4)) SWIG_fail;
29757 }
29758 {
29759 PyThreadState* __tstate = wxPyBeginAllowThreads();
29760 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29761
29762 wxPyEndAllowThreads(__tstate);
29763 if (PyErr_Occurred()) SWIG_fail;
29764 }
29765 resultobj = SWIG_From_int((result));
29766 return resultobj;
29767 fail:
29768 return NULL;
29769 }
29770
29771
29772 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29773 PyObject *obj;
29774 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29775 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29776 Py_INCREF(obj);
29777 return Py_BuildValue((char *)"");
29778 }
29779 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29780 PyObject *resultobj;
29781 wxClipboard *result;
29782 char *kwnames[] = {
29783 NULL
29784 };
29785
29786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29787 {
29788 PyThreadState* __tstate = wxPyBeginAllowThreads();
29789 result = (wxClipboard *)new wxClipboard();
29790
29791 wxPyEndAllowThreads(__tstate);
29792 if (PyErr_Occurred()) SWIG_fail;
29793 }
29794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29795 return resultobj;
29796 fail:
29797 return NULL;
29798 }
29799
29800
29801 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29802 PyObject *resultobj;
29803 wxClipboard *arg1 = (wxClipboard *) 0 ;
29804 PyObject * obj0 = 0 ;
29805 char *kwnames[] = {
29806 (char *) "self", NULL
29807 };
29808
29809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29811 if (SWIG_arg_fail(1)) SWIG_fail;
29812 {
29813 PyThreadState* __tstate = wxPyBeginAllowThreads();
29814 delete arg1;
29815
29816 wxPyEndAllowThreads(__tstate);
29817 if (PyErr_Occurred()) SWIG_fail;
29818 }
29819 Py_INCREF(Py_None); resultobj = Py_None;
29820 return resultobj;
29821 fail:
29822 return NULL;
29823 }
29824
29825
29826 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29827 PyObject *resultobj;
29828 wxClipboard *arg1 = (wxClipboard *) 0 ;
29829 bool result;
29830 PyObject * obj0 = 0 ;
29831 char *kwnames[] = {
29832 (char *) "self", NULL
29833 };
29834
29835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29837 if (SWIG_arg_fail(1)) SWIG_fail;
29838 {
29839 PyThreadState* __tstate = wxPyBeginAllowThreads();
29840 result = (bool)(arg1)->Open();
29841
29842 wxPyEndAllowThreads(__tstate);
29843 if (PyErr_Occurred()) SWIG_fail;
29844 }
29845 {
29846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29847 }
29848 return resultobj;
29849 fail:
29850 return NULL;
29851 }
29852
29853
29854 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29855 PyObject *resultobj;
29856 wxClipboard *arg1 = (wxClipboard *) 0 ;
29857 PyObject * obj0 = 0 ;
29858 char *kwnames[] = {
29859 (char *) "self", NULL
29860 };
29861
29862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29864 if (SWIG_arg_fail(1)) SWIG_fail;
29865 {
29866 PyThreadState* __tstate = wxPyBeginAllowThreads();
29867 (arg1)->Close();
29868
29869 wxPyEndAllowThreads(__tstate);
29870 if (PyErr_Occurred()) SWIG_fail;
29871 }
29872 Py_INCREF(Py_None); resultobj = Py_None;
29873 return resultobj;
29874 fail:
29875 return NULL;
29876 }
29877
29878
29879 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29880 PyObject *resultobj;
29881 wxClipboard *arg1 = (wxClipboard *) 0 ;
29882 bool result;
29883 PyObject * obj0 = 0 ;
29884 char *kwnames[] = {
29885 (char *) "self", NULL
29886 };
29887
29888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29890 if (SWIG_arg_fail(1)) SWIG_fail;
29891 {
29892 PyThreadState* __tstate = wxPyBeginAllowThreads();
29893 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29894
29895 wxPyEndAllowThreads(__tstate);
29896 if (PyErr_Occurred()) SWIG_fail;
29897 }
29898 {
29899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29900 }
29901 return resultobj;
29902 fail:
29903 return NULL;
29904 }
29905
29906
29907 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29908 PyObject *resultobj;
29909 wxClipboard *arg1 = (wxClipboard *) 0 ;
29910 wxDataObject *arg2 = (wxDataObject *) 0 ;
29911 bool result;
29912 PyObject * obj0 = 0 ;
29913 PyObject * obj1 = 0 ;
29914 char *kwnames[] = {
29915 (char *) "self",(char *) "data", NULL
29916 };
29917
29918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29920 if (SWIG_arg_fail(1)) SWIG_fail;
29921 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29922 if (SWIG_arg_fail(2)) SWIG_fail;
29923 {
29924 PyThreadState* __tstate = wxPyBeginAllowThreads();
29925 result = (bool)(arg1)->AddData(arg2);
29926
29927 wxPyEndAllowThreads(__tstate);
29928 if (PyErr_Occurred()) SWIG_fail;
29929 }
29930 {
29931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29932 }
29933 return resultobj;
29934 fail:
29935 return NULL;
29936 }
29937
29938
29939 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29940 PyObject *resultobj;
29941 wxClipboard *arg1 = (wxClipboard *) 0 ;
29942 wxDataObject *arg2 = (wxDataObject *) 0 ;
29943 bool result;
29944 PyObject * obj0 = 0 ;
29945 PyObject * obj1 = 0 ;
29946 char *kwnames[] = {
29947 (char *) "self",(char *) "data", NULL
29948 };
29949
29950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29952 if (SWIG_arg_fail(1)) SWIG_fail;
29953 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29954 if (SWIG_arg_fail(2)) SWIG_fail;
29955 {
29956 PyThreadState* __tstate = wxPyBeginAllowThreads();
29957 result = (bool)(arg1)->SetData(arg2);
29958
29959 wxPyEndAllowThreads(__tstate);
29960 if (PyErr_Occurred()) SWIG_fail;
29961 }
29962 {
29963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29964 }
29965 return resultobj;
29966 fail:
29967 return NULL;
29968 }
29969
29970
29971 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29972 PyObject *resultobj;
29973 wxClipboard *arg1 = (wxClipboard *) 0 ;
29974 wxDataFormat *arg2 = 0 ;
29975 bool result;
29976 PyObject * obj0 = 0 ;
29977 PyObject * obj1 = 0 ;
29978 char *kwnames[] = {
29979 (char *) "self",(char *) "format", NULL
29980 };
29981
29982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29984 if (SWIG_arg_fail(1)) SWIG_fail;
29985 {
29986 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29987 if (SWIG_arg_fail(2)) SWIG_fail;
29988 if (arg2 == NULL) {
29989 SWIG_null_ref("wxDataFormat");
29990 }
29991 if (SWIG_arg_fail(2)) SWIG_fail;
29992 }
29993 {
29994 PyThreadState* __tstate = wxPyBeginAllowThreads();
29995 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29996
29997 wxPyEndAllowThreads(__tstate);
29998 if (PyErr_Occurred()) SWIG_fail;
29999 }
30000 {
30001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30002 }
30003 return resultobj;
30004 fail:
30005 return NULL;
30006 }
30007
30008
30009 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30010 PyObject *resultobj;
30011 wxClipboard *arg1 = (wxClipboard *) 0 ;
30012 wxDataObject *arg2 = 0 ;
30013 bool result;
30014 PyObject * obj0 = 0 ;
30015 PyObject * obj1 = 0 ;
30016 char *kwnames[] = {
30017 (char *) "self",(char *) "data", NULL
30018 };
30019
30020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30022 if (SWIG_arg_fail(1)) SWIG_fail;
30023 {
30024 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30025 if (SWIG_arg_fail(2)) SWIG_fail;
30026 if (arg2 == NULL) {
30027 SWIG_null_ref("wxDataObject");
30028 }
30029 if (SWIG_arg_fail(2)) SWIG_fail;
30030 }
30031 {
30032 PyThreadState* __tstate = wxPyBeginAllowThreads();
30033 result = (bool)(arg1)->GetData(*arg2);
30034
30035 wxPyEndAllowThreads(__tstate);
30036 if (PyErr_Occurred()) SWIG_fail;
30037 }
30038 {
30039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30040 }
30041 return resultobj;
30042 fail:
30043 return NULL;
30044 }
30045
30046
30047 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30048 PyObject *resultobj;
30049 wxClipboard *arg1 = (wxClipboard *) 0 ;
30050 PyObject * obj0 = 0 ;
30051 char *kwnames[] = {
30052 (char *) "self", NULL
30053 };
30054
30055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30057 if (SWIG_arg_fail(1)) SWIG_fail;
30058 {
30059 PyThreadState* __tstate = wxPyBeginAllowThreads();
30060 (arg1)->Clear();
30061
30062 wxPyEndAllowThreads(__tstate);
30063 if (PyErr_Occurred()) SWIG_fail;
30064 }
30065 Py_INCREF(Py_None); resultobj = Py_None;
30066 return resultobj;
30067 fail:
30068 return NULL;
30069 }
30070
30071
30072 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30073 PyObject *resultobj;
30074 wxClipboard *arg1 = (wxClipboard *) 0 ;
30075 bool result;
30076 PyObject * obj0 = 0 ;
30077 char *kwnames[] = {
30078 (char *) "self", NULL
30079 };
30080
30081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30083 if (SWIG_arg_fail(1)) SWIG_fail;
30084 {
30085 PyThreadState* __tstate = wxPyBeginAllowThreads();
30086 result = (bool)(arg1)->Flush();
30087
30088 wxPyEndAllowThreads(__tstate);
30089 if (PyErr_Occurred()) SWIG_fail;
30090 }
30091 {
30092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30093 }
30094 return resultobj;
30095 fail:
30096 return NULL;
30097 }
30098
30099
30100 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30101 PyObject *resultobj;
30102 wxClipboard *arg1 = (wxClipboard *) 0 ;
30103 bool arg2 = (bool) true ;
30104 PyObject * obj0 = 0 ;
30105 PyObject * obj1 = 0 ;
30106 char *kwnames[] = {
30107 (char *) "self",(char *) "primary", NULL
30108 };
30109
30110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30112 if (SWIG_arg_fail(1)) SWIG_fail;
30113 if (obj1) {
30114 {
30115 arg2 = (bool)(SWIG_As_bool(obj1));
30116 if (SWIG_arg_fail(2)) SWIG_fail;
30117 }
30118 }
30119 {
30120 PyThreadState* __tstate = wxPyBeginAllowThreads();
30121 (arg1)->UsePrimarySelection(arg2);
30122
30123 wxPyEndAllowThreads(__tstate);
30124 if (PyErr_Occurred()) SWIG_fail;
30125 }
30126 Py_INCREF(Py_None); resultobj = Py_None;
30127 return resultobj;
30128 fail:
30129 return NULL;
30130 }
30131
30132
30133 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30134 PyObject *resultobj;
30135 wxClipboard *result;
30136 char *kwnames[] = {
30137 NULL
30138 };
30139
30140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30141 {
30142 PyThreadState* __tstate = wxPyBeginAllowThreads();
30143 result = (wxClipboard *)wxClipboard::Get();
30144
30145 wxPyEndAllowThreads(__tstate);
30146 if (PyErr_Occurred()) SWIG_fail;
30147 }
30148 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30149 return resultobj;
30150 fail:
30151 return NULL;
30152 }
30153
30154
30155 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30156 PyObject *obj;
30157 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30158 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30159 Py_INCREF(obj);
30160 return Py_BuildValue((char *)"");
30161 }
30162 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30163 PyObject *resultobj;
30164 wxClipboard *arg1 = (wxClipboard *) NULL ;
30165 wxClipboardLocker *result;
30166 PyObject * obj0 = 0 ;
30167 char *kwnames[] = {
30168 (char *) "clipboard", NULL
30169 };
30170
30171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30172 if (obj0) {
30173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30174 if (SWIG_arg_fail(1)) SWIG_fail;
30175 }
30176 {
30177 PyThreadState* __tstate = wxPyBeginAllowThreads();
30178 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30179
30180 wxPyEndAllowThreads(__tstate);
30181 if (PyErr_Occurred()) SWIG_fail;
30182 }
30183 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30184 return resultobj;
30185 fail:
30186 return NULL;
30187 }
30188
30189
30190 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30191 PyObject *resultobj;
30192 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30193 PyObject * obj0 = 0 ;
30194 char *kwnames[] = {
30195 (char *) "self", NULL
30196 };
30197
30198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30200 if (SWIG_arg_fail(1)) SWIG_fail;
30201 {
30202 PyThreadState* __tstate = wxPyBeginAllowThreads();
30203 delete arg1;
30204
30205 wxPyEndAllowThreads(__tstate);
30206 if (PyErr_Occurred()) SWIG_fail;
30207 }
30208 Py_INCREF(Py_None); resultobj = Py_None;
30209 return resultobj;
30210 fail:
30211 return NULL;
30212 }
30213
30214
30215 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30216 PyObject *resultobj;
30217 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30218 bool result;
30219 PyObject * obj0 = 0 ;
30220 char *kwnames[] = {
30221 (char *) "self", NULL
30222 };
30223
30224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30226 if (SWIG_arg_fail(1)) SWIG_fail;
30227 {
30228 PyThreadState* __tstate = wxPyBeginAllowThreads();
30229 result = (bool)wxClipboardLocker___nonzero__(arg1);
30230
30231 wxPyEndAllowThreads(__tstate);
30232 if (PyErr_Occurred()) SWIG_fail;
30233 }
30234 {
30235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30236 }
30237 return resultobj;
30238 fail:
30239 return NULL;
30240 }
30241
30242
30243 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30244 PyObject *obj;
30245 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30246 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30247 Py_INCREF(obj);
30248 return Py_BuildValue((char *)"");
30249 }
30250 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30251 PyObject *resultobj;
30252 int arg1 = (int) 0 ;
30253 int arg2 = (int) 0 ;
30254 int arg3 = (int) 0 ;
30255 int arg4 = (int) 0 ;
30256 wxVideoMode *result;
30257 PyObject * obj0 = 0 ;
30258 PyObject * obj1 = 0 ;
30259 PyObject * obj2 = 0 ;
30260 PyObject * obj3 = 0 ;
30261 char *kwnames[] = {
30262 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30263 };
30264
30265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30266 if (obj0) {
30267 {
30268 arg1 = (int)(SWIG_As_int(obj0));
30269 if (SWIG_arg_fail(1)) SWIG_fail;
30270 }
30271 }
30272 if (obj1) {
30273 {
30274 arg2 = (int)(SWIG_As_int(obj1));
30275 if (SWIG_arg_fail(2)) SWIG_fail;
30276 }
30277 }
30278 if (obj2) {
30279 {
30280 arg3 = (int)(SWIG_As_int(obj2));
30281 if (SWIG_arg_fail(3)) SWIG_fail;
30282 }
30283 }
30284 if (obj3) {
30285 {
30286 arg4 = (int)(SWIG_As_int(obj3));
30287 if (SWIG_arg_fail(4)) SWIG_fail;
30288 }
30289 }
30290 {
30291 PyThreadState* __tstate = wxPyBeginAllowThreads();
30292 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30293
30294 wxPyEndAllowThreads(__tstate);
30295 if (PyErr_Occurred()) SWIG_fail;
30296 }
30297 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30298 return resultobj;
30299 fail:
30300 return NULL;
30301 }
30302
30303
30304 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30305 PyObject *resultobj;
30306 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30307 PyObject * obj0 = 0 ;
30308 char *kwnames[] = {
30309 (char *) "self", NULL
30310 };
30311
30312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30314 if (SWIG_arg_fail(1)) SWIG_fail;
30315 {
30316 PyThreadState* __tstate = wxPyBeginAllowThreads();
30317 delete arg1;
30318
30319 wxPyEndAllowThreads(__tstate);
30320 if (PyErr_Occurred()) SWIG_fail;
30321 }
30322 Py_INCREF(Py_None); resultobj = Py_None;
30323 return resultobj;
30324 fail:
30325 return NULL;
30326 }
30327
30328
30329 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30330 PyObject *resultobj;
30331 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30332 wxVideoMode *arg2 = 0 ;
30333 bool result;
30334 PyObject * obj0 = 0 ;
30335 PyObject * obj1 = 0 ;
30336 char *kwnames[] = {
30337 (char *) "self",(char *) "other", NULL
30338 };
30339
30340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30342 if (SWIG_arg_fail(1)) SWIG_fail;
30343 {
30344 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30345 if (SWIG_arg_fail(2)) SWIG_fail;
30346 if (arg2 == NULL) {
30347 SWIG_null_ref("wxVideoMode");
30348 }
30349 if (SWIG_arg_fail(2)) SWIG_fail;
30350 }
30351 {
30352 PyThreadState* __tstate = wxPyBeginAllowThreads();
30353 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30354
30355 wxPyEndAllowThreads(__tstate);
30356 if (PyErr_Occurred()) SWIG_fail;
30357 }
30358 {
30359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30360 }
30361 return resultobj;
30362 fail:
30363 return NULL;
30364 }
30365
30366
30367 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30368 PyObject *resultobj;
30369 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30370 int result;
30371 PyObject * obj0 = 0 ;
30372 char *kwnames[] = {
30373 (char *) "self", NULL
30374 };
30375
30376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30378 if (SWIG_arg_fail(1)) SWIG_fail;
30379 {
30380 PyThreadState* __tstate = wxPyBeginAllowThreads();
30381 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30382
30383 wxPyEndAllowThreads(__tstate);
30384 if (PyErr_Occurred()) SWIG_fail;
30385 }
30386 {
30387 resultobj = SWIG_From_int((int)(result));
30388 }
30389 return resultobj;
30390 fail:
30391 return NULL;
30392 }
30393
30394
30395 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30396 PyObject *resultobj;
30397 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30398 int result;
30399 PyObject * obj0 = 0 ;
30400 char *kwnames[] = {
30401 (char *) "self", NULL
30402 };
30403
30404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30406 if (SWIG_arg_fail(1)) SWIG_fail;
30407 {
30408 PyThreadState* __tstate = wxPyBeginAllowThreads();
30409 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30410
30411 wxPyEndAllowThreads(__tstate);
30412 if (PyErr_Occurred()) SWIG_fail;
30413 }
30414 {
30415 resultobj = SWIG_From_int((int)(result));
30416 }
30417 return resultobj;
30418 fail:
30419 return NULL;
30420 }
30421
30422
30423 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30424 PyObject *resultobj;
30425 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30426 int result;
30427 PyObject * obj0 = 0 ;
30428 char *kwnames[] = {
30429 (char *) "self", NULL
30430 };
30431
30432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30434 if (SWIG_arg_fail(1)) SWIG_fail;
30435 {
30436 PyThreadState* __tstate = wxPyBeginAllowThreads();
30437 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30438
30439 wxPyEndAllowThreads(__tstate);
30440 if (PyErr_Occurred()) SWIG_fail;
30441 }
30442 {
30443 resultobj = SWIG_From_int((int)(result));
30444 }
30445 return resultobj;
30446 fail:
30447 return NULL;
30448 }
30449
30450
30451 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30452 PyObject *resultobj;
30453 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30454 bool result;
30455 PyObject * obj0 = 0 ;
30456 char *kwnames[] = {
30457 (char *) "self", NULL
30458 };
30459
30460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30462 if (SWIG_arg_fail(1)) SWIG_fail;
30463 {
30464 PyThreadState* __tstate = wxPyBeginAllowThreads();
30465 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30466
30467 wxPyEndAllowThreads(__tstate);
30468 if (PyErr_Occurred()) SWIG_fail;
30469 }
30470 {
30471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30472 }
30473 return resultobj;
30474 fail:
30475 return NULL;
30476 }
30477
30478
30479 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30480 PyObject *resultobj;
30481 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30482 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30483 bool result;
30484 PyObject * obj0 = 0 ;
30485 PyObject * obj1 = 0 ;
30486 char *kwnames[] = {
30487 (char *) "self",(char *) "other", NULL
30488 };
30489
30490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30492 if (SWIG_arg_fail(1)) SWIG_fail;
30493 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30494 if (SWIG_arg_fail(2)) SWIG_fail;
30495 {
30496 PyThreadState* __tstate = wxPyBeginAllowThreads();
30497 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30498
30499 wxPyEndAllowThreads(__tstate);
30500 if (PyErr_Occurred()) SWIG_fail;
30501 }
30502 {
30503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30504 }
30505 return resultobj;
30506 fail:
30507 return NULL;
30508 }
30509
30510
30511 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30512 PyObject *resultobj;
30513 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30514 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30515 bool result;
30516 PyObject * obj0 = 0 ;
30517 PyObject * obj1 = 0 ;
30518 char *kwnames[] = {
30519 (char *) "self",(char *) "other", NULL
30520 };
30521
30522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30524 if (SWIG_arg_fail(1)) SWIG_fail;
30525 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30526 if (SWIG_arg_fail(2)) SWIG_fail;
30527 {
30528 PyThreadState* __tstate = wxPyBeginAllowThreads();
30529 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30530
30531 wxPyEndAllowThreads(__tstate);
30532 if (PyErr_Occurred()) SWIG_fail;
30533 }
30534 {
30535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30536 }
30537 return resultobj;
30538 fail:
30539 return NULL;
30540 }
30541
30542
30543 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30544 PyObject *resultobj;
30545 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30546 int arg2 ;
30547 PyObject * obj0 = 0 ;
30548 PyObject * obj1 = 0 ;
30549 char *kwnames[] = {
30550 (char *) "self",(char *) "w", NULL
30551 };
30552
30553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30555 if (SWIG_arg_fail(1)) SWIG_fail;
30556 {
30557 arg2 = (int)(SWIG_As_int(obj1));
30558 if (SWIG_arg_fail(2)) SWIG_fail;
30559 }
30560 if (arg1) (arg1)->w = arg2;
30561
30562 Py_INCREF(Py_None); resultobj = Py_None;
30563 return resultobj;
30564 fail:
30565 return NULL;
30566 }
30567
30568
30569 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30570 PyObject *resultobj;
30571 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30572 int result;
30573 PyObject * obj0 = 0 ;
30574 char *kwnames[] = {
30575 (char *) "self", NULL
30576 };
30577
30578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30580 if (SWIG_arg_fail(1)) SWIG_fail;
30581 result = (int) ((arg1)->w);
30582
30583 {
30584 resultobj = SWIG_From_int((int)(result));
30585 }
30586 return resultobj;
30587 fail:
30588 return NULL;
30589 }
30590
30591
30592 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30593 PyObject *resultobj;
30594 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30595 int arg2 ;
30596 PyObject * obj0 = 0 ;
30597 PyObject * obj1 = 0 ;
30598 char *kwnames[] = {
30599 (char *) "self",(char *) "h", NULL
30600 };
30601
30602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30604 if (SWIG_arg_fail(1)) SWIG_fail;
30605 {
30606 arg2 = (int)(SWIG_As_int(obj1));
30607 if (SWIG_arg_fail(2)) SWIG_fail;
30608 }
30609 if (arg1) (arg1)->h = arg2;
30610
30611 Py_INCREF(Py_None); resultobj = Py_None;
30612 return resultobj;
30613 fail:
30614 return NULL;
30615 }
30616
30617
30618 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30619 PyObject *resultobj;
30620 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30621 int result;
30622 PyObject * obj0 = 0 ;
30623 char *kwnames[] = {
30624 (char *) "self", NULL
30625 };
30626
30627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30629 if (SWIG_arg_fail(1)) SWIG_fail;
30630 result = (int) ((arg1)->h);
30631
30632 {
30633 resultobj = SWIG_From_int((int)(result));
30634 }
30635 return resultobj;
30636 fail:
30637 return NULL;
30638 }
30639
30640
30641 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30642 PyObject *resultobj;
30643 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30644 int arg2 ;
30645 PyObject * obj0 = 0 ;
30646 PyObject * obj1 = 0 ;
30647 char *kwnames[] = {
30648 (char *) "self",(char *) "bpp", NULL
30649 };
30650
30651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30653 if (SWIG_arg_fail(1)) SWIG_fail;
30654 {
30655 arg2 = (int)(SWIG_As_int(obj1));
30656 if (SWIG_arg_fail(2)) SWIG_fail;
30657 }
30658 if (arg1) (arg1)->bpp = arg2;
30659
30660 Py_INCREF(Py_None); resultobj = Py_None;
30661 return resultobj;
30662 fail:
30663 return NULL;
30664 }
30665
30666
30667 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30668 PyObject *resultobj;
30669 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30670 int result;
30671 PyObject * obj0 = 0 ;
30672 char *kwnames[] = {
30673 (char *) "self", NULL
30674 };
30675
30676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30678 if (SWIG_arg_fail(1)) SWIG_fail;
30679 result = (int) ((arg1)->bpp);
30680
30681 {
30682 resultobj = SWIG_From_int((int)(result));
30683 }
30684 return resultobj;
30685 fail:
30686 return NULL;
30687 }
30688
30689
30690 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30691 PyObject *resultobj;
30692 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30693 int arg2 ;
30694 PyObject * obj0 = 0 ;
30695 PyObject * obj1 = 0 ;
30696 char *kwnames[] = {
30697 (char *) "self",(char *) "refresh", NULL
30698 };
30699
30700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30702 if (SWIG_arg_fail(1)) SWIG_fail;
30703 {
30704 arg2 = (int)(SWIG_As_int(obj1));
30705 if (SWIG_arg_fail(2)) SWIG_fail;
30706 }
30707 if (arg1) (arg1)->refresh = arg2;
30708
30709 Py_INCREF(Py_None); resultobj = Py_None;
30710 return resultobj;
30711 fail:
30712 return NULL;
30713 }
30714
30715
30716 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30717 PyObject *resultobj;
30718 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30719 int result;
30720 PyObject * obj0 = 0 ;
30721 char *kwnames[] = {
30722 (char *) "self", NULL
30723 };
30724
30725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30727 if (SWIG_arg_fail(1)) SWIG_fail;
30728 result = (int) ((arg1)->refresh);
30729
30730 {
30731 resultobj = SWIG_From_int((int)(result));
30732 }
30733 return resultobj;
30734 fail:
30735 return NULL;
30736 }
30737
30738
30739 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30740 PyObject *obj;
30741 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30742 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30743 Py_INCREF(obj);
30744 return Py_BuildValue((char *)"");
30745 }
30746 static int _wrap_DefaultVideoMode_set(PyObject *) {
30747 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30748 return 1;
30749 }
30750
30751
30752 static PyObject *_wrap_DefaultVideoMode_get(void) {
30753 PyObject *pyobj;
30754
30755 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30756 return pyobj;
30757 }
30758
30759
30760 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30761 PyObject *resultobj;
30762 size_t arg1 = (size_t) 0 ;
30763 wxDisplay *result;
30764 PyObject * obj0 = 0 ;
30765 char *kwnames[] = {
30766 (char *) "index", NULL
30767 };
30768
30769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30770 if (obj0) {
30771 {
30772 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30773 if (SWIG_arg_fail(1)) SWIG_fail;
30774 }
30775 }
30776 {
30777 PyThreadState* __tstate = wxPyBeginAllowThreads();
30778 result = (wxDisplay *)new wxDisplay(arg1);
30779
30780 wxPyEndAllowThreads(__tstate);
30781 if (PyErr_Occurred()) SWIG_fail;
30782 }
30783 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30784 return resultobj;
30785 fail:
30786 return NULL;
30787 }
30788
30789
30790 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30791 PyObject *resultobj;
30792 wxDisplay *arg1 = (wxDisplay *) 0 ;
30793 PyObject * obj0 = 0 ;
30794 char *kwnames[] = {
30795 (char *) "self", NULL
30796 };
30797
30798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30800 if (SWIG_arg_fail(1)) SWIG_fail;
30801 {
30802 PyThreadState* __tstate = wxPyBeginAllowThreads();
30803 delete arg1;
30804
30805 wxPyEndAllowThreads(__tstate);
30806 if (PyErr_Occurred()) SWIG_fail;
30807 }
30808 Py_INCREF(Py_None); resultobj = Py_None;
30809 return resultobj;
30810 fail:
30811 return NULL;
30812 }
30813
30814
30815 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30816 PyObject *resultobj;
30817 size_t result;
30818 char *kwnames[] = {
30819 NULL
30820 };
30821
30822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30823 {
30824 PyThreadState* __tstate = wxPyBeginAllowThreads();
30825 result = (size_t)wxDisplay::GetCount();
30826
30827 wxPyEndAllowThreads(__tstate);
30828 if (PyErr_Occurred()) SWIG_fail;
30829 }
30830 {
30831 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30832 }
30833 return resultobj;
30834 fail:
30835 return NULL;
30836 }
30837
30838
30839 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30840 PyObject *resultobj;
30841 wxPoint *arg1 = 0 ;
30842 int result;
30843 wxPoint temp1 ;
30844 PyObject * obj0 = 0 ;
30845 char *kwnames[] = {
30846 (char *) "pt", NULL
30847 };
30848
30849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30850 {
30851 arg1 = &temp1;
30852 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30853 }
30854 {
30855 PyThreadState* __tstate = wxPyBeginAllowThreads();
30856 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30857
30858 wxPyEndAllowThreads(__tstate);
30859 if (PyErr_Occurred()) SWIG_fail;
30860 }
30861 {
30862 resultobj = SWIG_From_int((int)(result));
30863 }
30864 return resultobj;
30865 fail:
30866 return NULL;
30867 }
30868
30869
30870 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30871 PyObject *resultobj;
30872 wxWindow *arg1 = (wxWindow *) 0 ;
30873 int result;
30874 PyObject * obj0 = 0 ;
30875 char *kwnames[] = {
30876 (char *) "window", NULL
30877 };
30878
30879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30881 if (SWIG_arg_fail(1)) SWIG_fail;
30882 {
30883 PyThreadState* __tstate = wxPyBeginAllowThreads();
30884 result = (int)Display_GetFromWindow(arg1);
30885
30886 wxPyEndAllowThreads(__tstate);
30887 if (PyErr_Occurred()) SWIG_fail;
30888 }
30889 {
30890 resultobj = SWIG_From_int((int)(result));
30891 }
30892 return resultobj;
30893 fail:
30894 return NULL;
30895 }
30896
30897
30898 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30899 PyObject *resultobj;
30900 wxDisplay *arg1 = (wxDisplay *) 0 ;
30901 bool result;
30902 PyObject * obj0 = 0 ;
30903 char *kwnames[] = {
30904 (char *) "self", NULL
30905 };
30906
30907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30909 if (SWIG_arg_fail(1)) SWIG_fail;
30910 {
30911 PyThreadState* __tstate = wxPyBeginAllowThreads();
30912 result = (bool)((wxDisplay const *)arg1)->IsOk();
30913
30914 wxPyEndAllowThreads(__tstate);
30915 if (PyErr_Occurred()) SWIG_fail;
30916 }
30917 {
30918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30919 }
30920 return resultobj;
30921 fail:
30922 return NULL;
30923 }
30924
30925
30926 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30927 PyObject *resultobj;
30928 wxDisplay *arg1 = (wxDisplay *) 0 ;
30929 wxRect result;
30930 PyObject * obj0 = 0 ;
30931 char *kwnames[] = {
30932 (char *) "self", NULL
30933 };
30934
30935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30937 if (SWIG_arg_fail(1)) SWIG_fail;
30938 {
30939 PyThreadState* __tstate = wxPyBeginAllowThreads();
30940 result = ((wxDisplay const *)arg1)->GetGeometry();
30941
30942 wxPyEndAllowThreads(__tstate);
30943 if (PyErr_Occurred()) SWIG_fail;
30944 }
30945 {
30946 wxRect * resultptr;
30947 resultptr = new wxRect((wxRect &)(result));
30948 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30949 }
30950 return resultobj;
30951 fail:
30952 return NULL;
30953 }
30954
30955
30956 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30957 PyObject *resultobj;
30958 wxDisplay *arg1 = (wxDisplay *) 0 ;
30959 wxString result;
30960 PyObject * obj0 = 0 ;
30961 char *kwnames[] = {
30962 (char *) "self", NULL
30963 };
30964
30965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30967 if (SWIG_arg_fail(1)) SWIG_fail;
30968 {
30969 PyThreadState* __tstate = wxPyBeginAllowThreads();
30970 result = ((wxDisplay const *)arg1)->GetName();
30971
30972 wxPyEndAllowThreads(__tstate);
30973 if (PyErr_Occurred()) SWIG_fail;
30974 }
30975 {
30976 #if wxUSE_UNICODE
30977 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30978 #else
30979 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30980 #endif
30981 }
30982 return resultobj;
30983 fail:
30984 return NULL;
30985 }
30986
30987
30988 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30989 PyObject *resultobj;
30990 wxDisplay *arg1 = (wxDisplay *) 0 ;
30991 bool result;
30992 PyObject * obj0 = 0 ;
30993 char *kwnames[] = {
30994 (char *) "self", NULL
30995 };
30996
30997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30999 if (SWIG_arg_fail(1)) SWIG_fail;
31000 {
31001 PyThreadState* __tstate = wxPyBeginAllowThreads();
31002 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
31003
31004 wxPyEndAllowThreads(__tstate);
31005 if (PyErr_Occurred()) SWIG_fail;
31006 }
31007 {
31008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31009 }
31010 return resultobj;
31011 fail:
31012 return NULL;
31013 }
31014
31015
31016 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31017 PyObject *resultobj;
31018 wxDisplay *arg1 = (wxDisplay *) 0 ;
31019 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31020 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31021 PyObject *result;
31022 PyObject * obj0 = 0 ;
31023 PyObject * obj1 = 0 ;
31024 char *kwnames[] = {
31025 (char *) "self",(char *) "mode", NULL
31026 };
31027
31028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31030 if (SWIG_arg_fail(1)) SWIG_fail;
31031 if (obj1) {
31032 {
31033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31034 if (SWIG_arg_fail(2)) SWIG_fail;
31035 if (arg2 == NULL) {
31036 SWIG_null_ref("wxVideoMode");
31037 }
31038 if (SWIG_arg_fail(2)) SWIG_fail;
31039 }
31040 }
31041 {
31042 PyThreadState* __tstate = wxPyBeginAllowThreads();
31043 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31044
31045 wxPyEndAllowThreads(__tstate);
31046 if (PyErr_Occurred()) SWIG_fail;
31047 }
31048 resultobj = result;
31049 return resultobj;
31050 fail:
31051 return NULL;
31052 }
31053
31054
31055 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31056 PyObject *resultobj;
31057 wxDisplay *arg1 = (wxDisplay *) 0 ;
31058 wxVideoMode result;
31059 PyObject * obj0 = 0 ;
31060 char *kwnames[] = {
31061 (char *) "self", NULL
31062 };
31063
31064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31066 if (SWIG_arg_fail(1)) SWIG_fail;
31067 {
31068 PyThreadState* __tstate = wxPyBeginAllowThreads();
31069 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31070
31071 wxPyEndAllowThreads(__tstate);
31072 if (PyErr_Occurred()) SWIG_fail;
31073 }
31074 {
31075 wxVideoMode * resultptr;
31076 resultptr = new wxVideoMode((wxVideoMode &)(result));
31077 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31078 }
31079 return resultobj;
31080 fail:
31081 return NULL;
31082 }
31083
31084
31085 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31086 PyObject *resultobj;
31087 wxDisplay *arg1 = (wxDisplay *) 0 ;
31088 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31089 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31090 bool result;
31091 PyObject * obj0 = 0 ;
31092 PyObject * obj1 = 0 ;
31093 char *kwnames[] = {
31094 (char *) "self",(char *) "mode", NULL
31095 };
31096
31097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31099 if (SWIG_arg_fail(1)) SWIG_fail;
31100 if (obj1) {
31101 {
31102 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31103 if (SWIG_arg_fail(2)) SWIG_fail;
31104 if (arg2 == NULL) {
31105 SWIG_null_ref("wxVideoMode");
31106 }
31107 if (SWIG_arg_fail(2)) SWIG_fail;
31108 }
31109 }
31110 {
31111 PyThreadState* __tstate = wxPyBeginAllowThreads();
31112 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31113
31114 wxPyEndAllowThreads(__tstate);
31115 if (PyErr_Occurred()) SWIG_fail;
31116 }
31117 {
31118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31119 }
31120 return resultobj;
31121 fail:
31122 return NULL;
31123 }
31124
31125
31126 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31127 PyObject *resultobj;
31128 wxDisplay *arg1 = (wxDisplay *) 0 ;
31129 PyObject * obj0 = 0 ;
31130 char *kwnames[] = {
31131 (char *) "self", NULL
31132 };
31133
31134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31136 if (SWIG_arg_fail(1)) SWIG_fail;
31137 {
31138 PyThreadState* __tstate = wxPyBeginAllowThreads();
31139 (arg1)->ResetMode();
31140
31141 wxPyEndAllowThreads(__tstate);
31142 if (PyErr_Occurred()) SWIG_fail;
31143 }
31144 Py_INCREF(Py_None); resultobj = Py_None;
31145 return resultobj;
31146 fail:
31147 return NULL;
31148 }
31149
31150
31151 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31152 PyObject *obj;
31153 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31154 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31155 Py_INCREF(obj);
31156 return Py_BuildValue((char *)"");
31157 }
31158 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31159 PyObject *resultobj;
31160 wxStandardPaths *result;
31161 char *kwnames[] = {
31162 NULL
31163 };
31164
31165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31166 {
31167 PyThreadState* __tstate = wxPyBeginAllowThreads();
31168 result = (wxStandardPaths *)StandardPaths_Get();
31169
31170 wxPyEndAllowThreads(__tstate);
31171 if (PyErr_Occurred()) SWIG_fail;
31172 }
31173 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31174 return resultobj;
31175 fail:
31176 return NULL;
31177 }
31178
31179
31180 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31181 PyObject *resultobj;
31182 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31183 wxString result;
31184 PyObject * obj0 = 0 ;
31185 char *kwnames[] = {
31186 (char *) "self", NULL
31187 };
31188
31189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31191 if (SWIG_arg_fail(1)) SWIG_fail;
31192 {
31193 PyThreadState* __tstate = wxPyBeginAllowThreads();
31194 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31195
31196 wxPyEndAllowThreads(__tstate);
31197 if (PyErr_Occurred()) SWIG_fail;
31198 }
31199 {
31200 #if wxUSE_UNICODE
31201 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31202 #else
31203 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31204 #endif
31205 }
31206 return resultobj;
31207 fail:
31208 return NULL;
31209 }
31210
31211
31212 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31213 PyObject *resultobj;
31214 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31215 wxString result;
31216 PyObject * obj0 = 0 ;
31217 char *kwnames[] = {
31218 (char *) "self", NULL
31219 };
31220
31221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31223 if (SWIG_arg_fail(1)) SWIG_fail;
31224 {
31225 PyThreadState* __tstate = wxPyBeginAllowThreads();
31226 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31227
31228 wxPyEndAllowThreads(__tstate);
31229 if (PyErr_Occurred()) SWIG_fail;
31230 }
31231 {
31232 #if wxUSE_UNICODE
31233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31234 #else
31235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31236 #endif
31237 }
31238 return resultobj;
31239 fail:
31240 return NULL;
31241 }
31242
31243
31244 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31245 PyObject *resultobj;
31246 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31247 wxString result;
31248 PyObject * obj0 = 0 ;
31249 char *kwnames[] = {
31250 (char *) "self", NULL
31251 };
31252
31253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31255 if (SWIG_arg_fail(1)) SWIG_fail;
31256 {
31257 PyThreadState* __tstate = wxPyBeginAllowThreads();
31258 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31259
31260 wxPyEndAllowThreads(__tstate);
31261 if (PyErr_Occurred()) SWIG_fail;
31262 }
31263 {
31264 #if wxUSE_UNICODE
31265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31266 #else
31267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31268 #endif
31269 }
31270 return resultobj;
31271 fail:
31272 return NULL;
31273 }
31274
31275
31276 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31277 PyObject *resultobj;
31278 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31279 wxString result;
31280 PyObject * obj0 = 0 ;
31281 char *kwnames[] = {
31282 (char *) "self", NULL
31283 };
31284
31285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31287 if (SWIG_arg_fail(1)) SWIG_fail;
31288 {
31289 PyThreadState* __tstate = wxPyBeginAllowThreads();
31290 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31291
31292 wxPyEndAllowThreads(__tstate);
31293 if (PyErr_Occurred()) SWIG_fail;
31294 }
31295 {
31296 #if wxUSE_UNICODE
31297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31298 #else
31299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31300 #endif
31301 }
31302 return resultobj;
31303 fail:
31304 return NULL;
31305 }
31306
31307
31308 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31309 PyObject *resultobj;
31310 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31311 wxString result;
31312 PyObject * obj0 = 0 ;
31313 char *kwnames[] = {
31314 (char *) "self", NULL
31315 };
31316
31317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31319 if (SWIG_arg_fail(1)) SWIG_fail;
31320 {
31321 PyThreadState* __tstate = wxPyBeginAllowThreads();
31322 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31323
31324 wxPyEndAllowThreads(__tstate);
31325 if (PyErr_Occurred()) SWIG_fail;
31326 }
31327 {
31328 #if wxUSE_UNICODE
31329 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31330 #else
31331 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31332 #endif
31333 }
31334 return resultobj;
31335 fail:
31336 return NULL;
31337 }
31338
31339
31340 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31341 PyObject *resultobj;
31342 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31343 wxString result;
31344 PyObject * obj0 = 0 ;
31345 char *kwnames[] = {
31346 (char *) "self", NULL
31347 };
31348
31349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31351 if (SWIG_arg_fail(1)) SWIG_fail;
31352 {
31353 PyThreadState* __tstate = wxPyBeginAllowThreads();
31354 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31355
31356 wxPyEndAllowThreads(__tstate);
31357 if (PyErr_Occurred()) SWIG_fail;
31358 }
31359 {
31360 #if wxUSE_UNICODE
31361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31362 #else
31363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31364 #endif
31365 }
31366 return resultobj;
31367 fail:
31368 return NULL;
31369 }
31370
31371
31372 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31373 PyObject *resultobj;
31374 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31375 wxString result;
31376 PyObject * obj0 = 0 ;
31377 char *kwnames[] = {
31378 (char *) "self", NULL
31379 };
31380
31381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31383 if (SWIG_arg_fail(1)) SWIG_fail;
31384 {
31385 PyThreadState* __tstate = wxPyBeginAllowThreads();
31386 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31387
31388 wxPyEndAllowThreads(__tstate);
31389 if (PyErr_Occurred()) SWIG_fail;
31390 }
31391 {
31392 #if wxUSE_UNICODE
31393 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31394 #else
31395 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31396 #endif
31397 }
31398 return resultobj;
31399 fail:
31400 return NULL;
31401 }
31402
31403
31404 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31405 PyObject *resultobj;
31406 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31407 wxString *arg2 = 0 ;
31408 bool temp2 = false ;
31409 PyObject * obj0 = 0 ;
31410 PyObject * obj1 = 0 ;
31411 char *kwnames[] = {
31412 (char *) "self",(char *) "prefix", NULL
31413 };
31414
31415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31417 if (SWIG_arg_fail(1)) SWIG_fail;
31418 {
31419 arg2 = wxString_in_helper(obj1);
31420 if (arg2 == NULL) SWIG_fail;
31421 temp2 = true;
31422 }
31423 {
31424 PyThreadState* __tstate = wxPyBeginAllowThreads();
31425 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31426
31427 wxPyEndAllowThreads(__tstate);
31428 if (PyErr_Occurred()) SWIG_fail;
31429 }
31430 Py_INCREF(Py_None); resultobj = Py_None;
31431 {
31432 if (temp2)
31433 delete arg2;
31434 }
31435 return resultobj;
31436 fail:
31437 {
31438 if (temp2)
31439 delete arg2;
31440 }
31441 return NULL;
31442 }
31443
31444
31445 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31446 PyObject *resultobj;
31447 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31448 wxString result;
31449 PyObject * obj0 = 0 ;
31450 char *kwnames[] = {
31451 (char *) "self", NULL
31452 };
31453
31454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31456 if (SWIG_arg_fail(1)) SWIG_fail;
31457 {
31458 PyThreadState* __tstate = wxPyBeginAllowThreads();
31459 result = wxStandardPaths_GetInstallPrefix(arg1);
31460
31461 wxPyEndAllowThreads(__tstate);
31462 if (PyErr_Occurred()) SWIG_fail;
31463 }
31464 {
31465 #if wxUSE_UNICODE
31466 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31467 #else
31468 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31469 #endif
31470 }
31471 return resultobj;
31472 fail:
31473 return NULL;
31474 }
31475
31476
31477 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31478 PyObject *obj;
31479 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31480 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31481 Py_INCREF(obj);
31482 return Py_BuildValue((char *)"");
31483 }
31484 static PyMethodDef SwigMethods[] = {
31485 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31492 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31500 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31564 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31572 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31590 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31593 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31596 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31599 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31605 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31619 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31625 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31631 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31634 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31648 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31651 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31652 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31655 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31682 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31684 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31686 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31688 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31695 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31701 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31715 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31719 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31722 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31739 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31747 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31794 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31812 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31822 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31838 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31854 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31868 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31878 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31921 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31924 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31927 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31931 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32024 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32025 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32026 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32027 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32044 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32089 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32123 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32131 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32132 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32137 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32146 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32153 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32156 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32159 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32164 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32167 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32171 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32174 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32178 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32179 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32183 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32187 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32191 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32201 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32214 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32215 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32222 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32225 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32230 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32231 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32236 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32239 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32243 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32244 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32245 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32247 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32248 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32249 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32250 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32251 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32252 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32253 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32256 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32257 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32258 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32259 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32260 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32261 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32262 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32263 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32264 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32265 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32266 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32267 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32268 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32271 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32272 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32273 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32274 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32275 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32276 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32277 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32278 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32279 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32280 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32281 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32282 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32283 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32284 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32285 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32286 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32287 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32288 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32289 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32290 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32291 { NULL, NULL, 0, NULL }
32292 };
32293
32294
32295 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32296
32297 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32298 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32299 }
32300 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32301 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32302 }
32303 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32304 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32305 }
32306 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32307 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32308 }
32309 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32310 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32311 }
32312 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32313 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32314 }
32315 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32316 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32317 }
32318 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32319 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32320 }
32321 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32322 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32323 }
32324 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32325 return (void *)((wxEvent *) ((wxPyEvent *) x));
32326 }
32327 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32328 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32329 }
32330 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32331 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32332 }
32333 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32334 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32335 }
32336 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32337 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32338 }
32339 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32340 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32341 }
32342 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32343 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32344 }
32345 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32346 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32347 }
32348 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32349 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32350 }
32351 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32352 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32353 }
32354 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32355 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32356 }
32357 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32358 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32359 }
32360 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32361 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32362 }
32363 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32364 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32365 }
32366 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32367 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32368 }
32369 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32370 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32371 }
32372 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32373 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32374 }
32375 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32376 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32377 }
32378 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32379 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32380 }
32381 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32382 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32383 }
32384 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32385 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32386 }
32387 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32388 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32389 }
32390 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32391 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32392 }
32393 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32394 return (void *)((wxEvent *) ((wxShowEvent *) x));
32395 }
32396 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32397 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32398 }
32399 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32400 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32401 }
32402 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32403 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32404 }
32405 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32406 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32407 }
32408 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32409 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32410 }
32411 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32412 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32413 }
32414 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32415 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32416 }
32417 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32418 return (void *)((wxConfigBase *) ((wxConfig *) x));
32419 }
32420 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32421 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32422 }
32423 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32424 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32425 }
32426 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32427 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32428 }
32429 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32430 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32431 }
32432 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32433 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32434 }
32435 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32436 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32437 }
32438 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32439 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32440 }
32441 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32442 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32443 }
32444 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32445 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32446 }
32447 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32448 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32449 }
32450 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32451 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32452 }
32453 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32454 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32455 }
32456 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32457 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32458 }
32459 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32460 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32461 }
32462 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32463 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32464 }
32465 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32466 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32467 }
32468 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32469 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32470 }
32471 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32472 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32473 }
32474 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32475 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32476 }
32477 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32478 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32479 }
32480 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32481 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32482 }
32483 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32484 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32485 }
32486 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32487 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32488 }
32489 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32490 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32491 }
32492 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32493 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32494 }
32495 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32496 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32497 }
32498 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32499 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32500 }
32501 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32502 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32503 }
32504 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32505 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32506 }
32507 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32508 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32509 }
32510 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32511 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32512 }
32513 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32514 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32515 }
32516 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32517 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32518 }
32519 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32520 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32521 }
32522 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32523 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32524 }
32525 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32526 return (void *)((wxObject *) ((wxSizerItem *) x));
32527 }
32528 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32529 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32530 }
32531 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32532 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32533 }
32534 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32535 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32536 }
32537 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32538 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32539 }
32540 static void *_p_wxSizerTo_p_wxObject(void *x) {
32541 return (void *)((wxObject *) ((wxSizer *) x));
32542 }
32543 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32544 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32545 }
32546 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32547 return (void *)((wxObject *) ((wxFileHistory *) x));
32548 }
32549 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32550 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32551 }
32552 static void *_p_wxEventTo_p_wxObject(void *x) {
32553 return (void *)((wxObject *) ((wxEvent *) x));
32554 }
32555 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32556 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32557 }
32558 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32559 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32560 }
32561 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32562 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32563 }
32564 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32565 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32566 }
32567 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32568 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32569 }
32570 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32571 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32572 }
32573 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32574 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32575 }
32576 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32577 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32578 }
32579 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32580 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32581 }
32582 static void *_p_wxControlTo_p_wxObject(void *x) {
32583 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32584 }
32585 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32586 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32587 }
32588 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32589 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32590 }
32591 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32592 return (void *)((wxObject *) ((wxFSFile *) x));
32593 }
32594 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32595 return (void *)((wxObject *) ((wxClipboard *) x));
32596 }
32597 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32598 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32599 }
32600 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32601 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32602 }
32603 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32604 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32605 }
32606 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32607 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32608 }
32609 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32610 return (void *)((wxObject *) ((wxToolTip *) x));
32611 }
32612 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32613 return (void *)((wxObject *) ((wxMenuItem *) x));
32614 }
32615 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32616 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32617 }
32618 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32619 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32620 }
32621 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32622 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32623 }
32624 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32625 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32626 }
32627 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32628 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32629 }
32630 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32631 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32632 }
32633 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32634 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32635 }
32636 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32637 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32638 }
32639 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32640 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32641 }
32642 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32643 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32644 }
32645 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32646 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32647 }
32648 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32649 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32650 }
32651 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32652 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32653 }
32654 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32655 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32656 }
32657 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32658 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32659 }
32660 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32661 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32662 }
32663 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32664 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32665 }
32666 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32667 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32668 }
32669 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32670 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32671 }
32672 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32673 return (void *)((wxObject *) ((wxImageHandler *) x));
32674 }
32675 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32676 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32677 }
32678 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32679 return (void *)((wxObject *) ((wxEvtHandler *) x));
32680 }
32681 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32682 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32683 }
32684 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32685 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32686 }
32687 static void *_p_wxImageTo_p_wxObject(void *x) {
32688 return (void *)((wxObject *) ((wxImage *) x));
32689 }
32690 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32691 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32692 }
32693 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32694 return (void *)((wxObject *) ((wxSystemOptions *) x));
32695 }
32696 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32697 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32698 }
32699 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32700 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32701 }
32702 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32703 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32704 }
32705 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32706 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32707 }
32708 static void *_p_wxWindowTo_p_wxObject(void *x) {
32709 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32710 }
32711 static void *_p_wxMenuTo_p_wxObject(void *x) {
32712 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32713 }
32714 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32715 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32716 }
32717 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32718 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32719 }
32720 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32721 return (void *)((wxObject *) ((wxFileSystem *) x));
32722 }
32723 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32724 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32725 }
32726 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32727 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32728 }
32729 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32730 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32731 }
32732 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32733 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32734 }
32735 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32736 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32737 }
32738 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32739 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32740 }
32741 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32742 return (void *)((wxObject *) ((wxBusyInfo *) x));
32743 }
32744 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32745 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32746 }
32747 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32748 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32749 }
32750 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32751 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32752 }
32753 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32754 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32755 }
32756 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32757 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32758 }
32759 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32760 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32761 }
32762 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32763 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32764 }
32765 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32766 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32767 }
32768 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32769 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32770 }
32771 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32772 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32773 }
32774 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32775 return (void *)((wxLog *) ((wxLogStderr *) x));
32776 }
32777 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32778 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32779 }
32780 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32781 return (void *)((wxLog *) ((wxLogWindow *) x));
32782 }
32783 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32784 return (void *)((wxLog *) ((wxLogChain *) x));
32785 }
32786 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32787 return (void *)((wxLog *) ((wxLogGui *) x));
32788 }
32789 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32790 return (void *)((wxLog *) ((wxPyLog *) x));
32791 }
32792 static void *_p_wxControlTo_p_wxWindow(void *x) {
32793 return (void *)((wxWindow *) ((wxControl *) x));
32794 }
32795 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32796 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32797 }
32798 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32799 return (void *)((wxWindow *) ((wxMenuBar *) x));
32800 }
32801 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32802 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32803 }
32804 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32805 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32806 }
32807 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}};
32808 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}};
32809 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}};
32810 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}};
32811 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}};
32812 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}};
32813 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}};
32814 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}};
32815 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}};
32816 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}};
32817 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}};
32818 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}};
32819 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}};
32820 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}};
32821 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}};
32822 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}};
32823 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}};
32824 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}};
32825 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}};
32826 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}};
32827 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}};
32828 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}};
32829 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}};
32830 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}};
32831 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}};
32832 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}};
32833 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}};
32834 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}};
32835 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}};
32836 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}};
32837 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}};
32838 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}};
32839 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}};
32840 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}};
32841 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}};
32842 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}};
32843 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}};
32844 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}};
32845 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}};
32846 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}};
32847 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}};
32848 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}};
32849 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}};
32850 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}};
32851 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}};
32852 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}};
32853 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}};
32854 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}};
32855 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}};
32856 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}};
32857 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}};
32858 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}};
32859 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}};
32860 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}};
32861 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}};
32862 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}};
32863 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}};
32864 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}};
32865 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}};
32866 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}};
32867 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}};
32868 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}};
32869 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}};
32870 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}};
32871 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}};
32872 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}};
32873 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}};
32874 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}};
32875 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}};
32876 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}};
32877 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}};
32878 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}};
32879 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}};
32880 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}};
32881 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}};
32882 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}};
32883 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}};
32884 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}};
32885 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}};
32886 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}};
32887 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}};
32888 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}};
32889 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}};
32890 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}};
32891 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}};
32892 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}};
32893 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}};
32894 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}};
32895 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}};
32896 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}};
32897 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}};
32898 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}};
32899 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}};
32900 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}};
32901 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}};
32902 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}};
32903 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}};
32904
32905 static swig_type_info *swig_types_initial[] = {
32906 _swigt__p_wxLogChain,
32907 _swigt__p_wxMutexGuiLocker,
32908 _swigt__p_wxMetafile,
32909 _swigt__p_wxFileHistory,
32910 _swigt__p_wxLog,
32911 _swigt__p_wxMenu,
32912 _swigt__p_wxEvent,
32913 _swigt__p_wxDateTime__TimeZone,
32914 _swigt__p_wxConfigBase,
32915 _swigt__p_wxDisplay,
32916 _swigt__p_wxFileType,
32917 _swigt__p_wxLogGui,
32918 _swigt__p_wxFont,
32919 _swigt__p_wxDataFormat,
32920 _swigt__p_wxTimerEvent,
32921 _swigt__p_wxCaret,
32922 _swigt__ptrdiff_t,
32923 _swigt__std__ptrdiff_t,
32924 _swigt__p_int,
32925 _swigt__p_wxSize,
32926 _swigt__p_wxClipboard,
32927 _swigt__p_wxStopWatch,
32928 _swigt__p_wxDC,
32929 _swigt__p_wxClipboardLocker,
32930 _swigt__p_wxIcon,
32931 _swigt__p_wxLogStderr,
32932 _swigt__p_wxLogTextCtrl,
32933 _swigt__p_wxTextCtrl,
32934 _swigt__p_wxBusyCursor,
32935 _swigt__p_wxBitmapDataObject,
32936 _swigt__p_wxTextDataObject,
32937 _swigt__p_wxDataObject,
32938 _swigt__p_wxPyTextDataObject,
32939 _swigt__p_wxPyBitmapDataObject,
32940 _swigt__p_wxFileDataObject,
32941 _swigt__p_wxCustomDataObject,
32942 _swigt__p_wxURLDataObject,
32943 _swigt__p_wxMetafileDataObject,
32944 _swigt__p_wxSound,
32945 _swigt__p_wxTimerRunner,
32946 _swigt__p_wxLogWindow,
32947 _swigt__p_wxTimeSpan,
32948 _swigt__p_wxArrayString,
32949 _swigt__p_wxWindowDisabler,
32950 _swigt__p_form_ops_t,
32951 _swigt__p_wxToolTip,
32952 _swigt__p_wxDataObjectComposite,
32953 _swigt__p_wxSystemSettings,
32954 _swigt__p_wxFileConfig,
32955 _swigt__p_wxVideoMode,
32956 _swigt__p_wxDataObjectSimple,
32957 _swigt__p_wxPyDataObjectSimple,
32958 _swigt__p_wxDuplexMode,
32959 _swigt__p_wxEvtHandler,
32960 _swigt__p_wxRect,
32961 _swigt__p_char,
32962 _swigt__p_wxSingleInstanceChecker,
32963 _swigt__p_wxStandardPaths,
32964 _swigt__p_wxFileTypeInfo,
32965 _swigt__p_wxFrame,
32966 _swigt__p_wxTimer,
32967 _swigt__p_wxPaperSize,
32968 _swigt__p_wxMimeTypesManager,
32969 _swigt__p_wxPyArtProvider,
32970 _swigt__p_wxPyTipProvider,
32971 _swigt__p_wxTipProvider,
32972 _swigt__p_wxJoystick,
32973 _swigt__p_wxSystemOptions,
32974 _swigt__p_wxPoint,
32975 _swigt__p_wxJoystickEvent,
32976 _swigt__p_wxCursor,
32977 _swigt__p_wxObject,
32978 _swigt__p_wxOutputStream,
32979 _swigt__p_wxDateTime,
32980 _swigt__p_wxPyDropSource,
32981 _swigt__p_unsigned_long,
32982 _swigt__p_wxKillError,
32983 _swigt__p_wxWindow,
32984 _swigt__p_wxString,
32985 _swigt__p_wxPyProcess,
32986 _swigt__p_wxBitmap,
32987 _swigt__p_wxConfig,
32988 _swigt__unsigned_int,
32989 _swigt__p_unsigned_int,
32990 _swigt__p_unsigned_char,
32991 _swigt__p_wxChar,
32992 _swigt__p_wxBusyInfo,
32993 _swigt__p_wxPyDropTarget,
32994 _swigt__p_wxPyTextDropTarget,
32995 _swigt__p_wxPyFileDropTarget,
32996 _swigt__p_wxProcessEvent,
32997 _swigt__p_wxPyLog,
32998 _swigt__p_wxLogNull,
32999 _swigt__p_wxColour,
33000 _swigt__p_wxPyTimer,
33001 _swigt__p_wxConfigPathChanger,
33002 _swigt__p_wxDateSpan,
33003 0
33004 };
33005
33006
33007 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33008
33009 static swig_const_info swig_const_table[] = {
33010 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
33011 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
33012 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
33013 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
33014 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
33015 {0, 0, 0, 0.0, 0, 0}};
33016
33017 #ifdef __cplusplus
33018 }
33019 #endif
33020
33021
33022 #ifdef __cplusplus
33023 extern "C" {
33024 #endif
33025
33026 /* Python-specific SWIG API */
33027 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33028 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33029 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33030
33031 /* -----------------------------------------------------------------------------
33032 * global variable support code.
33033 * ----------------------------------------------------------------------------- */
33034
33035 typedef struct swig_globalvar {
33036 char *name; /* Name of global variable */
33037 PyObject *(*get_attr)(); /* Return the current value */
33038 int (*set_attr)(PyObject *); /* Set the value */
33039 struct swig_globalvar *next;
33040 } swig_globalvar;
33041
33042 typedef struct swig_varlinkobject {
33043 PyObject_HEAD
33044 swig_globalvar *vars;
33045 } swig_varlinkobject;
33046
33047 static PyObject *
33048 swig_varlink_repr(swig_varlinkobject *v) {
33049 v = v;
33050 return PyString_FromString("<Swig global variables>");
33051 }
33052
33053 static int
33054 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33055 swig_globalvar *var;
33056 flags = flags;
33057 fprintf(fp,"Swig global variables { ");
33058 for (var = v->vars; var; var=var->next) {
33059 fprintf(fp,"%s", var->name);
33060 if (var->next) fprintf(fp,", ");
33061 }
33062 fprintf(fp," }\n");
33063 return 0;
33064 }
33065
33066 static PyObject *
33067 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33068 swig_globalvar *var = v->vars;
33069 while (var) {
33070 if (strcmp(var->name,n) == 0) {
33071 return (*var->get_attr)();
33072 }
33073 var = var->next;
33074 }
33075 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33076 return NULL;
33077 }
33078
33079 static int
33080 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33081 swig_globalvar *var = v->vars;
33082 while (var) {
33083 if (strcmp(var->name,n) == 0) {
33084 return (*var->set_attr)(p);
33085 }
33086 var = var->next;
33087 }
33088 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33089 return 1;
33090 }
33091
33092 static PyTypeObject varlinktype = {
33093 PyObject_HEAD_INIT(0)
33094 0, /* Number of items in variable part (ob_size) */
33095 (char *)"swigvarlink", /* Type name (tp_name) */
33096 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33097 0, /* Itemsize (tp_itemsize) */
33098 0, /* Deallocator (tp_dealloc) */
33099 (printfunc) swig_varlink_print, /* Print (tp_print) */
33100 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33101 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33102 0, /* tp_compare */
33103 (reprfunc) swig_varlink_repr, /* tp_repr */
33104 0, /* tp_as_number */
33105 0, /* tp_as_sequence */
33106 0, /* tp_as_mapping */
33107 0, /* tp_hash */
33108 0, /* tp_call */
33109 0, /* tp_str */
33110 0, /* tp_getattro */
33111 0, /* tp_setattro */
33112 0, /* tp_as_buffer */
33113 0, /* tp_flags */
33114 0, /* tp_doc */
33115 #if PY_VERSION_HEX >= 0x02000000
33116 0, /* tp_traverse */
33117 0, /* tp_clear */
33118 #endif
33119 #if PY_VERSION_HEX >= 0x02010000
33120 0, /* tp_richcompare */
33121 0, /* tp_weaklistoffset */
33122 #endif
33123 #if PY_VERSION_HEX >= 0x02020000
33124 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33125 #endif
33126 #if PY_VERSION_HEX >= 0x02030000
33127 0, /* tp_del */
33128 #endif
33129 #ifdef COUNT_ALLOCS
33130 0,0,0,0 /* tp_alloc -> tp_next */
33131 #endif
33132 };
33133
33134 /* Create a variable linking object for use later */
33135 static PyObject *
33136 SWIG_Python_newvarlink(void) {
33137 swig_varlinkobject *result = 0;
33138 result = PyMem_NEW(swig_varlinkobject,1);
33139 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33140 result->ob_type = &varlinktype;
33141 result->vars = 0;
33142 result->ob_refcnt = 0;
33143 Py_XINCREF((PyObject *) result);
33144 return ((PyObject*) result);
33145 }
33146
33147 static void
33148 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33149 swig_varlinkobject *v;
33150 swig_globalvar *gv;
33151 v= (swig_varlinkobject *) p;
33152 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33153 gv->name = (char *) malloc(strlen(name)+1);
33154 strcpy(gv->name,name);
33155 gv->get_attr = get_attr;
33156 gv->set_attr = set_attr;
33157 gv->next = v->vars;
33158 v->vars = gv;
33159 }
33160
33161 /* -----------------------------------------------------------------------------
33162 * constants/methods manipulation
33163 * ----------------------------------------------------------------------------- */
33164
33165 /* Install Constants */
33166 static void
33167 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33168 PyObject *obj = 0;
33169 size_t i;
33170 for (i = 0; constants[i].type; i++) {
33171 switch(constants[i].type) {
33172 case SWIG_PY_INT:
33173 obj = PyInt_FromLong(constants[i].lvalue);
33174 break;
33175 case SWIG_PY_FLOAT:
33176 obj = PyFloat_FromDouble(constants[i].dvalue);
33177 break;
33178 case SWIG_PY_STRING:
33179 if (constants[i].pvalue) {
33180 obj = PyString_FromString((char *) constants[i].pvalue);
33181 } else {
33182 Py_INCREF(Py_None);
33183 obj = Py_None;
33184 }
33185 break;
33186 case SWIG_PY_POINTER:
33187 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33188 break;
33189 case SWIG_PY_BINARY:
33190 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33191 break;
33192 default:
33193 obj = 0;
33194 break;
33195 }
33196 if (obj) {
33197 PyDict_SetItemString(d,constants[i].name,obj);
33198 Py_DECREF(obj);
33199 }
33200 }
33201 }
33202
33203 /* -----------------------------------------------------------------------------*/
33204 /* Fix SwigMethods to carry the callback ptrs when needed */
33205 /* -----------------------------------------------------------------------------*/
33206
33207 static void
33208 SWIG_Python_FixMethods(PyMethodDef *methods,
33209 swig_const_info *const_table,
33210 swig_type_info **types,
33211 swig_type_info **types_initial) {
33212 size_t i;
33213 for (i = 0; methods[i].ml_name; ++i) {
33214 char *c = methods[i].ml_doc;
33215 if (c && (c = strstr(c, "swig_ptr: "))) {
33216 int j;
33217 swig_const_info *ci = 0;
33218 char *name = c + 10;
33219 for (j = 0; const_table[j].type; j++) {
33220 if (strncmp(const_table[j].name, name,
33221 strlen(const_table[j].name)) == 0) {
33222 ci = &(const_table[j]);
33223 break;
33224 }
33225 }
33226 if (ci) {
33227 size_t shift = (ci->ptype) - types;
33228 swig_type_info *ty = types_initial[shift];
33229 size_t ldoc = (c - methods[i].ml_doc);
33230 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33231 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33232 char *buff = ndoc;
33233 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33234 strncpy(buff, methods[i].ml_doc, ldoc);
33235 buff += ldoc;
33236 strncpy(buff, "swig_ptr: ", 10);
33237 buff += 10;
33238 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33239 methods[i].ml_doc = ndoc;
33240 }
33241 }
33242 }
33243 }
33244
33245 /* -----------------------------------------------------------------------------*
33246 * Initialize type list
33247 * -----------------------------------------------------------------------------*/
33248
33249 #if PY_MAJOR_VERSION < 2
33250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33251 is copied out of Python/modsupport.c in python version 2.3.4 */
33252 static int
33253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33254 {
33255 PyObject *dict;
33256 if (!PyModule_Check(m)) {
33257 PyErr_SetString(PyExc_TypeError,
33258 "PyModule_AddObject() needs module as first arg");
33259 return -1;
33260 }
33261 if (!o) {
33262 PyErr_SetString(PyExc_TypeError,
33263 "PyModule_AddObject() needs non-NULL value");
33264 return -1;
33265 }
33266
33267 dict = PyModule_GetDict(m);
33268 if (dict == NULL) {
33269 /* Internal error -- modules must have a dict! */
33270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33271 PyModule_GetName(m));
33272 return -1;
33273 }
33274 if (PyDict_SetItemString(dict, name, o))
33275 return -1;
33276 Py_DECREF(o);
33277 return 0;
33278 }
33279 #endif
33280
33281 static swig_type_info **
33282 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33283 static PyMethodDef swig_empty_runtime_method_table[] = {
33284 {
33285 NULL, NULL, 0, NULL
33286 }
33287 };/* Sentinel */
33288
33289 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33290 swig_empty_runtime_method_table);
33291 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33292 if (pointer && module) {
33293 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33294 }
33295 return type_list_handle;
33296 }
33297
33298 static swig_type_info **
33299 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33300 swig_type_info **type_pointer;
33301
33302 /* first check if module already created */
33303 type_pointer = SWIG_Python_GetTypeListHandle();
33304 if (type_pointer) {
33305 return type_pointer;
33306 } else {
33307 /* create a new module and variable */
33308 return SWIG_Python_SetTypeListHandle(type_list_handle);
33309 }
33310 }
33311
33312 #ifdef __cplusplus
33313 }
33314 #endif
33315
33316 /* -----------------------------------------------------------------------------*
33317 * Partial Init method
33318 * -----------------------------------------------------------------------------*/
33319
33320 #ifdef SWIG_LINK_RUNTIME
33321 #ifdef __cplusplus
33322 extern "C"
33323 #endif
33324 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33325 #endif
33326
33327 #ifdef __cplusplus
33328 extern "C"
33329 #endif
33330 SWIGEXPORT(void) SWIG_init(void) {
33331 static PyObject *SWIG_globals = 0;
33332 static int typeinit = 0;
33333 PyObject *m, *d;
33334 int i;
33335 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33336
33337 /* Fix SwigMethods to carry the callback ptrs when needed */
33338 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33339
33340 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33341 d = PyModule_GetDict(m);
33342
33343 if (!typeinit) {
33344 #ifdef SWIG_LINK_RUNTIME
33345 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33346 #else
33347 # ifndef SWIG_STATIC_RUNTIME
33348 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33349 # endif
33350 #endif
33351 for (i = 0; swig_types_initial[i]; i++) {
33352 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33353 }
33354 typeinit = 1;
33355 }
33356 SWIG_InstallConstants(d,swig_const_table);
33357
33358 {
33359 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33360 }
33361 {
33362 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33363 }
33364 {
33365 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33366 }
33367 {
33368 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33369 }
33370 {
33371 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33372 }
33373 {
33374 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33375 }
33376 {
33377 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33378 }
33379 {
33380 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33381 }
33382 {
33383 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33384 }
33385 {
33386 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33387 }
33388 {
33389 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33390 }
33391 {
33392 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33393 }
33394 {
33395 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33396 }
33397 {
33398 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33399 }
33400 {
33401 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33402 }
33403 {
33404 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33405 }
33406 {
33407 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33408 }
33409 {
33410 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33411 }
33412 {
33413 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33414 }
33415 {
33416 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33417 }
33418 {
33419 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33420 }
33421 {
33422 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33423 }
33424 {
33425 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33426 }
33427 {
33428 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33429 }
33430 {
33431 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33432 }
33433 {
33434 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33435 }
33436 {
33437 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33438 }
33439 {
33440 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33441 }
33442 {
33443 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33444 }
33445 {
33446 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33447 }
33448 {
33449 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33450 }
33451 {
33452 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33453 }
33454 {
33455 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33456 }
33457 {
33458 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33459 }
33460 {
33461 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33462 }
33463 {
33464 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33465 }
33466 {
33467 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33468 }
33469 {
33470 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33471 }
33472 {
33473 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33474 }
33475 {
33476 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33477 }
33478 {
33479 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33480 }
33481 {
33482 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33483 }
33484 {
33485 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33486 }
33487 {
33488 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33489 }
33490 {
33491 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33492 }
33493 {
33494 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33495 }
33496 {
33497 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33498 }
33499 {
33500 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33501 }
33502 {
33503 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33504 }
33505 {
33506 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33507 }
33508 {
33509 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33510 }
33511 {
33512 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33513 }
33514 {
33515 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33516 }
33517 {
33518 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33519 }
33520 {
33521 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33522 }
33523 {
33524 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33525 }
33526 {
33527 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33528 }
33529 {
33530 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33531 }
33532 {
33533 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33534 }
33535 {
33536 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33537 }
33538 {
33539 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33540 }
33541 {
33542 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33543 }
33544 {
33545 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33546 }
33547 {
33548 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33549 }
33550 {
33551 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33552 }
33553 {
33554 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33555 }
33556 {
33557 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33558 }
33559 {
33560 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33561 }
33562 {
33563 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33564 }
33565 {
33566 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33567 }
33568 {
33569 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33570 }
33571 {
33572 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33573 }
33574 {
33575 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33576 }
33577 {
33578 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33579 }
33580 {
33581 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33582 }
33583 {
33584 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33585 }
33586 {
33587 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33588 }
33589 {
33590 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33591 }
33592 {
33593 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33594 }
33595 {
33596 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33597 }
33598 {
33599 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33600 }
33601 {
33602 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33603 }
33604 {
33605 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33606 }
33607 {
33608 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33609 }
33610 {
33611 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33612 }
33613 {
33614 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33615 }
33616 {
33617 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33618 }
33619 {
33620 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33621 }
33622 {
33623 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33624 }
33625 {
33626 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33627 }
33628 {
33629 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33630 }
33631 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33632 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33633 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33634 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33635 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33636 {
33637 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33638 }
33639 {
33640 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33641 }
33642 {
33643 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33644 }
33645 {
33646 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33647 }
33648 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33649
33650 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33651
33652 {
33653 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33654 }
33655 {
33656 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33657 }
33658 {
33659 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33660 }
33661 {
33662 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33663 }
33664 {
33665 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33666 }
33667 {
33668 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33669 }
33670 {
33671 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33672 }
33673 {
33674 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33675 }
33676 {
33677 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33678 }
33679 {
33680 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33681 }
33682 {
33683 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33684 }
33685 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33686 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33687 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33688 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33689 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33690 {
33691 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33692 }
33693 {
33694 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33695 }
33696 {
33697 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33698 }
33699 {
33700 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33701 }
33702 {
33703 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33704 }
33705 {
33706 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33707 }
33708 {
33709 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33710 }
33711 {
33712 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33713 }
33714 {
33715 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33716 }
33717 {
33718 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33719 }
33720 {
33721 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33722 }
33723 {
33724 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33725 }
33726 {
33727 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33728 }
33729 {
33730 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33731 }
33732 {
33733 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33734 }
33735 {
33736 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33737 }
33738 {
33739 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33740 }
33741 {
33742 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33743 }
33744 {
33745 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33746 }
33747 {
33748 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33749 }
33750 {
33751 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33752 }
33753 {
33754 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33755 }
33756 {
33757 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33758 }
33759 {
33760 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33761 }
33762 {
33763 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33764 }
33765 {
33766 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33767 }
33768 {
33769 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33770 }
33771 {
33772 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33773 }
33774 {
33775 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33776 }
33777 {
33778 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33779 }
33780 {
33781 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33782 }
33783 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33784 {
33785 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33786 }
33787 {
33788 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33789 }
33790 {
33791 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33792 }
33793 {
33794 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33795 }
33796 {
33797 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33798 }
33799
33800 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33801
33802 {
33803 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33804 }
33805 {
33806 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33807 }
33808 {
33809 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33810 }
33811 {
33812 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33813 }
33814 {
33815 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33816 }
33817 {
33818 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33819 }
33820 {
33821 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33822 }
33823 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33824 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33825 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33826 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33827 {
33828 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33829 }
33830 {
33831 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33832 }
33833 {
33834 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33835 }
33836 {
33837 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33838 }
33839 {
33840 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33841 }
33842 {
33843 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33844 }
33845 {
33846 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33847 }
33848 {
33849 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33850 }
33851 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33852 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33853 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33854 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33855 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33856 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33857 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33858 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33859 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33860 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33861 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33862 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33863 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33864 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33865 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33866 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33867 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33868 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33869 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33870 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33871 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33872 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33873 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33874 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33875 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33876 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33877 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33878 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33879 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33880 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33881 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33882 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33883 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33884 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33885 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33886 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33887 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33888 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33889 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33890 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33891 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33892 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33893 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33894 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33895 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33896 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33897 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33898 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33899 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33900 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33901 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33902 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33903 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33904 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33905 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33906 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33907
33908 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33909
33910 {
33911 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33912 }
33913 {
33914 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33915 }
33916 {
33917 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33918 }
33919 {
33920 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33921 }
33922 {
33923 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33924 }
33925 {
33926 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33927 }
33928 {
33929 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33930 }
33931 {
33932 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33933 }
33934 {
33935 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33936 }
33937 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33938 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33939 {
33940 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33941 }
33942 {
33943 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33944 }
33945 {
33946 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33947 }
33948 {
33949 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33950 }
33951 {
33952 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33953 }
33954 {
33955 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33956 }
33957 {
33958 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33959 }
33960 {
33961 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33962 }
33963 {
33964 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33965 }
33966 {
33967 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33968 }
33969 {
33970 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33971 }
33972 {
33973 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33974 }
33975 {
33976 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33977 }
33978 {
33979 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33980 }
33981 {
33982 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33983 }
33984 {
33985 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33986 }
33987 {
33988 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33989 }
33990 {
33991 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33992 }
33993 {
33994 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33995 }
33996 {
33997 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33998 }
33999 {
34000 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
34001 }
34002 {
34003 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
34004 }
34005 {
34006 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
34007 }
34008 {
34009 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
34010 }
34011 {
34012 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
34013 }
34014 {
34015 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
34016 }
34017 {
34018 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34019 }
34020 {
34021 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34022 }
34023 {
34024 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34025 }
34026 {
34027 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34028 }
34029 {
34030 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34031 }
34032 {
34033 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34034 }
34035 {
34036 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34037 }
34038 {
34039 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34040 }
34041 {
34042 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34043 }
34044 {
34045 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34046 }
34047 {
34048 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34049 }
34050 {
34051 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34052 }
34053 {
34054 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34055 }
34056 {
34057 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34058 }
34059 {
34060 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34061 }
34062 {
34063 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34064 }
34065 {
34066 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34067 }
34068 {
34069 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34070 }
34071 {
34072 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34073 }
34074 {
34075 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34076 }
34077 {
34078 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34079 }
34080 {
34081 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34082 }
34083 {
34084 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34085 }
34086 {
34087 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34088 }
34089 {
34090 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34091 }
34092 {
34093 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34094 }
34095 {
34096 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34097 }
34098 {
34099 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34100 }
34101 {
34102 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34103 }
34104 {
34105 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34106 }
34107 {
34108 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34109 }
34110 {
34111 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34112 }
34113 {
34114 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34115 }
34116 {
34117 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34118 }
34119 {
34120 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34121 }
34122 {
34123 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34124 }
34125 {
34126 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34127 }
34128 {
34129 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34130 }
34131 {
34132 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34133 }
34134 {
34135 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34136 }
34137 {
34138 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34139 }
34140 {
34141 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34142 }
34143 {
34144 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34145 }
34146 {
34147 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34148 }
34149 {
34150 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34151 }
34152 {
34153 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34154 }
34155 {
34156 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34157 }
34158 {
34159 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34160 }
34161 {
34162 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34163 }
34164 {
34165 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34166 }
34167 {
34168 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34169 }
34170 {
34171 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34172 }
34173 {
34174 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34175 }
34176 {
34177 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34178 }
34179 {
34180 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34181 }
34182 {
34183 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34184 }
34185 {
34186 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34187 }
34188 {
34189 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34190 }
34191 {
34192 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34193 }
34194 {
34195 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34196 }
34197 {
34198 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34199 }
34200 {
34201 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34202 }
34203 {
34204 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34205 }
34206 {
34207 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34208 }
34209 {
34210 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34211 }
34212 {
34213 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34214 }
34215 {
34216 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34217 }
34218 {
34219 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34220 }
34221 {
34222 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34223 }
34224 {
34225 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34226 }
34227 {
34228 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34229 }
34230 {
34231 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34232 }
34233 {
34234 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34235 }
34236 {
34237 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34238 }
34239 {
34240 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34241 }
34242 {
34243 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34244 }
34245 {
34246 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34247 }
34248 {
34249 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34250 }
34251 {
34252 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34253 }
34254 {
34255 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34256 }
34257 {
34258 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34259 }
34260 {
34261 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34262 }
34263 {
34264 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34265 }
34266 {
34267 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34268 }
34269 {
34270 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34271 }
34272 {
34273 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34274 }
34275 {
34276 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34277 }
34278 {
34279 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34280 }
34281 {
34282 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34283 }
34284 {
34285 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34286 }
34287 {
34288 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34289 }
34290 {
34291 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34292 }
34293 {
34294 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34295 }
34296 {
34297 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34298 }
34299 {
34300 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34301 }
34302 {
34303 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34304 }
34305 {
34306 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34307 }
34308 {
34309 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34310 }
34311 {
34312 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34313 }
34314 {
34315 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34316 }
34317 {
34318 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34319 }
34320 {
34321 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34322 }
34323 {
34324 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34325 }
34326 {
34327 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34328 }
34329 {
34330 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34331 }
34332 {
34333 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34334 }
34335 {
34336 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34337 }
34338 {
34339 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34340 }
34341 {
34342 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34343 }
34344 {
34345 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34346 }
34347 {
34348 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34349 }
34350 {
34351 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34352 }
34353 {
34354 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34355 }
34356 {
34357 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34358 }
34359 {
34360 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34361 }
34362 {
34363 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34364 }
34365 {
34366 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34367 }
34368 {
34369 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34370 }
34371 {
34372 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34373 }
34374 {
34375 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34376 }
34377 {
34378 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34379 }
34380 {
34381 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34382 }
34383 {
34384 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34385 }
34386 {
34387 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34388 }
34389 {
34390 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34391 }
34392 {
34393 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34394 }
34395 {
34396 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34397 }
34398 {
34399 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34400 }
34401 {
34402 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34403 }
34404 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34405 {
34406 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34407 }
34408 {
34409 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34410 }
34411 {
34412 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34413 }
34414 {
34415 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34416 }
34417 {
34418 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34419 }
34420 {
34421 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34422 }
34423 {
34424 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34425 }
34426 {
34427 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34428 }
34429 {
34430 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34431 }
34432 {
34433 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34434 }
34435 {
34436 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34437 }
34438 {
34439 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34440 }
34441 {
34442 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34443 }
34444 {
34445 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34446 }
34447 {
34448 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34449 }
34450 {
34451 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34452 }
34453 {
34454 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34455 }
34456 {
34457 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34458 }
34459 {
34460 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34461 }
34462 {
34463 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34464 }
34465 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34466 {
34467 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34468 }
34469 {
34470 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34471 }
34472 {
34473 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34474 }
34475 {
34476 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34477 }
34478 {
34479 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34480 }
34481 {
34482 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34483 }
34484 {
34485 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34486 }
34487 {
34488 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34489 }
34490 {
34491 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34492 }
34493 {
34494 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34495 }
34496 {
34497 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34498 }
34499 {
34500 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34501 }
34502
34503 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34504 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34505 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34506 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34507
34508 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34509 }
34510
wxWidgets (Impactor)