]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLogChain swig_types[0]
1343 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1344 #define SWIGTYPE_p_wxMetafile swig_types[2]
1345 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1346 #define SWIGTYPE_p_wxLog swig_types[4]
1347 #define SWIGTYPE_p_wxMenu swig_types[5]
1348 #define SWIGTYPE_p_wxEvent swig_types[6]
1349 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1350 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1351 #define SWIGTYPE_p_wxDisplay swig_types[9]
1352 #define SWIGTYPE_p_wxFileType swig_types[10]
1353 #define SWIGTYPE_p_wxLogGui swig_types[11]
1354 #define SWIGTYPE_p_wxFont swig_types[12]
1355 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1356 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1357 #define SWIGTYPE_p_wxCaret swig_types[15]
1358 #define SWIGTYPE_ptrdiff_t swig_types[16]
1359 #define SWIGTYPE_std__ptrdiff_t swig_types[17]
1360 #define SWIGTYPE_p_int swig_types[18]
1361 #define SWIGTYPE_p_wxSize swig_types[19]
1362 #define SWIGTYPE_p_wxClipboard swig_types[20]
1363 #define SWIGTYPE_p_wxStopWatch swig_types[21]
1364 #define SWIGTYPE_p_wxDC swig_types[22]
1365 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
1366 #define SWIGTYPE_p_wxIcon swig_types[24]
1367 #define SWIGTYPE_p_wxLogStderr swig_types[25]
1368 #define SWIGTYPE_p_wxLogTextCtrl swig_types[26]
1369 #define SWIGTYPE_p_wxTextCtrl swig_types[27]
1370 #define SWIGTYPE_p_wxBusyCursor swig_types[28]
1371 #define SWIGTYPE_p_wxBitmapDataObject swig_types[29]
1372 #define SWIGTYPE_p_wxTextDataObject swig_types[30]
1373 #define SWIGTYPE_p_wxDataObject swig_types[31]
1374 #define SWIGTYPE_p_wxPyTextDataObject swig_types[32]
1375 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[33]
1376 #define SWIGTYPE_p_wxFileDataObject swig_types[34]
1377 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
1378 #define SWIGTYPE_p_wxURLDataObject swig_types[36]
1379 #define SWIGTYPE_p_wxMetafileDataObject swig_types[37]
1380 #define SWIGTYPE_p_wxSound swig_types[38]
1381 #define SWIGTYPE_p_wxTimerRunner swig_types[39]
1382 #define SWIGTYPE_p_wxLogWindow swig_types[40]
1383 #define SWIGTYPE_p_wxTimeSpan swig_types[41]
1384 #define SWIGTYPE_p_wxArrayString swig_types[42]
1385 #define SWIGTYPE_p_wxWindowDisabler swig_types[43]
1386 #define SWIGTYPE_p_form_ops_t swig_types[44]
1387 #define SWIGTYPE_p_wxToolTip swig_types[45]
1388 #define SWIGTYPE_p_wxDataObjectComposite swig_types[46]
1389 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1390 #define SWIGTYPE_p_wxFileConfig swig_types[48]
1391 #define SWIGTYPE_p_wxVideoMode swig_types[49]
1392 #define SWIGTYPE_p_wxDataObjectSimple swig_types[50]
1393 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[51]
1394 #define SWIGTYPE_p_wxDuplexMode swig_types[52]
1395 #define SWIGTYPE_p_wxEvtHandler swig_types[53]
1396 #define SWIGTYPE_p_wxRect swig_types[54]
1397 #define SWIGTYPE_p_char swig_types[55]
1398 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[56]
1399 #define SWIGTYPE_p_wxStandardPaths swig_types[57]
1400 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
1401 #define SWIGTYPE_p_wxFrame swig_types[59]
1402 #define SWIGTYPE_p_wxTimer swig_types[60]
1403 #define SWIGTYPE_p_wxPaperSize swig_types[61]
1404 #define SWIGTYPE_p_wxMimeTypesManager swig_types[62]
1405 #define SWIGTYPE_p_wxPyArtProvider swig_types[63]
1406 #define SWIGTYPE_p_wxPyTipProvider swig_types[64]
1407 #define SWIGTYPE_p_wxTipProvider swig_types[65]
1408 #define SWIGTYPE_p_wxJoystick swig_types[66]
1409 #define SWIGTYPE_p_wxSystemOptions swig_types[67]
1410 #define SWIGTYPE_p_wxPoint swig_types[68]
1411 #define SWIGTYPE_p_wxJoystickEvent swig_types[69]
1412 #define SWIGTYPE_p_wxCursor swig_types[70]
1413 #define SWIGTYPE_p_wxObject swig_types[71]
1414 #define SWIGTYPE_p_wxOutputStream swig_types[72]
1415 #define SWIGTYPE_p_wxDateTime swig_types[73]
1416 #define SWIGTYPE_p_wxPyDropSource swig_types[74]
1417 #define SWIGTYPE_p_unsigned_long swig_types[75]
1418 #define SWIGTYPE_p_wxKillError swig_types[76]
1419 #define SWIGTYPE_p_wxWindow swig_types[77]
1420 #define SWIGTYPE_p_wxString swig_types[78]
1421 #define SWIGTYPE_p_wxPyProcess swig_types[79]
1422 #define SWIGTYPE_p_wxBitmap swig_types[80]
1423 #define SWIGTYPE_p_wxConfig swig_types[81]
1424 #define SWIGTYPE_unsigned_int swig_types[82]
1425 #define SWIGTYPE_p_unsigned_int swig_types[83]
1426 #define SWIGTYPE_p_unsigned_char swig_types[84]
1427 #define SWIGTYPE_p_wxChar swig_types[85]
1428 #define SWIGTYPE_p_wxBusyInfo swig_types[86]
1429 #define SWIGTYPE_p_wxPyDropTarget swig_types[87]
1430 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[88]
1431 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[89]
1432 #define SWIGTYPE_p_wxProcessEvent swig_types[90]
1433 #define SWIGTYPE_p_wxPyLog swig_types[91]
1434 #define SWIGTYPE_p_wxLogNull swig_types[92]
1435 #define SWIGTYPE_p_wxColour swig_types[93]
1436 #define SWIGTYPE_p_wxPyTimer swig_types[94]
1437 #define SWIGTYPE_p_wxConfigPathChanger swig_types[95]
1438 #define SWIGTYPE_p_wxDateSpan swig_types[96]
1439 static swig_type_info *swig_types[98];
1440
1441 /* -------- TYPES TABLE (END) -------- */
1442
1443
1444 /*-----------------------------------------------
1445 @(target):= _misc_.so
1446 ------------------------------------------------*/
1447 #define SWIG_init init_misc_
1448
1449 #define SWIG_name "_misc_"
1450
1451 #include "wx/wxPython/wxPython.h"
1452 #include "wx/wxPython/pyclasses.h"
1453 #include "wx/wxPython/pyistream.h"
1454
1455 static const wxString wxPyEmptyString(wxEmptyString);
1456
1457
1458
1459 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1460 #define SWIG_From_int PyInt_FromLong
1461 /*@@*/
1462
1463
1464 #include <limits.h>
1465
1466
1467 SWIGINTERN int
1468 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1469 const char *errmsg)
1470 {
1471 if (value < min_value) {
1472 if (errmsg) {
1473 PyErr_Format(PyExc_OverflowError,
1474 "value %ld is less than '%s' minimum %ld",
1475 value, errmsg, min_value);
1476 }
1477 return 0;
1478 } else if (value > max_value) {
1479 if (errmsg) {
1480 PyErr_Format(PyExc_OverflowError,
1481 "value %ld is greater than '%s' maximum %ld",
1482 value, errmsg, max_value);
1483 }
1484 return 0;
1485 }
1486 return 1;
1487 }
1488
1489
1490 SWIGINTERN int
1491 SWIG_AsVal_long(PyObject* obj, long* val)
1492 {
1493 if (PyNumber_Check(obj)) {
1494 if (val) *val = PyInt_AsLong(obj);
1495 return 1;
1496 }
1497 else {
1498 SWIG_type_error("number", obj);
1499 }
1500 return 0;
1501 }
1502
1503
1504 #if INT_MAX != LONG_MAX
1505 SWIGINTERN int
1506 SWIG_AsVal_int(PyObject *obj, int *val)
1507 {
1508 const char* errmsg = val ? "int" : (char*)0;
1509 long v;
1510 if (SWIG_AsVal_long(obj, &v)) {
1511 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1512 if (val) *val = (int)(v);
1513 return 1;
1514 } else {
1515 return 0;
1516 }
1517 } else {
1518 PyErr_Clear();
1519 }
1520 if (val) {
1521 SWIG_type_error(errmsg, obj);
1522 }
1523 return 0;
1524 }
1525 #else
1526 SWIGINTERNSHORT int
1527 SWIG_AsVal_int(PyObject *obj, int *val)
1528 {
1529 return SWIG_AsVal_long(obj,(long*)val);
1530 }
1531 #endif
1532
1533
1534 SWIGINTERNSHORT int
1535 SWIG_As_int(PyObject* obj)
1536 {
1537 int v;
1538 if (!SWIG_AsVal_int(obj, &v)) {
1539 /*
1540 this is needed to make valgrind/purify happier.
1541 */
1542 memset((void*)&v, 0, sizeof(int));
1543 }
1544 return v;
1545 }
1546
1547
1548 SWIGINTERNSHORT int
1549 SWIG_Check_int(PyObject* obj)
1550 {
1551 return SWIG_AsVal_int(obj, (int*)0);
1552 }
1553
1554 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1555
1556 #include <wx/stockitem.h>
1557
1558 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1559 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1560 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1561
1562 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1563 #define SWIG_From_long PyInt_FromLong
1564 /*@@*/
1565
1566
1567 SWIGINTERNSHORT long
1568 SWIG_As_long(PyObject* obj)
1569 {
1570 long v;
1571 if (!SWIG_AsVal_long(obj, &v)) {
1572 /*
1573 this is needed to make valgrind/purify happier.
1574 */
1575 memset((void*)&v, 0, sizeof(long));
1576 }
1577 return v;
1578 }
1579
1580
1581 SWIGINTERNSHORT int
1582 SWIG_Check_long(PyObject* obj)
1583 {
1584 return SWIG_AsVal_long(obj, (long*)0);
1585 }
1586
1587
1588 SWIGINTERN int
1589 SWIG_AsVal_bool(PyObject *obj, bool *val)
1590 {
1591 if (obj == Py_True) {
1592 if (val) *val = true;
1593 return 1;
1594 }
1595 if (obj == Py_False) {
1596 if (val) *val = false;
1597 return 1;
1598 }
1599 int res = 0;
1600 if (SWIG_AsVal_int(obj, &res)) {
1601 if (val) *val = res ? true : false;
1602 return 1;
1603 } else {
1604 PyErr_Clear();
1605 }
1606 if (val) {
1607 SWIG_type_error("bool", obj);
1608 }
1609 return 0;
1610 }
1611
1612
1613 SWIGINTERNSHORT bool
1614 SWIG_As_bool(PyObject* obj)
1615 {
1616 bool v;
1617 if (!SWIG_AsVal_bool(obj, &v)) {
1618 /*
1619 this is needed to make valgrind/purify happier.
1620 */
1621 memset((void*)&v, 0, sizeof(bool));
1622 }
1623 return v;
1624 }
1625
1626
1627 SWIGINTERNSHORT int
1628 SWIG_Check_bool(PyObject* obj)
1629 {
1630 return SWIG_AsVal_bool(obj, (bool*)0);
1631 }
1632
1633
1634 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1635 PyObject* o2;
1636 PyObject* o3;
1637
1638 if (!target) {
1639 target = o;
1640 } else if (target == Py_None) {
1641 Py_DECREF(Py_None);
1642 target = o;
1643 } else {
1644 if (!PyTuple_Check(target)) {
1645 o2 = target;
1646 target = PyTuple_New(1);
1647 PyTuple_SetItem(target, 0, o2);
1648 }
1649 o3 = PyTuple_New(1);
1650 PyTuple_SetItem(o3, 0, o);
1651
1652 o2 = target;
1653 target = PySequence_Concat(o2, o3);
1654 Py_DECREF(o2);
1655 Py_DECREF(o3);
1656 }
1657 return target;
1658 }
1659
1660
1661
1662 SWIGINTERN int
1663 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1664 {
1665 long v = 0;
1666 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1667 SWIG_type_error("unsigned number", obj);
1668 }
1669 else if (val)
1670 *val = (unsigned long)v;
1671 return 1;
1672 }
1673
1674
1675 SWIGINTERNSHORT unsigned long
1676 SWIG_As_unsigned_SS_long(PyObject* obj)
1677 {
1678 unsigned long v;
1679 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1680 /*
1681 this is needed to make valgrind/purify happier.
1682 */
1683 memset((void*)&v, 0, sizeof(unsigned long));
1684 }
1685 return v;
1686 }
1687
1688
1689 SWIGINTERNSHORT int
1690 SWIG_Check_unsigned_SS_long(PyObject* obj)
1691 {
1692 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1693 }
1694
1695
1696 SWIGINTERNSHORT PyObject*
1697 SWIG_From_unsigned_SS_long(unsigned long value)
1698 {
1699 return (value > LONG_MAX) ?
1700 PyLong_FromUnsignedLong(value)
1701 : PyInt_FromLong((long)(value));
1702 }
1703
1704
1705 bool wxThread_IsMain() {
1706 #ifdef WXP_WITH_THREAD
1707 return wxThread::IsMain();
1708 #else
1709 return true;
1710 #endif
1711 }
1712
1713 static void wxCaret_Destroy(wxCaret *self){
1714 delete self;
1715 }
1716
1717 #include <wx/snglinst.h>
1718
1719
1720 #ifdef __WXMSW__
1721 #include <wx/msw/private.h>
1722 #include <wx/dynload.h>
1723 #endif
1724
1725
1726
1727 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1728 #if 0
1729 , int method
1730 #endif
1731 )
1732 {
1733 #ifdef __WXMSW__
1734 #if 0
1735 switch (method)
1736 {
1737 case 1:
1738 // This one only partially works. Appears to be an undocumented
1739 // "standard" convention that not all widgets adhear to. For
1740 // example, for some widgets backgrounds or non-client areas may
1741 // not be painted.
1742 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1743 break;
1744
1745 case 2:
1746 #endif
1747 // This one works much better, nearly all widgets and their
1748 // children are captured correctly[**]. Prior to the big
1749 // background erase changes that Vadim did in 2004-2005 this
1750 // method failed badly on XP with Themes activated, most native
1751 // widgets draw only partially, if at all. Without themes it
1752 // worked just like on Win2k. After those changes this method
1753 // works very well.
1754 //
1755 // ** For example the radio buttons in a wxRadioBox are not its
1756 // children by default, but you can capture it via the panel
1757 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1758 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1759 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1760 PRF_ERASEBKGND | PRF_OWNED );
1761 return true;
1762 #if 0
1763 break;
1764
1765 case 3:
1766 // This one is only defined in the latest SDK and is only
1767 // available on XP. MSDN says it is similar to sending WM_PRINT
1768 // so I expect that it will work similar to the above. Since it
1769 // is avaialble only on XP, it can't be compiled like this and
1770 // will have to be loaded dynamically.
1771 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1772
1773 // fall through
1774
1775 case 4:
1776 // Use PrintWindow if available, or fallback to WM_PRINT
1777 // otherwise. Unfortunately using PrintWindow is even worse than
1778 // WM_PRINT. For most native widgets nothing is drawn to the dc
1779 // at all, with or without Themes.
1780 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1781 static bool s_triedToLoad = false;
1782 static PrintWindow_t pfnPrintWindow = NULL;
1783 if ( !s_triedToLoad )
1784 {
1785
1786 s_triedToLoad = true;
1787 wxDynamicLibrary dllUser32(_T("user32.dll"));
1788 if ( dllUser32.IsLoaded() )
1789 {
1790 wxLogNull nolog; // Don't report errors here
1791 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1792 }
1793 }
1794 if (pfnPrintWindow)
1795 {
1796 //printf("Using PrintWindow\n");
1797 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1798 }
1799 else
1800 {
1801 //printf("Using WM_PRINT\n");
1802 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1803 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1804 PRF_ERASEBKGND | PRF_OWNED );
1805 }
1806 }
1807 #endif // 0
1808 #else
1809 return false;
1810 #endif // __WXMSW__
1811 }
1812
1813
1814
1815 #include <wx/tipdlg.h>
1816
1817
1818 class wxPyTipProvider : public wxTipProvider {
1819 public:
1820 wxPyTipProvider(size_t currentTip)
1821 : wxTipProvider(currentTip) {}
1822
1823 DEC_PYCALLBACK_STRING__pure(GetTip);
1824 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1825 PYPRIVATE;
1826 };
1827
1828 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1829 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1830
1831
1832 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1833
1834 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1835
1836 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1837 : wxTimer(owner, id)
1838 {
1839 if (owner == NULL) SetOwner(this);
1840 }
1841
1842
1843 void wxPyTimer::Notify() {
1844 bool found;
1845 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1846 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1847 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1848 wxPyEndBlockThreads(blocked);
1849 if (! found)
1850 wxTimer::Notify();
1851 }
1852 void wxPyTimer::base_Notify() {
1853 wxTimer::Notify();
1854 }
1855
1856
1857
1858 SWIGINTERN PyObject *
1859 SWIG_FromCharPtr(const char* cptr)
1860 {
1861 if (cptr) {
1862 size_t size = strlen(cptr);
1863 if (size > INT_MAX) {
1864 return SWIG_NewPointerObj((char*)(cptr),
1865 SWIG_TypeQuery("char *"), 0);
1866 } else {
1867 if (size != 0) {
1868 return PyString_FromStringAndSize(cptr, size);
1869 } else {
1870 return PyString_FromString(cptr);
1871 }
1872 }
1873 }
1874 Py_INCREF(Py_None);
1875 return Py_None;
1876 }
1877
1878
1879 SWIGINTERNSHORT int
1880 SWIG_CheckUnsignedLongInRange(unsigned long value,
1881 unsigned long max_value,
1882 const char *errmsg)
1883 {
1884 if (value > max_value) {
1885 if (errmsg) {
1886 PyErr_Format(PyExc_OverflowError,
1887 "value %lu is greater than '%s' minimum %lu",
1888 value, errmsg, max_value);
1889 }
1890 return 0;
1891 }
1892 return 1;
1893 }
1894
1895
1896 #if UINT_MAX != ULONG_MAX
1897 SWIGINTERN int
1898 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1899 {
1900 const char* errmsg = val ? "unsigned int" : (char*)0;
1901 unsigned long v;
1902 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1903 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1904 if (val) *val = (unsigned int)(v);
1905 return 1;
1906 }
1907 } else {
1908 PyErr_Clear();
1909 }
1910 if (val) {
1911 SWIG_type_error(errmsg, obj);
1912 }
1913 return 0;
1914 }
1915 #else
1916 SWIGINTERNSHORT unsigned int
1917 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1918 {
1919 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1920 }
1921 #endif
1922
1923
1924 SWIGINTERNSHORT unsigned int
1925 SWIG_As_unsigned_SS_int(PyObject* obj)
1926 {
1927 unsigned int v;
1928 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1929 /*
1930 this is needed to make valgrind/purify happier.
1931 */
1932 memset((void*)&v, 0, sizeof(unsigned int));
1933 }
1934 return v;
1935 }
1936
1937
1938 SWIGINTERNSHORT int
1939 SWIG_Check_unsigned_SS_int(PyObject* obj)
1940 {
1941 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1942 }
1943
1944 static wxString Log_TimeStamp(){
1945 wxString msg;
1946 wxLog::TimeStamp(&msg);
1947 return msg;
1948 }
1949 static void wxLog_Destroy(wxLog *self){ delete self; }
1950 // Make somce wrappers that double any % signs so they are 'escaped'
1951 void wxPyLogFatalError(const wxString& msg)
1952 {
1953 wxString m(msg);
1954 m.Replace(wxT("%"), wxT("%%"));
1955 wxLogFatalError(m);
1956 }
1957
1958 void wxPyLogError(const wxString& msg)
1959 {
1960 wxString m(msg);
1961 m.Replace(wxT("%"), wxT("%%"));
1962 wxLogError(m);
1963 }
1964
1965 void wxPyLogWarning(const wxString& msg)
1966 {
1967 wxString m(msg);
1968 m.Replace(wxT("%"), wxT("%%"));
1969 wxLogWarning(m);
1970 }
1971
1972 void wxPyLogMessage(const wxString& msg)
1973 {
1974 wxString m(msg);
1975 m.Replace(wxT("%"), wxT("%%"));
1976 wxLogMessage(m);
1977 }
1978
1979 void wxPyLogInfo(const wxString& msg)
1980 {
1981 wxString m(msg);
1982 m.Replace(wxT("%"), wxT("%%"));
1983 wxLogInfo(m);
1984 }
1985
1986 void wxPyLogDebug(const wxString& msg)
1987 {
1988 wxString m(msg);
1989 m.Replace(wxT("%"), wxT("%%"));
1990 wxLogDebug(m);
1991 }
1992
1993 void wxPyLogVerbose(const wxString& msg)
1994 {
1995 wxString m(msg);
1996 m.Replace(wxT("%"), wxT("%%"));
1997 wxLogVerbose(m);
1998 }
1999
2000 void wxPyLogStatus(const wxString& msg)
2001 {
2002 wxString m(msg);
2003 m.Replace(wxT("%"), wxT("%%"));
2004 wxLogStatus(m);
2005 }
2006
2007 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2008 {
2009 wxString m(msg);
2010 m.Replace(wxT("%"), wxT("%%"));
2011 wxLogStatus(pFrame, m);
2012 }
2013
2014 void wxPyLogSysError(const wxString& msg)
2015 {
2016 wxString m(msg);
2017 m.Replace(wxT("%"), wxT("%%"));
2018 wxLogSysError(m);
2019 }
2020
2021 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2022 {
2023 wxString m(msg);
2024 m.Replace(wxT("%"), wxT("%%"));
2025 wxLogGeneric(level, m);
2026 }
2027
2028 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2029 {
2030 wxString m(msg);
2031 m.Replace(wxT("%"), wxT("%%"));
2032 wxLogTrace(mask, m);
2033 }
2034
2035 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2036 {
2037 wxString m(msg);
2038 m.Replace(wxT("%"), wxT("%%"));
2039 wxLogTrace(mask, m);
2040 }
2041
2042
2043
2044 // A wxLog class that can be derived from in wxPython
2045 class wxPyLog : public wxLog {
2046 public:
2047 wxPyLog() : wxLog() {}
2048
2049 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2050 bool found;
2051 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2052 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2053 PyObject* s = wx2PyString(szString);
2054 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2055 Py_DECREF(s);
2056 }
2057 wxPyEndBlockThreads(blocked);
2058 if (! found)
2059 wxLog::DoLog(level, szString, t);
2060 }
2061
2062 virtual void DoLogString(const wxChar *szString, time_t t) {
2063 bool found;
2064 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2065 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2066 PyObject* s = wx2PyString(szString);
2067 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2068 Py_DECREF(s);
2069 }
2070 wxPyEndBlockThreads(blocked);
2071 if (! found)
2072 wxLog::DoLogString(szString, t);
2073 }
2074
2075 PYPRIVATE;
2076 };
2077
2078
2079
2080
2081 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2082
2083
2084 #include <wx/joystick.h>
2085
2086
2087 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2088 // A C++ stub class for wxJoystick for platforms that don't have it.
2089 class wxJoystick : public wxObject {
2090 public:
2091 wxJoystick(int joystick = wxJOYSTICK1) {
2092 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2093 PyErr_SetString(PyExc_NotImplementedError,
2094 "wxJoystick is not available on this platform.");
2095 wxPyEndBlockThreads(blocked);
2096 }
2097 wxPoint GetPosition() { return wxPoint(-1,-1); }
2098 int GetZPosition() { return -1; }
2099 int GetButtonState() { return -1; }
2100 int GetPOVPosition() { return -1; }
2101 int GetPOVCTSPosition() { return -1; }
2102 int GetRudderPosition() { return -1; }
2103 int GetUPosition() { return -1; }
2104 int GetVPosition() { return -1; }
2105 int GetMovementThreshold() { return -1; }
2106 void SetMovementThreshold(int threshold) {}
2107
2108 bool IsOk(void) { return false; }
2109 int GetNumberJoysticks() { return -1; }
2110 int GetManufacturerId() { return -1; }
2111 int GetProductId() { return -1; }
2112 wxString GetProductName() { return wxEmptyString; }
2113 int GetXMin() { return -1; }
2114 int GetYMin() { return -1; }
2115 int GetZMin() { return -1; }
2116 int GetXMax() { return -1; }
2117 int GetYMax() { return -1; }
2118 int GetZMax() { return -1; }
2119 int GetNumberButtons() { return -1; }
2120 int GetNumberAxes() { return -1; }
2121 int GetMaxButtons() { return -1; }
2122 int GetMaxAxes() { return -1; }
2123 int GetPollingMin() { return -1; }
2124 int GetPollingMax() { return -1; }
2125 int GetRudderMin() { return -1; }
2126 int GetRudderMax() { return -1; }
2127 int GetUMin() { return -1; }
2128 int GetUMax() { return -1; }
2129 int GetVMin() { return -1; }
2130 int GetVMax() { return -1; }
2131
2132 bool HasRudder() { return false; }
2133 bool HasZ() { return false; }
2134 bool HasU() { return false; }
2135 bool HasV() { return false; }
2136 bool HasPOV() { return false; }
2137 bool HasPOV4Dir() { return false; }
2138 bool HasPOVCTS() { return false; }
2139
2140 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2141 bool ReleaseCapture() { return false; }
2142 };
2143 #endif
2144
2145
2146 #include <wx/sound.h>
2147
2148
2149 #if !wxUSE_SOUND
2150 // A C++ stub class for wxWave for platforms that don't have it.
2151 class wxSound : public wxObject
2152 {
2153 public:
2154 wxSound() {
2155 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2156 PyErr_SetString(PyExc_NotImplementedError,
2157 "wxSound is not available on this platform.");
2158 wxPyEndBlockThreads(blocked);
2159 }
2160 wxSound(const wxString&/*, bool*/) {
2161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2162 PyErr_SetString(PyExc_NotImplementedError,
2163 "wxSound is not available on this platform.");
2164 wxPyEndBlockThreads(blocked);
2165 }
2166 wxSound(int, const wxByte*) {
2167 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2168 PyErr_SetString(PyExc_NotImplementedError,
2169 "wxSound is not available on this platform.");
2170 wxPyEndBlockThreads(blocked);
2171 }
2172
2173 ~wxSound() {};
2174
2175 bool Create(const wxString&/*, bool*/) { return false; }
2176 bool Create(int, const wxByte*) { return false; };
2177 bool IsOk() { return false; };
2178 bool Play(unsigned) const { return false; }
2179 static bool Play(const wxString&, unsigned) { return false; }
2180 static void Stop() {}
2181 };
2182
2183 #endif
2184
2185 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2186 if (fileName.Length() == 0)
2187 return new wxSound;
2188 else
2189 return new wxSound(fileName);
2190 }
2191 static wxSound *new_wxSound(PyObject *data){
2192 unsigned char* buffer; int size;
2193 wxSound *sound = NULL;
2194
2195 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2196 if (!PyArg_Parse(data, "t#", &buffer, &size))
2197 goto done;
2198 sound = new wxSound(size, buffer);
2199 done:
2200 wxPyEndBlockThreads(blocked);
2201 return sound;
2202 }
2203 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2204 #ifndef __WXMAC__
2205 unsigned char* buffer;
2206 int size;
2207 bool rv = false;
2208
2209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2210 if (!PyArg_Parse(data, "t#", &buffer, &size))
2211 goto done;
2212 rv = self->Create(size, buffer);
2213 done:
2214 wxPyEndBlockThreads(blocked);
2215 return rv;
2216 #else
2217 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2218 PyErr_SetString(PyExc_NotImplementedError,
2219 "Create from data is not available on this platform.");
2220 wxPyEndBlockThreads(blocked);
2221 return false;
2222 #endif
2223 }
2224
2225 #include <wx/mimetype.h>
2226
2227 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2228 wxString str;
2229 if (self->GetMimeType(&str))
2230 return wx2PyString(str);
2231 else
2232 RETURN_NONE();
2233 }
2234 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2235 wxArrayString arr;
2236 if (self->GetMimeTypes(arr))
2237 return wxArrayString2PyList_helper(arr);
2238 else
2239 RETURN_NONE();
2240 }
2241 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2242 wxArrayString arr;
2243 if (self->GetExtensions(arr))
2244 return wxArrayString2PyList_helper(arr);
2245 else
2246 RETURN_NONE();
2247 }
2248 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2249 wxIconLocation loc;
2250 if (self->GetIcon(&loc))
2251 return new wxIcon(loc);
2252 else
2253 return NULL;
2254 }
2255 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2256 wxIconLocation loc;
2257 if (self->GetIcon(&loc)) {
2258 wxString iconFile = loc.GetFileName();
2259 int iconIndex = -1;
2260
2261
2262
2263 // Make a tuple and put the values in it
2264 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2265 PyObject* tuple = PyTuple_New(3);
2266 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2267 wxT("wxIcon"), true));
2268 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2269 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2270 wxPyEndBlockThreads(blocked);
2271 return tuple;
2272 }
2273 else
2274 RETURN_NONE();
2275 }
2276 static PyObject *wxFileType_GetDescription(wxFileType *self){
2277 wxString str;
2278 if (self->GetDescription(&str))
2279 return wx2PyString(str);
2280 else
2281 RETURN_NONE();
2282 }
2283 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2284 wxString str;
2285 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2286 return wx2PyString(str);
2287 else
2288 RETURN_NONE();
2289 }
2290 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2291 wxString str;
2292 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2293 return wx2PyString(str);
2294 else
2295 RETURN_NONE();
2296 }
2297 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2298 wxArrayString verbs;
2299 wxArrayString commands;
2300 if (self->GetAllCommands(&verbs, &commands,
2301 wxFileType::MessageParameters(filename, mimetype))) {
2302 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2303 PyObject* tuple = PyTuple_New(2);
2304 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2305 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2306 wxPyEndBlockThreads(blocked);
2307 return tuple;
2308 }
2309 else
2310 RETURN_NONE();
2311 }
2312 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2313 return wxFileType::ExpandCommand(command,
2314 wxFileType::MessageParameters(filename, mimetype));
2315 }
2316 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2317 wxArrayString arr;
2318 self->EnumAllFileTypes(arr);
2319 return wxArrayString2PyList_helper(arr);
2320 }
2321
2322 #include <wx/artprov.h>
2323
2324 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2325 static const wxString wxPyART_MENU(wxART_MENU);
2326 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2327 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2328 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2329 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2330 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2331 static const wxString wxPyART_OTHER(wxART_OTHER);
2332 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2333 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2334 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2335 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2336 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2337 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2338 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2339 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2340 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2341 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2342 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2343 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2344 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2345 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2346 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2347 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2348 static const wxString wxPyART_PRINT(wxART_PRINT);
2349 static const wxString wxPyART_HELP(wxART_HELP);
2350 static const wxString wxPyART_TIP(wxART_TIP);
2351 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2352 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2353 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2354 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2355 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2356 static const wxString wxPyART_CDROM(wxART_CDROM);
2357 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2358 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2359 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2360 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2361 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2362 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2363 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2364 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2365 static const wxString wxPyART_ERROR(wxART_ERROR);
2366 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2367 static const wxString wxPyART_WARNING(wxART_WARNING);
2368 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2369 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2370 static const wxString wxPyART_COPY(wxART_COPY);
2371 static const wxString wxPyART_CUT(wxART_CUT);
2372 static const wxString wxPyART_PASTE(wxART_PASTE);
2373 static const wxString wxPyART_DELETE(wxART_DELETE);
2374 static const wxString wxPyART_UNDO(wxART_UNDO);
2375 static const wxString wxPyART_REDO(wxART_REDO);
2376 static const wxString wxPyART_QUIT(wxART_QUIT);
2377 static const wxString wxPyART_FIND(wxART_FIND);
2378 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2379 // Python aware wxArtProvider
2380 class wxPyArtProvider : public wxArtProvider {
2381 public:
2382
2383 virtual wxBitmap CreateBitmap(const wxArtID& id,
2384 const wxArtClient& client,
2385 const wxSize& size) {
2386 wxBitmap rval = wxNullBitmap;
2387 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2388 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2389 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2390 PyObject* ro;
2391 wxBitmap* ptr;
2392 PyObject* s1, *s2;
2393 s1 = wx2PyString(id);
2394 s2 = wx2PyString(client);
2395 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2396 Py_DECREF(so);
2397 Py_DECREF(s1);
2398 Py_DECREF(s2);
2399 if (ro) {
2400 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2401 rval = *ptr;
2402 Py_DECREF(ro);
2403 }
2404 }
2405 wxPyEndBlockThreads(blocked);
2406 return rval;
2407 }
2408
2409 PYPRIVATE;
2410 };
2411
2412 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2413
2414
2415
2416 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2417 PyObject* ret = PyTuple_New(3);
2418 if (ret) {
2419 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2420 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2421 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2422 }
2423 return ret;
2424 }
2425
2426 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2427 bool cont;
2428 long index = 0;
2429 wxString value;
2430
2431 cont = self->GetFirstGroup(value, index);
2432 return __EnumerationHelper(cont, value, index);
2433 }
2434 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2435 bool cont;
2436 wxString value;
2437
2438 cont = self->GetNextGroup(value, index);
2439 return __EnumerationHelper(cont, value, index);
2440 }
2441 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2442 bool cont;
2443 long index = 0;
2444 wxString value;
2445
2446 cont = self->GetFirstEntry(value, index);
2447 return __EnumerationHelper(cont, value, index);
2448 }
2449 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2450 bool cont;
2451 wxString value;
2452
2453 cont = self->GetNextEntry(value, index);
2454 return __EnumerationHelper(cont, value, index);
2455 }
2456 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2457 long rv;
2458 self->Read(key, &rv, defaultVal);
2459 return rv;
2460 }
2461
2462 SWIGINTERN int
2463 SWIG_AsVal_double(PyObject *obj, double* val)
2464 {
2465 if (PyNumber_Check(obj)) {
2466 if (val) *val = PyFloat_AsDouble(obj);
2467 return 1;
2468 }
2469 else {
2470 SWIG_type_error("number", obj);
2471 }
2472 return 0;
2473 }
2474
2475
2476 SWIGINTERNSHORT double
2477 SWIG_As_double(PyObject* obj)
2478 {
2479 double v;
2480 if (!SWIG_AsVal_double(obj, &v)) {
2481 /*
2482 this is needed to make valgrind/purify happier.
2483 */
2484 memset((void*)&v, 0, sizeof(double));
2485 }
2486 return v;
2487 }
2488
2489
2490 SWIGINTERNSHORT int
2491 SWIG_Check_double(PyObject* obj)
2492 {
2493 return SWIG_AsVal_double(obj, (double*)0);
2494 }
2495
2496 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2497 double rv;
2498 self->Read(key, &rv, defaultVal);
2499 return rv;
2500 }
2501
2502 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2503 #define SWIG_From_double PyFloat_FromDouble
2504 /*@@*/
2505
2506 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2507 bool rv;
2508 self->Read(key, &rv, defaultVal);
2509 return rv;
2510 }
2511
2512 #include <wx/datetime.h>
2513
2514 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2515 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2516
2517 #define LOCAL_TZ wxDateTime::Local
2518
2519 static PyObject *DateTime_GetAmPmStrings(){
2520 wxString am;
2521 wxString pm;
2522 wxDateTime::GetAmPmStrings(&am, &pm);
2523 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2524 PyObject* tup = PyTuple_New(2);
2525 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2526 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2527 wxPyEndBlockThreads(blocked);
2528 return tup;
2529 }
2530
2531 #if UINT_MAX < LONG_MAX
2532 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2533 #define SWIG_From_unsigned_SS_int SWIG_From_long
2534 /*@@*/
2535 #else
2536 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2537 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2538 /*@@*/
2539 #endif
2540
2541 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2542 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2543 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2544 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2545 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2546 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2547 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2548 return (*self < *other);
2549 }
2550 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2551 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2552 return (*self <= *other);
2553 }
2554 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2555 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2556 return (*self > *other);
2557 }
2558 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2559 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2560 return (*self >= *other);
2561 }
2562 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2563 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2564 return (*self == *other);
2565 }
2566 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2567 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2568 return (*self != *other);
2569 }
2570 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2571 const wxChar* rv;
2572 const wxChar* _date = date;
2573 rv = self->ParseRfc822Date(_date);
2574 if (rv == NULL) return -1;
2575 return rv - _date;
2576 }
2577 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2578 const wxChar* rv;
2579 const wxChar* _date = date;
2580 rv = self->ParseFormat(_date, format, dateDef);
2581 if (rv == NULL) return -1;
2582 return rv - _date;
2583 }
2584 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2585 const wxChar* rv;
2586 const wxChar* _datetime = datetime;
2587 rv = self->ParseDateTime(_datetime);
2588 if (rv == NULL) return -1;
2589 return rv - _datetime;
2590 }
2591 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2592 const wxChar* rv;
2593 const wxChar* _date = date;
2594 rv = self->ParseDate(_date);
2595 if (rv == NULL) return -1;
2596 return rv - _date;
2597 }
2598 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2599 const wxChar* rv;
2600 const wxChar* _time = time;
2601 rv = self->ParseTime(_time);
2602 if (rv == NULL) return -1;
2603 return rv - _time;
2604 }
2605 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2606 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2607 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2608 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2609 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2610 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2611 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2612 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2613 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2614 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2615 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2616 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2617 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2618 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2619 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2620 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2621
2622 #include <wx/dataobj.h>
2623
2624 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2625 size_t count = self->GetFormatCount(dir);
2626 wxDataFormat* formats = new wxDataFormat[count];
2627 self->GetAllFormats(formats, dir);
2628
2629 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2630 PyObject* list = PyList_New(count);
2631 for (size_t i=0; i<count; i++) {
2632 wxDataFormat* format = new wxDataFormat(formats[i]);
2633 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2634 PyList_Append(list, obj);
2635 Py_DECREF(obj);
2636 }
2637 wxPyEndBlockThreads(blocked);
2638 delete [] formats;
2639 return list;
2640 }
2641 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2642 PyObject* rval = NULL;
2643 size_t size = self->GetDataSize(format);
2644 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2645 if (size) {
2646 char* buf = new char[size];
2647 if (self->GetDataHere(format, buf))
2648 rval = PyString_FromStringAndSize(buf, size);
2649 delete [] buf;
2650 }
2651 if (! rval) {
2652 rval = Py_None;
2653 Py_INCREF(rval);
2654 }
2655 wxPyEndBlockThreads(blocked);
2656 return rval;
2657 }
2658 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2659 bool rval;
2660 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2661 if (PyString_Check(data)) {
2662 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2663 }
2664 else {
2665 // raise a TypeError if not a string
2666 PyErr_SetString(PyExc_TypeError, "String expected.");
2667 rval = false;
2668 }
2669 wxPyEndBlockThreads(blocked);
2670 return rval;
2671 }
2672 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2673 PyObject* rval = NULL;
2674 size_t size = self->GetDataSize();
2675 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2676 if (size) {
2677 char* buf = new char[size];
2678 if (self->GetDataHere(buf))
2679 rval = PyString_FromStringAndSize(buf, size);
2680 delete [] buf;
2681 }
2682 if (! rval) {
2683 rval = Py_None;
2684 Py_INCREF(rval);
2685 }
2686 wxPyEndBlockThreads(blocked);
2687 return rval;
2688 }
2689 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2690 bool rval;
2691 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2692 if (PyString_Check(data)) {
2693 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2694 }
2695 else {
2696 // raise a TypeError if not a string
2697 PyErr_SetString(PyExc_TypeError, "String expected.");
2698 rval = false;
2699 }
2700 wxPyEndBlockThreads(blocked);
2701 return rval;
2702 }
2703 // Create a new class for wxPython to use
2704 class wxPyDataObjectSimple : public wxDataObjectSimple {
2705 public:
2706 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2707 : wxDataObjectSimple(format) {}
2708
2709 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2710 bool GetDataHere(void *buf) const;
2711 bool SetData(size_t len, const void *buf) const;
2712 PYPRIVATE;
2713 };
2714
2715 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2716
2717 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2718 // We need to get the data for this object and write it to buf. I think
2719 // the best way to do this for wxPython is to have the Python method
2720 // return either a string or None and then act appropriately with the
2721 // C++ version.
2722
2723 bool rval = false;
2724 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2725 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2726 PyObject* ro;
2727 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2728 if (ro) {
2729 rval = (ro != Py_None && PyString_Check(ro));
2730 if (rval)
2731 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2732 Py_DECREF(ro);
2733 }
2734 }
2735 wxPyEndBlockThreads(blocked);
2736 return rval;
2737 }
2738
2739 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2740 // For this one we simply need to make a string from buf and len
2741 // and send it to the Python method.
2742 bool rval = false;
2743 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2744 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2745 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2746 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2747 Py_DECREF(data);
2748 }
2749 wxPyEndBlockThreads(blocked);
2750 return rval;
2751 }
2752
2753 // Create a new class for wxPython to use
2754 class wxPyTextDataObject : public wxTextDataObject {
2755 public:
2756 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2757 : wxTextDataObject(text) {}
2758
2759 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2760 DEC_PYCALLBACK_STRING__const(GetText);
2761 DEC_PYCALLBACK__STRING(SetText);
2762 PYPRIVATE;
2763 };
2764
2765 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2766 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2767 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2768
2769
2770 // Create a new class for wxPython to use
2771 class wxPyBitmapDataObject : public wxBitmapDataObject {
2772 public:
2773 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2774 : wxBitmapDataObject(bitmap) {}
2775
2776 wxBitmap GetBitmap() const;
2777 void SetBitmap(const wxBitmap& bitmap);
2778 PYPRIVATE;
2779 };
2780
2781 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2782 wxBitmap* rval = &wxNullBitmap;
2783 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2784 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2785 PyObject* ro;
2786 wxBitmap* ptr;
2787 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2788 if (ro) {
2789 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2790 rval = ptr;
2791 Py_DECREF(ro);
2792 }
2793 }
2794 wxPyEndBlockThreads(blocked);
2795 return *rval;
2796 }
2797
2798 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2799 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2800 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2801 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2802 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2803 Py_DECREF(bo);
2804 }
2805 wxPyEndBlockThreads(blocked);
2806 }
2807
2808 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2809 return new wxCustomDataObject(wxDataFormat(formatName));
2810 }
2811 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2812 bool rval;
2813 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2814 if (PyString_Check(data)) {
2815 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2816 }
2817 else {
2818 // raise a TypeError if not a string
2819 PyErr_SetString(PyExc_TypeError, "String expected.");
2820 rval = false;
2821 }
2822 wxPyEndBlockThreads(blocked);
2823 return rval;
2824 }
2825 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2826 PyObject* obj;
2827 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2828 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2829 wxPyEndBlockThreads(blocked);
2830 return obj;
2831 }
2832
2833 #include <wx/metafile.h>
2834
2835
2836 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2837
2838
2839 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2840 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2841 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2842 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2843 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2844
2845
2846 class wxPyTextDropTarget : public wxTextDropTarget {
2847 public:
2848 wxPyTextDropTarget() {}
2849
2850 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2851
2852 DEC_PYCALLBACK__(OnLeave);
2853 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2854 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2855 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2856 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2857
2858 PYPRIVATE;
2859 };
2860
2861 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2862 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2863 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2864 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2865 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2866 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2867
2868
2869
2870 class wxPyFileDropTarget : public wxFileDropTarget {
2871 public:
2872 wxPyFileDropTarget() {}
2873
2874 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2875
2876 DEC_PYCALLBACK__(OnLeave);
2877 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2878 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2879 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2880 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2881
2882 PYPRIVATE;
2883 };
2884
2885 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2886 const wxArrayString& filenames) {
2887 bool rval = false;
2888 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2889 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2890 PyObject* list = wxArrayString2PyList_helper(filenames);
2891 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2892 Py_DECREF(list);
2893 }
2894 wxPyEndBlockThreads(blocked);
2895 return rval;
2896 }
2897
2898
2899
2900 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2901 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2902 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2903 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2904 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2905
2906
2907
2908
2909 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2910
2911 #include <wx/display.h>
2912
2913 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2914 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2915
2916 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2917 #if !wxUSE_DISPLAY
2918 #include <wx/dynarray.h>
2919 #include <wx/vidmode.h>
2920
2921 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2922 #include "wx/arrimpl.cpp"
2923 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2924 const wxVideoMode wxDefaultVideoMode;
2925
2926 class wxDisplay
2927 {
2928 public:
2929 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2930 ~wxDisplay() {}
2931
2932 static size_t GetCount()
2933 { wxPyRaiseNotImplemented(); return 0; }
2934
2935 static int GetFromPoint(const wxPoint& pt)
2936 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2937 static int GetFromWindow(wxWindow *window)
2938 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2939
2940 virtual bool IsOk() const { return false; }
2941 virtual wxRect GetGeometry() const { wxRect r; return r; }
2942 virtual wxString GetName() const { return wxEmptyString; }
2943 bool IsPrimary() const { return false; }
2944
2945 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2946 { wxArrayVideoModes a; return a; }
2947
2948 virtual wxVideoMode GetCurrentMode() const
2949 { return wxDefaultVideoMode; }
2950
2951 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2952 { return false; }
2953
2954 void ResetMode() {}
2955 };
2956 #endif
2957
2958 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2959 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2960 PyObject* pyList = NULL;
2961 wxArrayVideoModes arr = self->GetModes(mode);
2962 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2963 pyList = PyList_New(0);
2964 for (int i=0; i < arr.GetCount(); i++) {
2965 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2966 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2967 PyList_Append(pyList, pyObj);
2968 Py_DECREF(pyObj);
2969 }
2970 wxPyEndBlockThreads(blocked);
2971 return pyList;
2972 }
2973
2974 #include <wx/stdpaths.h>
2975
2976 static wxStandardPaths *StandardPaths_Get(){
2977 return (wxStandardPaths*) &wxStandardPaths::Get();
2978 }
2979 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2980 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2981 #ifdef __cplusplus
2982 extern "C" {
2983 #endif
2984 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2985 PyObject *resultobj;
2986 wxSystemColour arg1 ;
2987 wxColour result;
2988 PyObject * obj0 = 0 ;
2989 char *kwnames[] = {
2990 (char *) "index", NULL
2991 };
2992
2993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2994 {
2995 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2996 if (SWIG_arg_fail(1)) SWIG_fail;
2997 }
2998 {
2999 if (!wxPyCheckForApp()) SWIG_fail;
3000 PyThreadState* __tstate = wxPyBeginAllowThreads();
3001 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3002
3003 wxPyEndAllowThreads(__tstate);
3004 if (PyErr_Occurred()) SWIG_fail;
3005 }
3006 {
3007 wxColour * resultptr;
3008 resultptr = new wxColour((wxColour &)(result));
3009 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3010 }
3011 return resultobj;
3012 fail:
3013 return NULL;
3014 }
3015
3016
3017 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3018 PyObject *resultobj;
3019 wxSystemFont arg1 ;
3020 wxFont result;
3021 PyObject * obj0 = 0 ;
3022 char *kwnames[] = {
3023 (char *) "index", NULL
3024 };
3025
3026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3027 {
3028 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3029 if (SWIG_arg_fail(1)) SWIG_fail;
3030 }
3031 {
3032 if (!wxPyCheckForApp()) SWIG_fail;
3033 PyThreadState* __tstate = wxPyBeginAllowThreads();
3034 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3035
3036 wxPyEndAllowThreads(__tstate);
3037 if (PyErr_Occurred()) SWIG_fail;
3038 }
3039 {
3040 wxFont * resultptr;
3041 resultptr = new wxFont((wxFont &)(result));
3042 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3043 }
3044 return resultobj;
3045 fail:
3046 return NULL;
3047 }
3048
3049
3050 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3051 PyObject *resultobj;
3052 wxSystemMetric arg1 ;
3053 wxWindow *arg2 = (wxWindow *) NULL ;
3054 int result;
3055 PyObject * obj0 = 0 ;
3056 PyObject * obj1 = 0 ;
3057 char *kwnames[] = {
3058 (char *) "index",(char *) "win", NULL
3059 };
3060
3061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3062 {
3063 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3064 if (SWIG_arg_fail(1)) SWIG_fail;
3065 }
3066 if (obj1) {
3067 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3068 if (SWIG_arg_fail(2)) SWIG_fail;
3069 }
3070 {
3071 if (!wxPyCheckForApp()) SWIG_fail;
3072 PyThreadState* __tstate = wxPyBeginAllowThreads();
3073 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3074
3075 wxPyEndAllowThreads(__tstate);
3076 if (PyErr_Occurred()) SWIG_fail;
3077 }
3078 {
3079 resultobj = SWIG_From_int((int)(result));
3080 }
3081 return resultobj;
3082 fail:
3083 return NULL;
3084 }
3085
3086
3087 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3088 PyObject *resultobj;
3089 wxSystemFeature arg1 ;
3090 bool result;
3091 PyObject * obj0 = 0 ;
3092 char *kwnames[] = {
3093 (char *) "index", NULL
3094 };
3095
3096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3097 {
3098 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3099 if (SWIG_arg_fail(1)) SWIG_fail;
3100 }
3101 {
3102 if (!wxPyCheckForApp()) SWIG_fail;
3103 PyThreadState* __tstate = wxPyBeginAllowThreads();
3104 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3105
3106 wxPyEndAllowThreads(__tstate);
3107 if (PyErr_Occurred()) SWIG_fail;
3108 }
3109 {
3110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3111 }
3112 return resultobj;
3113 fail:
3114 return NULL;
3115 }
3116
3117
3118 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3119 PyObject *resultobj;
3120 wxSystemScreenType result;
3121 char *kwnames[] = {
3122 NULL
3123 };
3124
3125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3126 {
3127 if (!wxPyCheckForApp()) SWIG_fail;
3128 PyThreadState* __tstate = wxPyBeginAllowThreads();
3129 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3130
3131 wxPyEndAllowThreads(__tstate);
3132 if (PyErr_Occurred()) SWIG_fail;
3133 }
3134 resultobj = SWIG_From_int((result));
3135 return resultobj;
3136 fail:
3137 return NULL;
3138 }
3139
3140
3141 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3142 PyObject *resultobj;
3143 wxSystemScreenType arg1 ;
3144 PyObject * obj0 = 0 ;
3145 char *kwnames[] = {
3146 (char *) "screen", NULL
3147 };
3148
3149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3150 {
3151 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3152 if (SWIG_arg_fail(1)) SWIG_fail;
3153 }
3154 {
3155 if (!wxPyCheckForApp()) SWIG_fail;
3156 PyThreadState* __tstate = wxPyBeginAllowThreads();
3157 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3158
3159 wxPyEndAllowThreads(__tstate);
3160 if (PyErr_Occurred()) SWIG_fail;
3161 }
3162 Py_INCREF(Py_None); resultobj = Py_None;
3163 return resultobj;
3164 fail:
3165 return NULL;
3166 }
3167
3168
3169 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3170 PyObject *obj;
3171 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3172 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3173 Py_INCREF(obj);
3174 return Py_BuildValue((char *)"");
3175 }
3176 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3177 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3178 return 1;
3179 }
3180
3181
3182 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3183 PyObject *pyobj;
3184
3185 {
3186 #if wxUSE_UNICODE
3187 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3188 #else
3189 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3190 #endif
3191 }
3192 return pyobj;
3193 }
3194
3195
3196 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3197 PyObject *resultobj;
3198 wxSystemOptions *result;
3199 char *kwnames[] = {
3200 NULL
3201 };
3202
3203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3204 {
3205 PyThreadState* __tstate = wxPyBeginAllowThreads();
3206 result = (wxSystemOptions *)new wxSystemOptions();
3207
3208 wxPyEndAllowThreads(__tstate);
3209 if (PyErr_Occurred()) SWIG_fail;
3210 }
3211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3212 return resultobj;
3213 fail:
3214 return NULL;
3215 }
3216
3217
3218 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3219 PyObject *resultobj;
3220 wxString *arg1 = 0 ;
3221 wxString *arg2 = 0 ;
3222 bool temp1 = false ;
3223 bool temp2 = false ;
3224 PyObject * obj0 = 0 ;
3225 PyObject * obj1 = 0 ;
3226 char *kwnames[] = {
3227 (char *) "name",(char *) "value", NULL
3228 };
3229
3230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3231 {
3232 arg1 = wxString_in_helper(obj0);
3233 if (arg1 == NULL) SWIG_fail;
3234 temp1 = true;
3235 }
3236 {
3237 arg2 = wxString_in_helper(obj1);
3238 if (arg2 == NULL) SWIG_fail;
3239 temp2 = true;
3240 }
3241 {
3242 PyThreadState* __tstate = wxPyBeginAllowThreads();
3243 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3244
3245 wxPyEndAllowThreads(__tstate);
3246 if (PyErr_Occurred()) SWIG_fail;
3247 }
3248 Py_INCREF(Py_None); resultobj = Py_None;
3249 {
3250 if (temp1)
3251 delete arg1;
3252 }
3253 {
3254 if (temp2)
3255 delete arg2;
3256 }
3257 return resultobj;
3258 fail:
3259 {
3260 if (temp1)
3261 delete arg1;
3262 }
3263 {
3264 if (temp2)
3265 delete arg2;
3266 }
3267 return NULL;
3268 }
3269
3270
3271 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3272 PyObject *resultobj;
3273 wxString *arg1 = 0 ;
3274 int arg2 ;
3275 bool temp1 = false ;
3276 PyObject * obj0 = 0 ;
3277 PyObject * obj1 = 0 ;
3278 char *kwnames[] = {
3279 (char *) "name",(char *) "value", NULL
3280 };
3281
3282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3283 {
3284 arg1 = wxString_in_helper(obj0);
3285 if (arg1 == NULL) SWIG_fail;
3286 temp1 = true;
3287 }
3288 {
3289 arg2 = (int)(SWIG_As_int(obj1));
3290 if (SWIG_arg_fail(2)) SWIG_fail;
3291 }
3292 {
3293 PyThreadState* __tstate = wxPyBeginAllowThreads();
3294 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3295
3296 wxPyEndAllowThreads(__tstate);
3297 if (PyErr_Occurred()) SWIG_fail;
3298 }
3299 Py_INCREF(Py_None); resultobj = Py_None;
3300 {
3301 if (temp1)
3302 delete arg1;
3303 }
3304 return resultobj;
3305 fail:
3306 {
3307 if (temp1)
3308 delete arg1;
3309 }
3310 return NULL;
3311 }
3312
3313
3314 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3315 PyObject *resultobj;
3316 wxString *arg1 = 0 ;
3317 wxString result;
3318 bool temp1 = false ;
3319 PyObject * obj0 = 0 ;
3320 char *kwnames[] = {
3321 (char *) "name", NULL
3322 };
3323
3324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3325 {
3326 arg1 = wxString_in_helper(obj0);
3327 if (arg1 == NULL) SWIG_fail;
3328 temp1 = true;
3329 }
3330 {
3331 PyThreadState* __tstate = wxPyBeginAllowThreads();
3332 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3333
3334 wxPyEndAllowThreads(__tstate);
3335 if (PyErr_Occurred()) SWIG_fail;
3336 }
3337 {
3338 #if wxUSE_UNICODE
3339 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3340 #else
3341 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3342 #endif
3343 }
3344 {
3345 if (temp1)
3346 delete arg1;
3347 }
3348 return resultobj;
3349 fail:
3350 {
3351 if (temp1)
3352 delete arg1;
3353 }
3354 return NULL;
3355 }
3356
3357
3358 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3359 PyObject *resultobj;
3360 wxString *arg1 = 0 ;
3361 int result;
3362 bool temp1 = false ;
3363 PyObject * obj0 = 0 ;
3364 char *kwnames[] = {
3365 (char *) "name", NULL
3366 };
3367
3368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3369 {
3370 arg1 = wxString_in_helper(obj0);
3371 if (arg1 == NULL) SWIG_fail;
3372 temp1 = true;
3373 }
3374 {
3375 PyThreadState* __tstate = wxPyBeginAllowThreads();
3376 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3377
3378 wxPyEndAllowThreads(__tstate);
3379 if (PyErr_Occurred()) SWIG_fail;
3380 }
3381 {
3382 resultobj = SWIG_From_int((int)(result));
3383 }
3384 {
3385 if (temp1)
3386 delete arg1;
3387 }
3388 return resultobj;
3389 fail:
3390 {
3391 if (temp1)
3392 delete arg1;
3393 }
3394 return NULL;
3395 }
3396
3397
3398 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3399 PyObject *resultobj;
3400 wxString *arg1 = 0 ;
3401 bool result;
3402 bool temp1 = false ;
3403 PyObject * obj0 = 0 ;
3404 char *kwnames[] = {
3405 (char *) "name", NULL
3406 };
3407
3408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3409 {
3410 arg1 = wxString_in_helper(obj0);
3411 if (arg1 == NULL) SWIG_fail;
3412 temp1 = true;
3413 }
3414 {
3415 PyThreadState* __tstate = wxPyBeginAllowThreads();
3416 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3417
3418 wxPyEndAllowThreads(__tstate);
3419 if (PyErr_Occurred()) SWIG_fail;
3420 }
3421 {
3422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3423 }
3424 {
3425 if (temp1)
3426 delete arg1;
3427 }
3428 return resultobj;
3429 fail:
3430 {
3431 if (temp1)
3432 delete arg1;
3433 }
3434 return NULL;
3435 }
3436
3437
3438 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3439 PyObject *resultobj;
3440 wxString *arg1 = 0 ;
3441 bool result;
3442 bool temp1 = false ;
3443 PyObject * obj0 = 0 ;
3444 char *kwnames[] = {
3445 (char *) "name", NULL
3446 };
3447
3448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3449 {
3450 arg1 = wxString_in_helper(obj0);
3451 if (arg1 == NULL) SWIG_fail;
3452 temp1 = true;
3453 }
3454 {
3455 PyThreadState* __tstate = wxPyBeginAllowThreads();
3456 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3457
3458 wxPyEndAllowThreads(__tstate);
3459 if (PyErr_Occurred()) SWIG_fail;
3460 }
3461 {
3462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3463 }
3464 {
3465 if (temp1)
3466 delete arg1;
3467 }
3468 return resultobj;
3469 fail:
3470 {
3471 if (temp1)
3472 delete arg1;
3473 }
3474 return NULL;
3475 }
3476
3477
3478 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3479 PyObject *obj;
3480 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3481 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3482 Py_INCREF(obj);
3483 return Py_BuildValue((char *)"");
3484 }
3485 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3486 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3487 return 1;
3488 }
3489
3490
3491 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3492 PyObject *pyobj;
3493
3494 {
3495 #if wxUSE_UNICODE
3496 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3497 #else
3498 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3499 #endif
3500 }
3501 return pyobj;
3502 }
3503
3504
3505 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3506 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3507 return 1;
3508 }
3509
3510
3511 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3512 PyObject *pyobj;
3513
3514 {
3515 #if wxUSE_UNICODE
3516 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3517 #else
3518 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3519 #endif
3520 }
3521 return pyobj;
3522 }
3523
3524
3525 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3526 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3527 return 1;
3528 }
3529
3530
3531 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3532 PyObject *pyobj;
3533
3534 {
3535 #if wxUSE_UNICODE
3536 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3537 #else
3538 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3539 #endif
3540 }
3541 return pyobj;
3542 }
3543
3544
3545 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3546 PyObject *resultobj;
3547 long result;
3548 char *kwnames[] = {
3549 NULL
3550 };
3551
3552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3553 {
3554 PyThreadState* __tstate = wxPyBeginAllowThreads();
3555 result = (long)wxNewId();
3556
3557 wxPyEndAllowThreads(__tstate);
3558 if (PyErr_Occurred()) SWIG_fail;
3559 }
3560 {
3561 resultobj = SWIG_From_long((long)(result));
3562 }
3563 return resultobj;
3564 fail:
3565 return NULL;
3566 }
3567
3568
3569 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3570 PyObject *resultobj;
3571 long arg1 ;
3572 PyObject * obj0 = 0 ;
3573 char *kwnames[] = {
3574 (char *) "id", NULL
3575 };
3576
3577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3578 {
3579 arg1 = (long)(SWIG_As_long(obj0));
3580 if (SWIG_arg_fail(1)) SWIG_fail;
3581 }
3582 {
3583 PyThreadState* __tstate = wxPyBeginAllowThreads();
3584 wxRegisterId(arg1);
3585
3586 wxPyEndAllowThreads(__tstate);
3587 if (PyErr_Occurred()) SWIG_fail;
3588 }
3589 Py_INCREF(Py_None); resultobj = Py_None;
3590 return resultobj;
3591 fail:
3592 return NULL;
3593 }
3594
3595
3596 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3597 PyObject *resultobj;
3598 long result;
3599 char *kwnames[] = {
3600 NULL
3601 };
3602
3603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3604 {
3605 PyThreadState* __tstate = wxPyBeginAllowThreads();
3606 result = (long)wxGetCurrentId();
3607
3608 wxPyEndAllowThreads(__tstate);
3609 if (PyErr_Occurred()) SWIG_fail;
3610 }
3611 {
3612 resultobj = SWIG_From_long((long)(result));
3613 }
3614 return resultobj;
3615 fail:
3616 return NULL;
3617 }
3618
3619
3620 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3621 PyObject *resultobj;
3622 int arg1 ;
3623 bool result;
3624 PyObject * obj0 = 0 ;
3625 char *kwnames[] = {
3626 (char *) "id", NULL
3627 };
3628
3629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3630 {
3631 arg1 = (int)(SWIG_As_int(obj0));
3632 if (SWIG_arg_fail(1)) SWIG_fail;
3633 }
3634 {
3635 PyThreadState* __tstate = wxPyBeginAllowThreads();
3636 result = (bool)wxIsStockID(arg1);
3637
3638 wxPyEndAllowThreads(__tstate);
3639 if (PyErr_Occurred()) SWIG_fail;
3640 }
3641 {
3642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3643 }
3644 return resultobj;
3645 fail:
3646 return NULL;
3647 }
3648
3649
3650 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3651 PyObject *resultobj;
3652 int arg1 ;
3653 wxString *arg2 = 0 ;
3654 bool result;
3655 bool temp2 = false ;
3656 PyObject * obj0 = 0 ;
3657 PyObject * obj1 = 0 ;
3658 char *kwnames[] = {
3659 (char *) "id",(char *) "label", NULL
3660 };
3661
3662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3663 {
3664 arg1 = (int)(SWIG_As_int(obj0));
3665 if (SWIG_arg_fail(1)) SWIG_fail;
3666 }
3667 {
3668 arg2 = wxString_in_helper(obj1);
3669 if (arg2 == NULL) SWIG_fail;
3670 temp2 = true;
3671 }
3672 {
3673 PyThreadState* __tstate = wxPyBeginAllowThreads();
3674 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3675
3676 wxPyEndAllowThreads(__tstate);
3677 if (PyErr_Occurred()) SWIG_fail;
3678 }
3679 {
3680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3681 }
3682 {
3683 if (temp2)
3684 delete arg2;
3685 }
3686 return resultobj;
3687 fail:
3688 {
3689 if (temp2)
3690 delete arg2;
3691 }
3692 return NULL;
3693 }
3694
3695
3696 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3697 PyObject *resultobj;
3698 int arg1 ;
3699 bool arg2 = (bool) true ;
3700 wxString arg3 = (wxString) wxPyEmptyString ;
3701 wxString result;
3702 PyObject * obj0 = 0 ;
3703 PyObject * obj1 = 0 ;
3704 PyObject * obj2 = 0 ;
3705 char *kwnames[] = {
3706 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3707 };
3708
3709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3710 {
3711 arg1 = (int)(SWIG_As_int(obj0));
3712 if (SWIG_arg_fail(1)) SWIG_fail;
3713 }
3714 if (obj1) {
3715 {
3716 arg2 = (bool)(SWIG_As_bool(obj1));
3717 if (SWIG_arg_fail(2)) SWIG_fail;
3718 }
3719 }
3720 if (obj2) {
3721 {
3722 wxString* sptr = wxString_in_helper(obj2);
3723 if (sptr == NULL) SWIG_fail;
3724 arg3 = *sptr;
3725 delete sptr;
3726 }
3727 }
3728 {
3729 PyThreadState* __tstate = wxPyBeginAllowThreads();
3730 result = wxGetStockLabel(arg1,arg2,arg3);
3731
3732 wxPyEndAllowThreads(__tstate);
3733 if (PyErr_Occurred()) SWIG_fail;
3734 }
3735 {
3736 #if wxUSE_UNICODE
3737 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3738 #else
3739 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3740 #endif
3741 }
3742 return resultobj;
3743 fail:
3744 return NULL;
3745 }
3746
3747
3748 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3749 PyObject *resultobj;
3750 char *kwnames[] = {
3751 NULL
3752 };
3753
3754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3755 {
3756 if (!wxPyCheckForApp()) SWIG_fail;
3757 PyThreadState* __tstate = wxPyBeginAllowThreads();
3758 wxBell();
3759
3760 wxPyEndAllowThreads(__tstate);
3761 if (PyErr_Occurred()) SWIG_fail;
3762 }
3763 Py_INCREF(Py_None); resultobj = Py_None;
3764 return resultobj;
3765 fail:
3766 return NULL;
3767 }
3768
3769
3770 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3771 PyObject *resultobj;
3772 char *kwnames[] = {
3773 NULL
3774 };
3775
3776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3777 {
3778 if (!wxPyCheckForApp()) SWIG_fail;
3779 PyThreadState* __tstate = wxPyBeginAllowThreads();
3780 wxEndBusyCursor();
3781
3782 wxPyEndAllowThreads(__tstate);
3783 if (PyErr_Occurred()) SWIG_fail;
3784 }
3785 Py_INCREF(Py_None); resultobj = Py_None;
3786 return resultobj;
3787 fail:
3788 return NULL;
3789 }
3790
3791
3792 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3793 PyObject *resultobj;
3794 bool arg1 = (bool) true ;
3795 long result;
3796 PyObject * obj0 = 0 ;
3797 char *kwnames[] = {
3798 (char *) "resetTimer", NULL
3799 };
3800
3801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3802 if (obj0) {
3803 {
3804 arg1 = (bool)(SWIG_As_bool(obj0));
3805 if (SWIG_arg_fail(1)) SWIG_fail;
3806 }
3807 }
3808 {
3809 PyThreadState* __tstate = wxPyBeginAllowThreads();
3810 result = (long)wxGetElapsedTime(arg1);
3811
3812 wxPyEndAllowThreads(__tstate);
3813 if (PyErr_Occurred()) SWIG_fail;
3814 }
3815 {
3816 resultobj = SWIG_From_long((long)(result));
3817 }
3818 return resultobj;
3819 fail:
3820 return NULL;
3821 }
3822
3823
3824 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3825 PyObject *resultobj;
3826 int *arg1 = (int *) 0 ;
3827 int *arg2 = (int *) 0 ;
3828 int temp1 ;
3829 int res1 = 0 ;
3830 int temp2 ;
3831 int res2 = 0 ;
3832 char *kwnames[] = {
3833 NULL
3834 };
3835
3836 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3837 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3839 {
3840 if (!wxPyCheckForApp()) SWIG_fail;
3841 PyThreadState* __tstate = wxPyBeginAllowThreads();
3842 wxGetMousePosition(arg1,arg2);
3843
3844 wxPyEndAllowThreads(__tstate);
3845 if (PyErr_Occurred()) SWIG_fail;
3846 }
3847 Py_INCREF(Py_None); resultobj = Py_None;
3848 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3849 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3850 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3851 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3852 return resultobj;
3853 fail:
3854 return NULL;
3855 }
3856
3857
3858 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3859 PyObject *resultobj;
3860 bool result;
3861 char *kwnames[] = {
3862 NULL
3863 };
3864
3865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3866 {
3867 PyThreadState* __tstate = wxPyBeginAllowThreads();
3868 result = (bool)wxIsBusy();
3869
3870 wxPyEndAllowThreads(__tstate);
3871 if (PyErr_Occurred()) SWIG_fail;
3872 }
3873 {
3874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3875 }
3876 return resultobj;
3877 fail:
3878 return NULL;
3879 }
3880
3881
3882 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3883 PyObject *resultobj;
3884 wxString result;
3885 char *kwnames[] = {
3886 NULL
3887 };
3888
3889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3890 {
3891 PyThreadState* __tstate = wxPyBeginAllowThreads();
3892 result = wxNow();
3893
3894 wxPyEndAllowThreads(__tstate);
3895 if (PyErr_Occurred()) SWIG_fail;
3896 }
3897 {
3898 #if wxUSE_UNICODE
3899 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3900 #else
3901 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3902 #endif
3903 }
3904 return resultobj;
3905 fail:
3906 return NULL;
3907 }
3908
3909
3910 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3911 PyObject *resultobj;
3912 wxString const &arg1_defvalue = wxPyEmptyString ;
3913 wxString *arg1 = (wxString *) &arg1_defvalue ;
3914 bool result;
3915 bool temp1 = false ;
3916 PyObject * obj0 = 0 ;
3917 char *kwnames[] = {
3918 (char *) "command", NULL
3919 };
3920
3921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3922 if (obj0) {
3923 {
3924 arg1 = wxString_in_helper(obj0);
3925 if (arg1 == NULL) SWIG_fail;
3926 temp1 = true;
3927 }
3928 }
3929 {
3930 PyThreadState* __tstate = wxPyBeginAllowThreads();
3931 result = (bool)wxShell((wxString const &)*arg1);
3932
3933 wxPyEndAllowThreads(__tstate);
3934 if (PyErr_Occurred()) SWIG_fail;
3935 }
3936 {
3937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3938 }
3939 {
3940 if (temp1)
3941 delete arg1;
3942 }
3943 return resultobj;
3944 fail:
3945 {
3946 if (temp1)
3947 delete arg1;
3948 }
3949 return NULL;
3950 }
3951
3952
3953 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3954 PyObject *resultobj;
3955 char *kwnames[] = {
3956 NULL
3957 };
3958
3959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3960 {
3961 PyThreadState* __tstate = wxPyBeginAllowThreads();
3962 wxStartTimer();
3963
3964 wxPyEndAllowThreads(__tstate);
3965 if (PyErr_Occurred()) SWIG_fail;
3966 }
3967 Py_INCREF(Py_None); resultobj = Py_None;
3968 return resultobj;
3969 fail:
3970 return NULL;
3971 }
3972
3973
3974 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3975 PyObject *resultobj;
3976 int *arg1 = (int *) 0 ;
3977 int *arg2 = (int *) 0 ;
3978 int result;
3979 int temp1 ;
3980 int res1 = 0 ;
3981 int temp2 ;
3982 int res2 = 0 ;
3983 char *kwnames[] = {
3984 NULL
3985 };
3986
3987 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3988 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3990 {
3991 PyThreadState* __tstate = wxPyBeginAllowThreads();
3992 result = (int)wxGetOsVersion(arg1,arg2);
3993
3994 wxPyEndAllowThreads(__tstate);
3995 if (PyErr_Occurred()) SWIG_fail;
3996 }
3997 {
3998 resultobj = SWIG_From_int((int)(result));
3999 }
4000 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4001 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4002 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4003 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4004 return resultobj;
4005 fail:
4006 return NULL;
4007 }
4008
4009
4010 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4011 PyObject *resultobj;
4012 wxString result;
4013 char *kwnames[] = {
4014 NULL
4015 };
4016
4017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4018 {
4019 PyThreadState* __tstate = wxPyBeginAllowThreads();
4020 result = wxGetOsDescription();
4021
4022 wxPyEndAllowThreads(__tstate);
4023 if (PyErr_Occurred()) SWIG_fail;
4024 }
4025 {
4026 #if wxUSE_UNICODE
4027 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4028 #else
4029 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4030 #endif
4031 }
4032 return resultobj;
4033 fail:
4034 return NULL;
4035 }
4036
4037
4038 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4039 PyObject *resultobj;
4040 long result;
4041 char *kwnames[] = {
4042 NULL
4043 };
4044
4045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4046 {
4047 PyThreadState* __tstate = wxPyBeginAllowThreads();
4048 result = (long)wxGetFreeMemory();
4049
4050 wxPyEndAllowThreads(__tstate);
4051 if (PyErr_Occurred()) SWIG_fail;
4052 }
4053 {
4054 resultobj = SWIG_From_long((long)(result));
4055 }
4056 return resultobj;
4057 fail:
4058 return NULL;
4059 }
4060
4061
4062 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4063 PyObject *resultobj;
4064 wxShutdownFlags arg1 ;
4065 bool result;
4066 PyObject * obj0 = 0 ;
4067 char *kwnames[] = {
4068 (char *) "wFlags", NULL
4069 };
4070
4071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4072 {
4073 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4074 if (SWIG_arg_fail(1)) SWIG_fail;
4075 }
4076 {
4077 if (!wxPyCheckForApp()) SWIG_fail;
4078 PyThreadState* __tstate = wxPyBeginAllowThreads();
4079 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4080
4081 wxPyEndAllowThreads(__tstate);
4082 if (PyErr_Occurred()) SWIG_fail;
4083 }
4084 {
4085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4086 }
4087 return resultobj;
4088 fail:
4089 return NULL;
4090 }
4091
4092
4093 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4094 PyObject *resultobj;
4095 int arg1 ;
4096 PyObject * obj0 = 0 ;
4097 char *kwnames[] = {
4098 (char *) "secs", NULL
4099 };
4100
4101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4102 {
4103 arg1 = (int)(SWIG_As_int(obj0));
4104 if (SWIG_arg_fail(1)) SWIG_fail;
4105 }
4106 {
4107 PyThreadState* __tstate = wxPyBeginAllowThreads();
4108 wxSleep(arg1);
4109
4110 wxPyEndAllowThreads(__tstate);
4111 if (PyErr_Occurred()) SWIG_fail;
4112 }
4113 Py_INCREF(Py_None); resultobj = Py_None;
4114 return resultobj;
4115 fail:
4116 return NULL;
4117 }
4118
4119
4120 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4121 PyObject *resultobj;
4122 unsigned long arg1 ;
4123 PyObject * obj0 = 0 ;
4124 char *kwnames[] = {
4125 (char *) "milliseconds", NULL
4126 };
4127
4128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4129 {
4130 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4131 if (SWIG_arg_fail(1)) SWIG_fail;
4132 }
4133 {
4134 PyThreadState* __tstate = wxPyBeginAllowThreads();
4135 wxMilliSleep(arg1);
4136
4137 wxPyEndAllowThreads(__tstate);
4138 if (PyErr_Occurred()) SWIG_fail;
4139 }
4140 Py_INCREF(Py_None); resultobj = Py_None;
4141 return resultobj;
4142 fail:
4143 return NULL;
4144 }
4145
4146
4147 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4148 PyObject *resultobj;
4149 unsigned long arg1 ;
4150 PyObject * obj0 = 0 ;
4151 char *kwnames[] = {
4152 (char *) "microseconds", NULL
4153 };
4154
4155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4156 {
4157 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4158 if (SWIG_arg_fail(1)) SWIG_fail;
4159 }
4160 {
4161 PyThreadState* __tstate = wxPyBeginAllowThreads();
4162 wxMicroSleep(arg1);
4163
4164 wxPyEndAllowThreads(__tstate);
4165 if (PyErr_Occurred()) SWIG_fail;
4166 }
4167 Py_INCREF(Py_None); resultobj = Py_None;
4168 return resultobj;
4169 fail:
4170 return NULL;
4171 }
4172
4173
4174 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4175 PyObject *resultobj;
4176 bool arg1 ;
4177 PyObject * obj0 = 0 ;
4178 char *kwnames[] = {
4179 (char *) "enable", NULL
4180 };
4181
4182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4183 {
4184 arg1 = (bool)(SWIG_As_bool(obj0));
4185 if (SWIG_arg_fail(1)) SWIG_fail;
4186 }
4187 {
4188 PyThreadState* __tstate = wxPyBeginAllowThreads();
4189 wxEnableTopLevelWindows(arg1);
4190
4191 wxPyEndAllowThreads(__tstate);
4192 if (PyErr_Occurred()) SWIG_fail;
4193 }
4194 Py_INCREF(Py_None); resultobj = Py_None;
4195 return resultobj;
4196 fail:
4197 return NULL;
4198 }
4199
4200
4201 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4202 PyObject *resultobj;
4203 wxString *arg1 = 0 ;
4204 wxString result;
4205 bool temp1 = false ;
4206 PyObject * obj0 = 0 ;
4207 char *kwnames[] = {
4208 (char *) "in", NULL
4209 };
4210
4211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4212 {
4213 arg1 = wxString_in_helper(obj0);
4214 if (arg1 == NULL) SWIG_fail;
4215 temp1 = true;
4216 }
4217 {
4218 PyThreadState* __tstate = wxPyBeginAllowThreads();
4219 result = wxStripMenuCodes((wxString const &)*arg1);
4220
4221 wxPyEndAllowThreads(__tstate);
4222 if (PyErr_Occurred()) SWIG_fail;
4223 }
4224 {
4225 #if wxUSE_UNICODE
4226 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4227 #else
4228 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4229 #endif
4230 }
4231 {
4232 if (temp1)
4233 delete arg1;
4234 }
4235 return resultobj;
4236 fail:
4237 {
4238 if (temp1)
4239 delete arg1;
4240 }
4241 return NULL;
4242 }
4243
4244
4245 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4246 PyObject *resultobj;
4247 wxString result;
4248 char *kwnames[] = {
4249 NULL
4250 };
4251
4252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4253 {
4254 PyThreadState* __tstate = wxPyBeginAllowThreads();
4255 result = wxGetEmailAddress();
4256
4257 wxPyEndAllowThreads(__tstate);
4258 if (PyErr_Occurred()) SWIG_fail;
4259 }
4260 {
4261 #if wxUSE_UNICODE
4262 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4263 #else
4264 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4265 #endif
4266 }
4267 return resultobj;
4268 fail:
4269 return NULL;
4270 }
4271
4272
4273 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4274 PyObject *resultobj;
4275 wxString result;
4276 char *kwnames[] = {
4277 NULL
4278 };
4279
4280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4281 {
4282 PyThreadState* __tstate = wxPyBeginAllowThreads();
4283 result = wxGetHostName();
4284
4285 wxPyEndAllowThreads(__tstate);
4286 if (PyErr_Occurred()) SWIG_fail;
4287 }
4288 {
4289 #if wxUSE_UNICODE
4290 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4291 #else
4292 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4293 #endif
4294 }
4295 return resultobj;
4296 fail:
4297 return NULL;
4298 }
4299
4300
4301 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4302 PyObject *resultobj;
4303 wxString result;
4304 char *kwnames[] = {
4305 NULL
4306 };
4307
4308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4309 {
4310 PyThreadState* __tstate = wxPyBeginAllowThreads();
4311 result = wxGetFullHostName();
4312
4313 wxPyEndAllowThreads(__tstate);
4314 if (PyErr_Occurred()) SWIG_fail;
4315 }
4316 {
4317 #if wxUSE_UNICODE
4318 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4319 #else
4320 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4321 #endif
4322 }
4323 return resultobj;
4324 fail:
4325 return NULL;
4326 }
4327
4328
4329 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4330 PyObject *resultobj;
4331 wxString result;
4332 char *kwnames[] = {
4333 NULL
4334 };
4335
4336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4337 {
4338 PyThreadState* __tstate = wxPyBeginAllowThreads();
4339 result = wxGetUserId();
4340
4341 wxPyEndAllowThreads(__tstate);
4342 if (PyErr_Occurred()) SWIG_fail;
4343 }
4344 {
4345 #if wxUSE_UNICODE
4346 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4347 #else
4348 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4349 #endif
4350 }
4351 return resultobj;
4352 fail:
4353 return NULL;
4354 }
4355
4356
4357 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4358 PyObject *resultobj;
4359 wxString result;
4360 char *kwnames[] = {
4361 NULL
4362 };
4363
4364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4365 {
4366 PyThreadState* __tstate = wxPyBeginAllowThreads();
4367 result = wxGetUserName();
4368
4369 wxPyEndAllowThreads(__tstate);
4370 if (PyErr_Occurred()) SWIG_fail;
4371 }
4372 {
4373 #if wxUSE_UNICODE
4374 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4375 #else
4376 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4377 #endif
4378 }
4379 return resultobj;
4380 fail:
4381 return NULL;
4382 }
4383
4384
4385 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4386 PyObject *resultobj;
4387 wxString result;
4388 char *kwnames[] = {
4389 NULL
4390 };
4391
4392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4393 {
4394 PyThreadState* __tstate = wxPyBeginAllowThreads();
4395 result = wxGetHomeDir();
4396
4397 wxPyEndAllowThreads(__tstate);
4398 if (PyErr_Occurred()) SWIG_fail;
4399 }
4400 {
4401 #if wxUSE_UNICODE
4402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4403 #else
4404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4405 #endif
4406 }
4407 return resultobj;
4408 fail:
4409 return NULL;
4410 }
4411
4412
4413 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4414 PyObject *resultobj;
4415 wxString const &arg1_defvalue = wxPyEmptyString ;
4416 wxString *arg1 = (wxString *) &arg1_defvalue ;
4417 wxString result;
4418 bool temp1 = false ;
4419 PyObject * obj0 = 0 ;
4420 char *kwnames[] = {
4421 (char *) "user", NULL
4422 };
4423
4424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4425 if (obj0) {
4426 {
4427 arg1 = wxString_in_helper(obj0);
4428 if (arg1 == NULL) SWIG_fail;
4429 temp1 = true;
4430 }
4431 }
4432 {
4433 PyThreadState* __tstate = wxPyBeginAllowThreads();
4434 result = wxGetUserHome((wxString const &)*arg1);
4435
4436 wxPyEndAllowThreads(__tstate);
4437 if (PyErr_Occurred()) SWIG_fail;
4438 }
4439 {
4440 #if wxUSE_UNICODE
4441 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4442 #else
4443 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4444 #endif
4445 }
4446 {
4447 if (temp1)
4448 delete arg1;
4449 }
4450 return resultobj;
4451 fail:
4452 {
4453 if (temp1)
4454 delete arg1;
4455 }
4456 return NULL;
4457 }
4458
4459
4460 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4461 PyObject *resultobj;
4462 unsigned long result;
4463 char *kwnames[] = {
4464 NULL
4465 };
4466
4467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4468 {
4469 PyThreadState* __tstate = wxPyBeginAllowThreads();
4470 result = (unsigned long)wxGetProcessId();
4471
4472 wxPyEndAllowThreads(__tstate);
4473 if (PyErr_Occurred()) SWIG_fail;
4474 }
4475 {
4476 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4477 }
4478 return resultobj;
4479 fail:
4480 return NULL;
4481 }
4482
4483
4484 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4485 PyObject *resultobj;
4486 char *kwnames[] = {
4487 NULL
4488 };
4489
4490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4491 {
4492 PyThreadState* __tstate = wxPyBeginAllowThreads();
4493 wxTrap();
4494
4495 wxPyEndAllowThreads(__tstate);
4496 if (PyErr_Occurred()) SWIG_fail;
4497 }
4498 Py_INCREF(Py_None); resultobj = Py_None;
4499 return resultobj;
4500 fail:
4501 return NULL;
4502 }
4503
4504
4505 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4506 PyObject *resultobj;
4507 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4508 wxString *arg1 = (wxString *) &arg1_defvalue ;
4509 wxString const &arg2_defvalue = wxPyEmptyString ;
4510 wxString *arg2 = (wxString *) &arg2_defvalue ;
4511 wxString const &arg3_defvalue = wxPyEmptyString ;
4512 wxString *arg3 = (wxString *) &arg3_defvalue ;
4513 wxString const &arg4_defvalue = wxPyEmptyString ;
4514 wxString *arg4 = (wxString *) &arg4_defvalue ;
4515 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4516 wxString *arg5 = (wxString *) &arg5_defvalue ;
4517 int arg6 = (int) 0 ;
4518 wxWindow *arg7 = (wxWindow *) NULL ;
4519 int arg8 = (int) -1 ;
4520 int arg9 = (int) -1 ;
4521 wxString result;
4522 bool temp1 = false ;
4523 bool temp2 = false ;
4524 bool temp3 = false ;
4525 bool temp4 = false ;
4526 bool temp5 = false ;
4527 PyObject * obj0 = 0 ;
4528 PyObject * obj1 = 0 ;
4529 PyObject * obj2 = 0 ;
4530 PyObject * obj3 = 0 ;
4531 PyObject * obj4 = 0 ;
4532 PyObject * obj5 = 0 ;
4533 PyObject * obj6 = 0 ;
4534 PyObject * obj7 = 0 ;
4535 PyObject * obj8 = 0 ;
4536 char *kwnames[] = {
4537 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4538 };
4539
4540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4541 if (obj0) {
4542 {
4543 arg1 = wxString_in_helper(obj0);
4544 if (arg1 == NULL) SWIG_fail;
4545 temp1 = true;
4546 }
4547 }
4548 if (obj1) {
4549 {
4550 arg2 = wxString_in_helper(obj1);
4551 if (arg2 == NULL) SWIG_fail;
4552 temp2 = true;
4553 }
4554 }
4555 if (obj2) {
4556 {
4557 arg3 = wxString_in_helper(obj2);
4558 if (arg3 == NULL) SWIG_fail;
4559 temp3 = true;
4560 }
4561 }
4562 if (obj3) {
4563 {
4564 arg4 = wxString_in_helper(obj3);
4565 if (arg4 == NULL) SWIG_fail;
4566 temp4 = true;
4567 }
4568 }
4569 if (obj4) {
4570 {
4571 arg5 = wxString_in_helper(obj4);
4572 if (arg5 == NULL) SWIG_fail;
4573 temp5 = true;
4574 }
4575 }
4576 if (obj5) {
4577 {
4578 arg6 = (int)(SWIG_As_int(obj5));
4579 if (SWIG_arg_fail(6)) SWIG_fail;
4580 }
4581 }
4582 if (obj6) {
4583 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4584 if (SWIG_arg_fail(7)) SWIG_fail;
4585 }
4586 if (obj7) {
4587 {
4588 arg8 = (int)(SWIG_As_int(obj7));
4589 if (SWIG_arg_fail(8)) SWIG_fail;
4590 }
4591 }
4592 if (obj8) {
4593 {
4594 arg9 = (int)(SWIG_As_int(obj8));
4595 if (SWIG_arg_fail(9)) SWIG_fail;
4596 }
4597 }
4598 {
4599 if (!wxPyCheckForApp()) SWIG_fail;
4600 PyThreadState* __tstate = wxPyBeginAllowThreads();
4601 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4602
4603 wxPyEndAllowThreads(__tstate);
4604 if (PyErr_Occurred()) SWIG_fail;
4605 }
4606 {
4607 #if wxUSE_UNICODE
4608 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4609 #else
4610 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4611 #endif
4612 }
4613 {
4614 if (temp1)
4615 delete arg1;
4616 }
4617 {
4618 if (temp2)
4619 delete arg2;
4620 }
4621 {
4622 if (temp3)
4623 delete arg3;
4624 }
4625 {
4626 if (temp4)
4627 delete arg4;
4628 }
4629 {
4630 if (temp5)
4631 delete arg5;
4632 }
4633 return resultobj;
4634 fail:
4635 {
4636 if (temp1)
4637 delete arg1;
4638 }
4639 {
4640 if (temp2)
4641 delete arg2;
4642 }
4643 {
4644 if (temp3)
4645 delete arg3;
4646 }
4647 {
4648 if (temp4)
4649 delete arg4;
4650 }
4651 {
4652 if (temp5)
4653 delete arg5;
4654 }
4655 return NULL;
4656 }
4657
4658
4659 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4660 PyObject *resultobj;
4661 wxString *arg1 = 0 ;
4662 wxString *arg2 = 0 ;
4663 wxString const &arg3_defvalue = wxPyEmptyString ;
4664 wxString *arg3 = (wxString *) &arg3_defvalue ;
4665 wxWindow *arg4 = (wxWindow *) NULL ;
4666 wxString result;
4667 bool temp1 = false ;
4668 bool temp2 = false ;
4669 bool temp3 = false ;
4670 PyObject * obj0 = 0 ;
4671 PyObject * obj1 = 0 ;
4672 PyObject * obj2 = 0 ;
4673 PyObject * obj3 = 0 ;
4674 char *kwnames[] = {
4675 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4676 };
4677
4678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4679 {
4680 arg1 = wxString_in_helper(obj0);
4681 if (arg1 == NULL) SWIG_fail;
4682 temp1 = true;
4683 }
4684 {
4685 arg2 = wxString_in_helper(obj1);
4686 if (arg2 == NULL) SWIG_fail;
4687 temp2 = true;
4688 }
4689 if (obj2) {
4690 {
4691 arg3 = wxString_in_helper(obj2);
4692 if (arg3 == NULL) SWIG_fail;
4693 temp3 = true;
4694 }
4695 }
4696 if (obj3) {
4697 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4698 if (SWIG_arg_fail(4)) SWIG_fail;
4699 }
4700 {
4701 if (!wxPyCheckForApp()) SWIG_fail;
4702 PyThreadState* __tstate = wxPyBeginAllowThreads();
4703 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4704
4705 wxPyEndAllowThreads(__tstate);
4706 if (PyErr_Occurred()) SWIG_fail;
4707 }
4708 {
4709 #if wxUSE_UNICODE
4710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4711 #else
4712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4713 #endif
4714 }
4715 {
4716 if (temp1)
4717 delete arg1;
4718 }
4719 {
4720 if (temp2)
4721 delete arg2;
4722 }
4723 {
4724 if (temp3)
4725 delete arg3;
4726 }
4727 return resultobj;
4728 fail:
4729 {
4730 if (temp1)
4731 delete arg1;
4732 }
4733 {
4734 if (temp2)
4735 delete arg2;
4736 }
4737 {
4738 if (temp3)
4739 delete arg3;
4740 }
4741 return NULL;
4742 }
4743
4744
4745 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4746 PyObject *resultobj;
4747 wxString *arg1 = 0 ;
4748 wxString *arg2 = 0 ;
4749 wxString const &arg3_defvalue = wxPyEmptyString ;
4750 wxString *arg3 = (wxString *) &arg3_defvalue ;
4751 wxWindow *arg4 = (wxWindow *) NULL ;
4752 wxString result;
4753 bool temp1 = false ;
4754 bool temp2 = false ;
4755 bool temp3 = false ;
4756 PyObject * obj0 = 0 ;
4757 PyObject * obj1 = 0 ;
4758 PyObject * obj2 = 0 ;
4759 PyObject * obj3 = 0 ;
4760 char *kwnames[] = {
4761 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4762 };
4763
4764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4765 {
4766 arg1 = wxString_in_helper(obj0);
4767 if (arg1 == NULL) SWIG_fail;
4768 temp1 = true;
4769 }
4770 {
4771 arg2 = wxString_in_helper(obj1);
4772 if (arg2 == NULL) SWIG_fail;
4773 temp2 = true;
4774 }
4775 if (obj2) {
4776 {
4777 arg3 = wxString_in_helper(obj2);
4778 if (arg3 == NULL) SWIG_fail;
4779 temp3 = true;
4780 }
4781 }
4782 if (obj3) {
4783 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4784 if (SWIG_arg_fail(4)) SWIG_fail;
4785 }
4786 {
4787 if (!wxPyCheckForApp()) SWIG_fail;
4788 PyThreadState* __tstate = wxPyBeginAllowThreads();
4789 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4790
4791 wxPyEndAllowThreads(__tstate);
4792 if (PyErr_Occurred()) SWIG_fail;
4793 }
4794 {
4795 #if wxUSE_UNICODE
4796 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4797 #else
4798 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4799 #endif
4800 }
4801 {
4802 if (temp1)
4803 delete arg1;
4804 }
4805 {
4806 if (temp2)
4807 delete arg2;
4808 }
4809 {
4810 if (temp3)
4811 delete arg3;
4812 }
4813 return resultobj;
4814 fail:
4815 {
4816 if (temp1)
4817 delete arg1;
4818 }
4819 {
4820 if (temp2)
4821 delete arg2;
4822 }
4823 {
4824 if (temp3)
4825 delete arg3;
4826 }
4827 return NULL;
4828 }
4829
4830
4831 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4832 PyObject *resultobj;
4833 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4834 wxString *arg1 = (wxString *) &arg1_defvalue ;
4835 wxString const &arg2_defvalue = wxPyEmptyString ;
4836 wxString *arg2 = (wxString *) &arg2_defvalue ;
4837 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4838 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4839 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4840 wxWindow *arg5 = (wxWindow *) NULL ;
4841 wxString result;
4842 bool temp1 = false ;
4843 bool temp2 = false ;
4844 wxPoint temp4 ;
4845 PyObject * obj0 = 0 ;
4846 PyObject * obj1 = 0 ;
4847 PyObject * obj2 = 0 ;
4848 PyObject * obj3 = 0 ;
4849 PyObject * obj4 = 0 ;
4850 char *kwnames[] = {
4851 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4852 };
4853
4854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4855 if (obj0) {
4856 {
4857 arg1 = wxString_in_helper(obj0);
4858 if (arg1 == NULL) SWIG_fail;
4859 temp1 = true;
4860 }
4861 }
4862 if (obj1) {
4863 {
4864 arg2 = wxString_in_helper(obj1);
4865 if (arg2 == NULL) SWIG_fail;
4866 temp2 = true;
4867 }
4868 }
4869 if (obj2) {
4870 {
4871 arg3 = (long)(SWIG_As_long(obj2));
4872 if (SWIG_arg_fail(3)) SWIG_fail;
4873 }
4874 }
4875 if (obj3) {
4876 {
4877 arg4 = &temp4;
4878 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4879 }
4880 }
4881 if (obj4) {
4882 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4883 if (SWIG_arg_fail(5)) SWIG_fail;
4884 }
4885 {
4886 if (!wxPyCheckForApp()) SWIG_fail;
4887 PyThreadState* __tstate = wxPyBeginAllowThreads();
4888 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4889
4890 wxPyEndAllowThreads(__tstate);
4891 if (PyErr_Occurred()) SWIG_fail;
4892 }
4893 {
4894 #if wxUSE_UNICODE
4895 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4896 #else
4897 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4898 #endif
4899 }
4900 {
4901 if (temp1)
4902 delete arg1;
4903 }
4904 {
4905 if (temp2)
4906 delete arg2;
4907 }
4908 return resultobj;
4909 fail:
4910 {
4911 if (temp1)
4912 delete arg1;
4913 }
4914 {
4915 if (temp2)
4916 delete arg2;
4917 }
4918 return NULL;
4919 }
4920
4921
4922 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4923 PyObject *resultobj;
4924 wxString *arg1 = 0 ;
4925 wxString const &arg2_defvalue = wxPyEmptyString ;
4926 wxString *arg2 = (wxString *) &arg2_defvalue ;
4927 wxString const &arg3_defvalue = wxPyEmptyString ;
4928 wxString *arg3 = (wxString *) &arg3_defvalue ;
4929 wxWindow *arg4 = (wxWindow *) NULL ;
4930 int arg5 = (int) -1 ;
4931 int arg6 = (int) -1 ;
4932 bool arg7 = (bool) true ;
4933 wxString result;
4934 bool temp1 = false ;
4935 bool temp2 = false ;
4936 bool temp3 = false ;
4937 PyObject * obj0 = 0 ;
4938 PyObject * obj1 = 0 ;
4939 PyObject * obj2 = 0 ;
4940 PyObject * obj3 = 0 ;
4941 PyObject * obj4 = 0 ;
4942 PyObject * obj5 = 0 ;
4943 PyObject * obj6 = 0 ;
4944 char *kwnames[] = {
4945 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4946 };
4947
4948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4949 {
4950 arg1 = wxString_in_helper(obj0);
4951 if (arg1 == NULL) SWIG_fail;
4952 temp1 = true;
4953 }
4954 if (obj1) {
4955 {
4956 arg2 = wxString_in_helper(obj1);
4957 if (arg2 == NULL) SWIG_fail;
4958 temp2 = true;
4959 }
4960 }
4961 if (obj2) {
4962 {
4963 arg3 = wxString_in_helper(obj2);
4964 if (arg3 == NULL) SWIG_fail;
4965 temp3 = true;
4966 }
4967 }
4968 if (obj3) {
4969 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4970 if (SWIG_arg_fail(4)) SWIG_fail;
4971 }
4972 if (obj4) {
4973 {
4974 arg5 = (int)(SWIG_As_int(obj4));
4975 if (SWIG_arg_fail(5)) SWIG_fail;
4976 }
4977 }
4978 if (obj5) {
4979 {
4980 arg6 = (int)(SWIG_As_int(obj5));
4981 if (SWIG_arg_fail(6)) SWIG_fail;
4982 }
4983 }
4984 if (obj6) {
4985 {
4986 arg7 = (bool)(SWIG_As_bool(obj6));
4987 if (SWIG_arg_fail(7)) SWIG_fail;
4988 }
4989 }
4990 {
4991 if (!wxPyCheckForApp()) SWIG_fail;
4992 PyThreadState* __tstate = wxPyBeginAllowThreads();
4993 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4994
4995 wxPyEndAllowThreads(__tstate);
4996 if (PyErr_Occurred()) SWIG_fail;
4997 }
4998 {
4999 #if wxUSE_UNICODE
5000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5001 #else
5002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5003 #endif
5004 }
5005 {
5006 if (temp1)
5007 delete arg1;
5008 }
5009 {
5010 if (temp2)
5011 delete arg2;
5012 }
5013 {
5014 if (temp3)
5015 delete arg3;
5016 }
5017 return resultobj;
5018 fail:
5019 {
5020 if (temp1)
5021 delete arg1;
5022 }
5023 {
5024 if (temp2)
5025 delete arg2;
5026 }
5027 {
5028 if (temp3)
5029 delete arg3;
5030 }
5031 return NULL;
5032 }
5033
5034
5035 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5036 PyObject *resultobj;
5037 wxString *arg1 = 0 ;
5038 wxString const &arg2_defvalue = wxPyEmptyString ;
5039 wxString *arg2 = (wxString *) &arg2_defvalue ;
5040 wxString const &arg3_defvalue = wxPyEmptyString ;
5041 wxString *arg3 = (wxString *) &arg3_defvalue ;
5042 wxWindow *arg4 = (wxWindow *) NULL ;
5043 wxString result;
5044 bool temp1 = false ;
5045 bool temp2 = false ;
5046 bool temp3 = false ;
5047 PyObject * obj0 = 0 ;
5048 PyObject * obj1 = 0 ;
5049 PyObject * obj2 = 0 ;
5050 PyObject * obj3 = 0 ;
5051 char *kwnames[] = {
5052 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5053 };
5054
5055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5056 {
5057 arg1 = wxString_in_helper(obj0);
5058 if (arg1 == NULL) SWIG_fail;
5059 temp1 = true;
5060 }
5061 if (obj1) {
5062 {
5063 arg2 = wxString_in_helper(obj1);
5064 if (arg2 == NULL) SWIG_fail;
5065 temp2 = true;
5066 }
5067 }
5068 if (obj2) {
5069 {
5070 arg3 = wxString_in_helper(obj2);
5071 if (arg3 == NULL) SWIG_fail;
5072 temp3 = true;
5073 }
5074 }
5075 if (obj3) {
5076 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5077 if (SWIG_arg_fail(4)) SWIG_fail;
5078 }
5079 {
5080 if (!wxPyCheckForApp()) SWIG_fail;
5081 PyThreadState* __tstate = wxPyBeginAllowThreads();
5082 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5083
5084 wxPyEndAllowThreads(__tstate);
5085 if (PyErr_Occurred()) SWIG_fail;
5086 }
5087 {
5088 #if wxUSE_UNICODE
5089 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5090 #else
5091 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5092 #endif
5093 }
5094 {
5095 if (temp1)
5096 delete arg1;
5097 }
5098 {
5099 if (temp2)
5100 delete arg2;
5101 }
5102 {
5103 if (temp3)
5104 delete arg3;
5105 }
5106 return resultobj;
5107 fail:
5108 {
5109 if (temp1)
5110 delete arg1;
5111 }
5112 {
5113 if (temp2)
5114 delete arg2;
5115 }
5116 {
5117 if (temp3)
5118 delete arg3;
5119 }
5120 return NULL;
5121 }
5122
5123
5124 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5125 PyObject *resultobj;
5126 wxString *arg1 = 0 ;
5127 wxString *arg2 = 0 ;
5128 int arg3 ;
5129 wxString *arg4 = (wxString *) 0 ;
5130 wxWindow *arg5 = (wxWindow *) NULL ;
5131 int arg6 = (int) -1 ;
5132 int arg7 = (int) -1 ;
5133 bool arg8 = (bool) true ;
5134 int arg9 = (int) 150 ;
5135 int arg10 = (int) 200 ;
5136 wxString result;
5137 bool temp1 = false ;
5138 bool temp2 = false ;
5139 PyObject * obj0 = 0 ;
5140 PyObject * obj1 = 0 ;
5141 PyObject * obj2 = 0 ;
5142 PyObject * obj3 = 0 ;
5143 PyObject * obj4 = 0 ;
5144 PyObject * obj5 = 0 ;
5145 PyObject * obj6 = 0 ;
5146 PyObject * obj7 = 0 ;
5147 PyObject * obj8 = 0 ;
5148 char *kwnames[] = {
5149 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5150 };
5151
5152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5153 {
5154 arg1 = wxString_in_helper(obj0);
5155 if (arg1 == NULL) SWIG_fail;
5156 temp1 = true;
5157 }
5158 {
5159 arg2 = wxString_in_helper(obj1);
5160 if (arg2 == NULL) SWIG_fail;
5161 temp2 = true;
5162 }
5163 {
5164 arg3 = PyList_Size(obj2);
5165 arg4 = wxString_LIST_helper(obj2);
5166 if (arg4 == NULL) SWIG_fail;
5167 }
5168 if (obj3) {
5169 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5170 if (SWIG_arg_fail(5)) SWIG_fail;
5171 }
5172 if (obj4) {
5173 {
5174 arg6 = (int)(SWIG_As_int(obj4));
5175 if (SWIG_arg_fail(6)) SWIG_fail;
5176 }
5177 }
5178 if (obj5) {
5179 {
5180 arg7 = (int)(SWIG_As_int(obj5));
5181 if (SWIG_arg_fail(7)) SWIG_fail;
5182 }
5183 }
5184 if (obj6) {
5185 {
5186 arg8 = (bool)(SWIG_As_bool(obj6));
5187 if (SWIG_arg_fail(8)) SWIG_fail;
5188 }
5189 }
5190 if (obj7) {
5191 {
5192 arg9 = (int)(SWIG_As_int(obj7));
5193 if (SWIG_arg_fail(9)) SWIG_fail;
5194 }
5195 }
5196 if (obj8) {
5197 {
5198 arg10 = (int)(SWIG_As_int(obj8));
5199 if (SWIG_arg_fail(10)) SWIG_fail;
5200 }
5201 }
5202 {
5203 if (!wxPyCheckForApp()) SWIG_fail;
5204 PyThreadState* __tstate = wxPyBeginAllowThreads();
5205 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5206
5207 wxPyEndAllowThreads(__tstate);
5208 if (PyErr_Occurred()) SWIG_fail;
5209 }
5210 {
5211 #if wxUSE_UNICODE
5212 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5213 #else
5214 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5215 #endif
5216 }
5217 {
5218 if (temp1)
5219 delete arg1;
5220 }
5221 {
5222 if (temp2)
5223 delete arg2;
5224 }
5225 {
5226 if (arg4) delete [] arg4;
5227 }
5228 return resultobj;
5229 fail:
5230 {
5231 if (temp1)
5232 delete arg1;
5233 }
5234 {
5235 if (temp2)
5236 delete arg2;
5237 }
5238 {
5239 if (arg4) delete [] arg4;
5240 }
5241 return NULL;
5242 }
5243
5244
5245 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5246 PyObject *resultobj;
5247 wxString *arg1 = 0 ;
5248 wxString *arg2 = 0 ;
5249 int arg3 ;
5250 wxString *arg4 = (wxString *) 0 ;
5251 wxWindow *arg5 = (wxWindow *) NULL ;
5252 int arg6 = (int) -1 ;
5253 int arg7 = (int) -1 ;
5254 bool arg8 = (bool) true ;
5255 int arg9 = (int) 150 ;
5256 int arg10 = (int) 200 ;
5257 int result;
5258 bool temp1 = false ;
5259 bool temp2 = false ;
5260 PyObject * obj0 = 0 ;
5261 PyObject * obj1 = 0 ;
5262 PyObject * obj2 = 0 ;
5263 PyObject * obj3 = 0 ;
5264 PyObject * obj4 = 0 ;
5265 PyObject * obj5 = 0 ;
5266 PyObject * obj6 = 0 ;
5267 PyObject * obj7 = 0 ;
5268 PyObject * obj8 = 0 ;
5269 char *kwnames[] = {
5270 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5271 };
5272
5273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5274 {
5275 arg1 = wxString_in_helper(obj0);
5276 if (arg1 == NULL) SWIG_fail;
5277 temp1 = true;
5278 }
5279 {
5280 arg2 = wxString_in_helper(obj1);
5281 if (arg2 == NULL) SWIG_fail;
5282 temp2 = true;
5283 }
5284 {
5285 arg3 = PyList_Size(obj2);
5286 arg4 = wxString_LIST_helper(obj2);
5287 if (arg4 == NULL) SWIG_fail;
5288 }
5289 if (obj3) {
5290 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5291 if (SWIG_arg_fail(5)) SWIG_fail;
5292 }
5293 if (obj4) {
5294 {
5295 arg6 = (int)(SWIG_As_int(obj4));
5296 if (SWIG_arg_fail(6)) SWIG_fail;
5297 }
5298 }
5299 if (obj5) {
5300 {
5301 arg7 = (int)(SWIG_As_int(obj5));
5302 if (SWIG_arg_fail(7)) SWIG_fail;
5303 }
5304 }
5305 if (obj6) {
5306 {
5307 arg8 = (bool)(SWIG_As_bool(obj6));
5308 if (SWIG_arg_fail(8)) SWIG_fail;
5309 }
5310 }
5311 if (obj7) {
5312 {
5313 arg9 = (int)(SWIG_As_int(obj7));
5314 if (SWIG_arg_fail(9)) SWIG_fail;
5315 }
5316 }
5317 if (obj8) {
5318 {
5319 arg10 = (int)(SWIG_As_int(obj8));
5320 if (SWIG_arg_fail(10)) SWIG_fail;
5321 }
5322 }
5323 {
5324 if (!wxPyCheckForApp()) SWIG_fail;
5325 PyThreadState* __tstate = wxPyBeginAllowThreads();
5326 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5327
5328 wxPyEndAllowThreads(__tstate);
5329 if (PyErr_Occurred()) SWIG_fail;
5330 }
5331 {
5332 resultobj = SWIG_From_int((int)(result));
5333 }
5334 {
5335 if (temp1)
5336 delete arg1;
5337 }
5338 {
5339 if (temp2)
5340 delete arg2;
5341 }
5342 {
5343 if (arg4) delete [] arg4;
5344 }
5345 return resultobj;
5346 fail:
5347 {
5348 if (temp1)
5349 delete arg1;
5350 }
5351 {
5352 if (temp2)
5353 delete arg2;
5354 }
5355 {
5356 if (arg4) delete [] arg4;
5357 }
5358 return NULL;
5359 }
5360
5361
5362 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5363 PyObject *resultobj;
5364 wxString *arg1 = 0 ;
5365 wxString const &arg2_defvalue = wxPyEmptyString ;
5366 wxString *arg2 = (wxString *) &arg2_defvalue ;
5367 int arg3 = (int) wxOK|wxCENTRE ;
5368 wxWindow *arg4 = (wxWindow *) NULL ;
5369 int arg5 = (int) -1 ;
5370 int arg6 = (int) -1 ;
5371 int result;
5372 bool temp1 = false ;
5373 bool temp2 = false ;
5374 PyObject * obj0 = 0 ;
5375 PyObject * obj1 = 0 ;
5376 PyObject * obj2 = 0 ;
5377 PyObject * obj3 = 0 ;
5378 PyObject * obj4 = 0 ;
5379 PyObject * obj5 = 0 ;
5380 char *kwnames[] = {
5381 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5382 };
5383
5384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5385 {
5386 arg1 = wxString_in_helper(obj0);
5387 if (arg1 == NULL) SWIG_fail;
5388 temp1 = true;
5389 }
5390 if (obj1) {
5391 {
5392 arg2 = wxString_in_helper(obj1);
5393 if (arg2 == NULL) SWIG_fail;
5394 temp2 = true;
5395 }
5396 }
5397 if (obj2) {
5398 {
5399 arg3 = (int)(SWIG_As_int(obj2));
5400 if (SWIG_arg_fail(3)) SWIG_fail;
5401 }
5402 }
5403 if (obj3) {
5404 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5405 if (SWIG_arg_fail(4)) SWIG_fail;
5406 }
5407 if (obj4) {
5408 {
5409 arg5 = (int)(SWIG_As_int(obj4));
5410 if (SWIG_arg_fail(5)) SWIG_fail;
5411 }
5412 }
5413 if (obj5) {
5414 {
5415 arg6 = (int)(SWIG_As_int(obj5));
5416 if (SWIG_arg_fail(6)) SWIG_fail;
5417 }
5418 }
5419 {
5420 if (!wxPyCheckForApp()) SWIG_fail;
5421 PyThreadState* __tstate = wxPyBeginAllowThreads();
5422 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5423
5424 wxPyEndAllowThreads(__tstate);
5425 if (PyErr_Occurred()) SWIG_fail;
5426 }
5427 {
5428 resultobj = SWIG_From_int((int)(result));
5429 }
5430 {
5431 if (temp1)
5432 delete arg1;
5433 }
5434 {
5435 if (temp2)
5436 delete arg2;
5437 }
5438 return resultobj;
5439 fail:
5440 {
5441 if (temp1)
5442 delete arg1;
5443 }
5444 {
5445 if (temp2)
5446 delete arg2;
5447 }
5448 return NULL;
5449 }
5450
5451
5452 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5453 PyObject *resultobj;
5454 wxString *arg1 = 0 ;
5455 wxString *arg2 = 0 ;
5456 wxString *arg3 = 0 ;
5457 long arg4 ;
5458 long arg5 = (long) 0 ;
5459 long arg6 = (long) 100 ;
5460 wxWindow *arg7 = (wxWindow *) NULL ;
5461 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5462 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5463 long result;
5464 bool temp1 = false ;
5465 bool temp2 = false ;
5466 bool temp3 = false ;
5467 wxPoint temp8 ;
5468 PyObject * obj0 = 0 ;
5469 PyObject * obj1 = 0 ;
5470 PyObject * obj2 = 0 ;
5471 PyObject * obj3 = 0 ;
5472 PyObject * obj4 = 0 ;
5473 PyObject * obj5 = 0 ;
5474 PyObject * obj6 = 0 ;
5475 PyObject * obj7 = 0 ;
5476 char *kwnames[] = {
5477 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5478 };
5479
5480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5481 {
5482 arg1 = wxString_in_helper(obj0);
5483 if (arg1 == NULL) SWIG_fail;
5484 temp1 = true;
5485 }
5486 {
5487 arg2 = wxString_in_helper(obj1);
5488 if (arg2 == NULL) SWIG_fail;
5489 temp2 = true;
5490 }
5491 {
5492 arg3 = wxString_in_helper(obj2);
5493 if (arg3 == NULL) SWIG_fail;
5494 temp3 = true;
5495 }
5496 {
5497 arg4 = (long)(SWIG_As_long(obj3));
5498 if (SWIG_arg_fail(4)) SWIG_fail;
5499 }
5500 if (obj4) {
5501 {
5502 arg5 = (long)(SWIG_As_long(obj4));
5503 if (SWIG_arg_fail(5)) SWIG_fail;
5504 }
5505 }
5506 if (obj5) {
5507 {
5508 arg6 = (long)(SWIG_As_long(obj5));
5509 if (SWIG_arg_fail(6)) SWIG_fail;
5510 }
5511 }
5512 if (obj6) {
5513 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5514 if (SWIG_arg_fail(7)) SWIG_fail;
5515 }
5516 if (obj7) {
5517 {
5518 arg8 = &temp8;
5519 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5520 }
5521 }
5522 {
5523 if (!wxPyCheckForApp()) SWIG_fail;
5524 PyThreadState* __tstate = wxPyBeginAllowThreads();
5525 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5526
5527 wxPyEndAllowThreads(__tstate);
5528 if (PyErr_Occurred()) SWIG_fail;
5529 }
5530 {
5531 resultobj = SWIG_From_long((long)(result));
5532 }
5533 {
5534 if (temp1)
5535 delete arg1;
5536 }
5537 {
5538 if (temp2)
5539 delete arg2;
5540 }
5541 {
5542 if (temp3)
5543 delete arg3;
5544 }
5545 return resultobj;
5546 fail:
5547 {
5548 if (temp1)
5549 delete arg1;
5550 }
5551 {
5552 if (temp2)
5553 delete arg2;
5554 }
5555 {
5556 if (temp3)
5557 delete arg3;
5558 }
5559 return NULL;
5560 }
5561
5562
5563 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5564 PyObject *resultobj;
5565 bool result;
5566 char *kwnames[] = {
5567 NULL
5568 };
5569
5570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5571 {
5572 if (!wxPyCheckForApp()) SWIG_fail;
5573 PyThreadState* __tstate = wxPyBeginAllowThreads();
5574 result = (bool)wxColourDisplay();
5575
5576 wxPyEndAllowThreads(__tstate);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 {
5580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5581 }
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5589 PyObject *resultobj;
5590 int result;
5591 char *kwnames[] = {
5592 NULL
5593 };
5594
5595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5596 {
5597 if (!wxPyCheckForApp()) SWIG_fail;
5598 PyThreadState* __tstate = wxPyBeginAllowThreads();
5599 result = (int)wxDisplayDepth();
5600
5601 wxPyEndAllowThreads(__tstate);
5602 if (PyErr_Occurred()) SWIG_fail;
5603 }
5604 {
5605 resultobj = SWIG_From_int((int)(result));
5606 }
5607 return resultobj;
5608 fail:
5609 return NULL;
5610 }
5611
5612
5613 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5614 PyObject *resultobj;
5615 int result;
5616 char *kwnames[] = {
5617 NULL
5618 };
5619
5620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5621 {
5622 if (!wxPyCheckForApp()) SWIG_fail;
5623 PyThreadState* __tstate = wxPyBeginAllowThreads();
5624 result = (int)wxGetDisplayDepth();
5625
5626 wxPyEndAllowThreads(__tstate);
5627 if (PyErr_Occurred()) SWIG_fail;
5628 }
5629 {
5630 resultobj = SWIG_From_int((int)(result));
5631 }
5632 return resultobj;
5633 fail:
5634 return NULL;
5635 }
5636
5637
5638 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5639 PyObject *resultobj;
5640 int *arg1 = (int *) 0 ;
5641 int *arg2 = (int *) 0 ;
5642 int temp1 ;
5643 int res1 = 0 ;
5644 int temp2 ;
5645 int res2 = 0 ;
5646 char *kwnames[] = {
5647 NULL
5648 };
5649
5650 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5651 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5653 {
5654 if (!wxPyCheckForApp()) SWIG_fail;
5655 PyThreadState* __tstate = wxPyBeginAllowThreads();
5656 wxDisplaySize(arg1,arg2);
5657
5658 wxPyEndAllowThreads(__tstate);
5659 if (PyErr_Occurred()) SWIG_fail;
5660 }
5661 Py_INCREF(Py_None); resultobj = Py_None;
5662 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5663 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5664 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5665 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5666 return resultobj;
5667 fail:
5668 return NULL;
5669 }
5670
5671
5672 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5673 PyObject *resultobj;
5674 wxSize result;
5675 char *kwnames[] = {
5676 NULL
5677 };
5678
5679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5680 {
5681 if (!wxPyCheckForApp()) SWIG_fail;
5682 PyThreadState* __tstate = wxPyBeginAllowThreads();
5683 result = wxGetDisplaySize();
5684
5685 wxPyEndAllowThreads(__tstate);
5686 if (PyErr_Occurred()) SWIG_fail;
5687 }
5688 {
5689 wxSize * resultptr;
5690 resultptr = new wxSize((wxSize &)(result));
5691 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5692 }
5693 return resultobj;
5694 fail:
5695 return NULL;
5696 }
5697
5698
5699 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5700 PyObject *resultobj;
5701 int *arg1 = (int *) 0 ;
5702 int *arg2 = (int *) 0 ;
5703 int temp1 ;
5704 int res1 = 0 ;
5705 int temp2 ;
5706 int res2 = 0 ;
5707 char *kwnames[] = {
5708 NULL
5709 };
5710
5711 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5712 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5714 {
5715 if (!wxPyCheckForApp()) SWIG_fail;
5716 PyThreadState* __tstate = wxPyBeginAllowThreads();
5717 wxDisplaySizeMM(arg1,arg2);
5718
5719 wxPyEndAllowThreads(__tstate);
5720 if (PyErr_Occurred()) SWIG_fail;
5721 }
5722 Py_INCREF(Py_None); resultobj = Py_None;
5723 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5724 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5725 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5726 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5727 return resultobj;
5728 fail:
5729 return NULL;
5730 }
5731
5732
5733 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5734 PyObject *resultobj;
5735 wxSize result;
5736 char *kwnames[] = {
5737 NULL
5738 };
5739
5740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5741 {
5742 if (!wxPyCheckForApp()) SWIG_fail;
5743 PyThreadState* __tstate = wxPyBeginAllowThreads();
5744 result = wxGetDisplaySizeMM();
5745
5746 wxPyEndAllowThreads(__tstate);
5747 if (PyErr_Occurred()) SWIG_fail;
5748 }
5749 {
5750 wxSize * resultptr;
5751 resultptr = new wxSize((wxSize &)(result));
5752 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5753 }
5754 return resultobj;
5755 fail:
5756 return NULL;
5757 }
5758
5759
5760 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5761 PyObject *resultobj;
5762 int *arg1 = (int *) 0 ;
5763 int *arg2 = (int *) 0 ;
5764 int *arg3 = (int *) 0 ;
5765 int *arg4 = (int *) 0 ;
5766 int temp1 ;
5767 int res1 = 0 ;
5768 int temp2 ;
5769 int res2 = 0 ;
5770 int temp3 ;
5771 int res3 = 0 ;
5772 int temp4 ;
5773 int res4 = 0 ;
5774 char *kwnames[] = {
5775 NULL
5776 };
5777
5778 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5779 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5780 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5781 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5783 {
5784 if (!wxPyCheckForApp()) SWIG_fail;
5785 PyThreadState* __tstate = wxPyBeginAllowThreads();
5786 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5787
5788 wxPyEndAllowThreads(__tstate);
5789 if (PyErr_Occurred()) SWIG_fail;
5790 }
5791 Py_INCREF(Py_None); resultobj = Py_None;
5792 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5793 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5794 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5795 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5796 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5797 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5798 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5799 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5800 return resultobj;
5801 fail:
5802 return NULL;
5803 }
5804
5805
5806 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5807 PyObject *resultobj;
5808 wxRect result;
5809 char *kwnames[] = {
5810 NULL
5811 };
5812
5813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5814 {
5815 if (!wxPyCheckForApp()) SWIG_fail;
5816 PyThreadState* __tstate = wxPyBeginAllowThreads();
5817 result = wxGetClientDisplayRect();
5818
5819 wxPyEndAllowThreads(__tstate);
5820 if (PyErr_Occurred()) SWIG_fail;
5821 }
5822 {
5823 wxRect * resultptr;
5824 resultptr = new wxRect((wxRect &)(result));
5825 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5826 }
5827 return resultobj;
5828 fail:
5829 return NULL;
5830 }
5831
5832
5833 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5834 PyObject *resultobj;
5835 wxCursor *arg1 = 0 ;
5836 PyObject * obj0 = 0 ;
5837 char *kwnames[] = {
5838 (char *) "cursor", NULL
5839 };
5840
5841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5842 {
5843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5844 if (SWIG_arg_fail(1)) SWIG_fail;
5845 if (arg1 == NULL) {
5846 SWIG_null_ref("wxCursor");
5847 }
5848 if (SWIG_arg_fail(1)) SWIG_fail;
5849 }
5850 {
5851 if (!wxPyCheckForApp()) SWIG_fail;
5852 PyThreadState* __tstate = wxPyBeginAllowThreads();
5853 wxSetCursor(*arg1);
5854
5855 wxPyEndAllowThreads(__tstate);
5856 if (PyErr_Occurred()) SWIG_fail;
5857 }
5858 Py_INCREF(Py_None); resultobj = Py_None;
5859 return resultobj;
5860 fail:
5861 return NULL;
5862 }
5863
5864
5865 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5866 PyObject *resultobj;
5867 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5868 PyObject * obj0 = 0 ;
5869 char *kwnames[] = {
5870 (char *) "cursor", NULL
5871 };
5872
5873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5874 if (obj0) {
5875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5876 if (SWIG_arg_fail(1)) SWIG_fail;
5877 }
5878 {
5879 if (!wxPyCheckForApp()) SWIG_fail;
5880 PyThreadState* __tstate = wxPyBeginAllowThreads();
5881 wxBeginBusyCursor(arg1);
5882
5883 wxPyEndAllowThreads(__tstate);
5884 if (PyErr_Occurred()) SWIG_fail;
5885 }
5886 Py_INCREF(Py_None); resultobj = Py_None;
5887 return resultobj;
5888 fail:
5889 return NULL;
5890 }
5891
5892
5893 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5894 PyObject *resultobj;
5895 wxWindow *result;
5896 char *kwnames[] = {
5897 NULL
5898 };
5899
5900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5901 {
5902 if (!wxPyCheckForApp()) SWIG_fail;
5903 PyThreadState* __tstate = wxPyBeginAllowThreads();
5904 result = (wxWindow *)wxGetActiveWindow();
5905
5906 wxPyEndAllowThreads(__tstate);
5907 if (PyErr_Occurred()) SWIG_fail;
5908 }
5909 {
5910 resultobj = wxPyMake_wxObject(result, 0);
5911 }
5912 return resultobj;
5913 fail:
5914 return NULL;
5915 }
5916
5917
5918 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5919 PyObject *resultobj;
5920 wxPoint *arg1 = 0 ;
5921 wxWindow *result;
5922 wxPoint temp1 ;
5923 PyObject * obj0 = 0 ;
5924 char *kwnames[] = {
5925 (char *) "pt", NULL
5926 };
5927
5928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5929 {
5930 arg1 = &temp1;
5931 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5932 }
5933 {
5934 if (!wxPyCheckForApp()) SWIG_fail;
5935 PyThreadState* __tstate = wxPyBeginAllowThreads();
5936 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5937
5938 wxPyEndAllowThreads(__tstate);
5939 if (PyErr_Occurred()) SWIG_fail;
5940 }
5941 {
5942 resultobj = wxPyMake_wxObject(result, 0);
5943 }
5944 return resultobj;
5945 fail:
5946 return NULL;
5947 }
5948
5949
5950 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5951 PyObject *resultobj;
5952 wxPoint *arg1 = 0 ;
5953 wxWindow *result;
5954 wxPoint temp1 ;
5955 PyObject * obj0 = 0 ;
5956 char *kwnames[] = {
5957 (char *) "pt", NULL
5958 };
5959
5960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5961 {
5962 arg1 = &temp1;
5963 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5964 }
5965 {
5966 if (!wxPyCheckForApp()) SWIG_fail;
5967 PyThreadState* __tstate = wxPyBeginAllowThreads();
5968 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5969
5970 wxPyEndAllowThreads(__tstate);
5971 if (PyErr_Occurred()) SWIG_fail;
5972 }
5973 {
5974 resultobj = wxPyMake_wxObject(result, 0);
5975 }
5976 return resultobj;
5977 fail:
5978 return NULL;
5979 }
5980
5981
5982 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5983 PyObject *resultobj;
5984 wxWindow *arg1 = (wxWindow *) 0 ;
5985 wxWindow *result;
5986 PyObject * obj0 = 0 ;
5987 char *kwnames[] = {
5988 (char *) "win", NULL
5989 };
5990
5991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5993 if (SWIG_arg_fail(1)) SWIG_fail;
5994 {
5995 if (!wxPyCheckForApp()) SWIG_fail;
5996 PyThreadState* __tstate = wxPyBeginAllowThreads();
5997 result = (wxWindow *)wxGetTopLevelParent(arg1);
5998
5999 wxPyEndAllowThreads(__tstate);
6000 if (PyErr_Occurred()) SWIG_fail;
6001 }
6002 {
6003 resultobj = wxPyMake_wxObject(result, 0);
6004 }
6005 return resultobj;
6006 fail:
6007 return NULL;
6008 }
6009
6010
6011 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
6012 PyObject *resultobj;
6013 wxString *arg1 = 0 ;
6014 bool result;
6015 bool temp1 = false ;
6016 PyObject * obj0 = 0 ;
6017 char *kwnames[] = {
6018 (char *) "url", NULL
6019 };
6020
6021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
6022 {
6023 arg1 = wxString_in_helper(obj0);
6024 if (arg1 == NULL) SWIG_fail;
6025 temp1 = true;
6026 }
6027 {
6028 PyThreadState* __tstate = wxPyBeginAllowThreads();
6029 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
6030
6031 wxPyEndAllowThreads(__tstate);
6032 if (PyErr_Occurred()) SWIG_fail;
6033 }
6034 {
6035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6036 }
6037 {
6038 if (temp1)
6039 delete arg1;
6040 }
6041 return resultobj;
6042 fail:
6043 {
6044 if (temp1)
6045 delete arg1;
6046 }
6047 return NULL;
6048 }
6049
6050
6051 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6052 PyObject *resultobj;
6053 wxKeyCode arg1 ;
6054 bool result;
6055 PyObject * obj0 = 0 ;
6056 char *kwnames[] = {
6057 (char *) "key", NULL
6058 };
6059
6060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6061 {
6062 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6063 if (SWIG_arg_fail(1)) SWIG_fail;
6064 }
6065 {
6066 if (!wxPyCheckForApp()) SWIG_fail;
6067 PyThreadState* __tstate = wxPyBeginAllowThreads();
6068 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6069
6070 wxPyEndAllowThreads(__tstate);
6071 if (PyErr_Occurred()) SWIG_fail;
6072 }
6073 {
6074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6075 }
6076 return resultobj;
6077 fail:
6078 return NULL;
6079 }
6080
6081
6082 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6083 PyObject *resultobj;
6084 char *kwnames[] = {
6085 NULL
6086 };
6087
6088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6089 {
6090 if (!wxPyCheckForApp()) SWIG_fail;
6091 PyThreadState* __tstate = wxPyBeginAllowThreads();
6092 wxWakeUpMainThread();
6093
6094 wxPyEndAllowThreads(__tstate);
6095 if (PyErr_Occurred()) SWIG_fail;
6096 }
6097 Py_INCREF(Py_None); resultobj = Py_None;
6098 return resultobj;
6099 fail:
6100 return NULL;
6101 }
6102
6103
6104 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6105 PyObject *resultobj;
6106 char *kwnames[] = {
6107 NULL
6108 };
6109
6110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6111 {
6112 if (!wxPyCheckForApp()) SWIG_fail;
6113 PyThreadState* __tstate = wxPyBeginAllowThreads();
6114 wxMutexGuiEnter();
6115
6116 wxPyEndAllowThreads(__tstate);
6117 if (PyErr_Occurred()) SWIG_fail;
6118 }
6119 Py_INCREF(Py_None); resultobj = Py_None;
6120 return resultobj;
6121 fail:
6122 return NULL;
6123 }
6124
6125
6126 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6127 PyObject *resultobj;
6128 char *kwnames[] = {
6129 NULL
6130 };
6131
6132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6133 {
6134 if (!wxPyCheckForApp()) SWIG_fail;
6135 PyThreadState* __tstate = wxPyBeginAllowThreads();
6136 wxMutexGuiLeave();
6137
6138 wxPyEndAllowThreads(__tstate);
6139 if (PyErr_Occurred()) SWIG_fail;
6140 }
6141 Py_INCREF(Py_None); resultobj = Py_None;
6142 return resultobj;
6143 fail:
6144 return NULL;
6145 }
6146
6147
6148 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6149 PyObject *resultobj;
6150 wxMutexGuiLocker *result;
6151 char *kwnames[] = {
6152 NULL
6153 };
6154
6155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6156 {
6157 if (!wxPyCheckForApp()) SWIG_fail;
6158 PyThreadState* __tstate = wxPyBeginAllowThreads();
6159 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6160
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6165 return resultobj;
6166 fail:
6167 return NULL;
6168 }
6169
6170
6171 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6172 PyObject *resultobj;
6173 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6174 PyObject * obj0 = 0 ;
6175 char *kwnames[] = {
6176 (char *) "self", NULL
6177 };
6178
6179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6181 if (SWIG_arg_fail(1)) SWIG_fail;
6182 {
6183 PyThreadState* __tstate = wxPyBeginAllowThreads();
6184 delete arg1;
6185
6186 wxPyEndAllowThreads(__tstate);
6187 if (PyErr_Occurred()) SWIG_fail;
6188 }
6189 Py_INCREF(Py_None); resultobj = Py_None;
6190 return resultobj;
6191 fail:
6192 return NULL;
6193 }
6194
6195
6196 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6197 PyObject *obj;
6198 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6199 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6200 Py_INCREF(obj);
6201 return Py_BuildValue((char *)"");
6202 }
6203 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6204 PyObject *resultobj;
6205 bool result;
6206 char *kwnames[] = {
6207 NULL
6208 };
6209
6210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6211 {
6212 PyThreadState* __tstate = wxPyBeginAllowThreads();
6213 result = (bool)wxThread_IsMain();
6214
6215 wxPyEndAllowThreads(__tstate);
6216 if (PyErr_Occurred()) SWIG_fail;
6217 }
6218 {
6219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6220 }
6221 return resultobj;
6222 fail:
6223 return NULL;
6224 }
6225
6226
6227 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6228 PyObject *resultobj;
6229 wxString *arg1 = 0 ;
6230 wxToolTip *result;
6231 bool temp1 = false ;
6232 PyObject * obj0 = 0 ;
6233 char *kwnames[] = {
6234 (char *) "tip", NULL
6235 };
6236
6237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6238 {
6239 arg1 = wxString_in_helper(obj0);
6240 if (arg1 == NULL) SWIG_fail;
6241 temp1 = true;
6242 }
6243 {
6244 if (!wxPyCheckForApp()) SWIG_fail;
6245 PyThreadState* __tstate = wxPyBeginAllowThreads();
6246 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6247
6248 wxPyEndAllowThreads(__tstate);
6249 if (PyErr_Occurred()) SWIG_fail;
6250 }
6251 {
6252 resultobj = wxPyMake_wxObject(result, 1);
6253 }
6254 {
6255 if (temp1)
6256 delete arg1;
6257 }
6258 return resultobj;
6259 fail:
6260 {
6261 if (temp1)
6262 delete arg1;
6263 }
6264 return NULL;
6265 }
6266
6267
6268 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6269 PyObject *resultobj;
6270 wxToolTip *arg1 = (wxToolTip *) 0 ;
6271 wxString *arg2 = 0 ;
6272 bool temp2 = false ;
6273 PyObject * obj0 = 0 ;
6274 PyObject * obj1 = 0 ;
6275 char *kwnames[] = {
6276 (char *) "self",(char *) "tip", NULL
6277 };
6278
6279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6281 if (SWIG_arg_fail(1)) SWIG_fail;
6282 {
6283 arg2 = wxString_in_helper(obj1);
6284 if (arg2 == NULL) SWIG_fail;
6285 temp2 = true;
6286 }
6287 {
6288 PyThreadState* __tstate = wxPyBeginAllowThreads();
6289 (arg1)->SetTip((wxString const &)*arg2);
6290
6291 wxPyEndAllowThreads(__tstate);
6292 if (PyErr_Occurred()) SWIG_fail;
6293 }
6294 Py_INCREF(Py_None); resultobj = Py_None;
6295 {
6296 if (temp2)
6297 delete arg2;
6298 }
6299 return resultobj;
6300 fail:
6301 {
6302 if (temp2)
6303 delete arg2;
6304 }
6305 return NULL;
6306 }
6307
6308
6309 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6310 PyObject *resultobj;
6311 wxToolTip *arg1 = (wxToolTip *) 0 ;
6312 wxString result;
6313 PyObject * obj0 = 0 ;
6314 char *kwnames[] = {
6315 (char *) "self", NULL
6316 };
6317
6318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6320 if (SWIG_arg_fail(1)) SWIG_fail;
6321 {
6322 PyThreadState* __tstate = wxPyBeginAllowThreads();
6323 result = (arg1)->GetTip();
6324
6325 wxPyEndAllowThreads(__tstate);
6326 if (PyErr_Occurred()) SWIG_fail;
6327 }
6328 {
6329 #if wxUSE_UNICODE
6330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6331 #else
6332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6333 #endif
6334 }
6335 return resultobj;
6336 fail:
6337 return NULL;
6338 }
6339
6340
6341 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6342 PyObject *resultobj;
6343 wxToolTip *arg1 = (wxToolTip *) 0 ;
6344 wxWindow *result;
6345 PyObject * obj0 = 0 ;
6346 char *kwnames[] = {
6347 (char *) "self", NULL
6348 };
6349
6350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6352 if (SWIG_arg_fail(1)) SWIG_fail;
6353 {
6354 PyThreadState* __tstate = wxPyBeginAllowThreads();
6355 result = (wxWindow *)(arg1)->GetWindow();
6356
6357 wxPyEndAllowThreads(__tstate);
6358 if (PyErr_Occurred()) SWIG_fail;
6359 }
6360 {
6361 resultobj = wxPyMake_wxObject(result, 0);
6362 }
6363 return resultobj;
6364 fail:
6365 return NULL;
6366 }
6367
6368
6369 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6370 PyObject *resultobj;
6371 bool arg1 ;
6372 PyObject * obj0 = 0 ;
6373 char *kwnames[] = {
6374 (char *) "flag", NULL
6375 };
6376
6377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6378 {
6379 arg1 = (bool)(SWIG_As_bool(obj0));
6380 if (SWIG_arg_fail(1)) SWIG_fail;
6381 }
6382 {
6383 PyThreadState* __tstate = wxPyBeginAllowThreads();
6384 wxToolTip::Enable(arg1);
6385
6386 wxPyEndAllowThreads(__tstate);
6387 if (PyErr_Occurred()) SWIG_fail;
6388 }
6389 Py_INCREF(Py_None); resultobj = Py_None;
6390 return resultobj;
6391 fail:
6392 return NULL;
6393 }
6394
6395
6396 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6397 PyObject *resultobj;
6398 long arg1 ;
6399 PyObject * obj0 = 0 ;
6400 char *kwnames[] = {
6401 (char *) "milliseconds", NULL
6402 };
6403
6404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6405 {
6406 arg1 = (long)(SWIG_As_long(obj0));
6407 if (SWIG_arg_fail(1)) SWIG_fail;
6408 }
6409 {
6410 PyThreadState* __tstate = wxPyBeginAllowThreads();
6411 wxToolTip::SetDelay(arg1);
6412
6413 wxPyEndAllowThreads(__tstate);
6414 if (PyErr_Occurred()) SWIG_fail;
6415 }
6416 Py_INCREF(Py_None); resultobj = Py_None;
6417 return resultobj;
6418 fail:
6419 return NULL;
6420 }
6421
6422
6423 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6424 PyObject *obj;
6425 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6426 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6427 Py_INCREF(obj);
6428 return Py_BuildValue((char *)"");
6429 }
6430 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6431 PyObject *resultobj;
6432 wxWindow *arg1 = (wxWindow *) 0 ;
6433 wxSize *arg2 = 0 ;
6434 wxCaret *result;
6435 wxSize temp2 ;
6436 PyObject * obj0 = 0 ;
6437 PyObject * obj1 = 0 ;
6438 char *kwnames[] = {
6439 (char *) "window",(char *) "size", NULL
6440 };
6441
6442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6444 if (SWIG_arg_fail(1)) SWIG_fail;
6445 {
6446 arg2 = &temp2;
6447 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6448 }
6449 {
6450 if (!wxPyCheckForApp()) SWIG_fail;
6451 PyThreadState* __tstate = wxPyBeginAllowThreads();
6452 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6453
6454 wxPyEndAllowThreads(__tstate);
6455 if (PyErr_Occurred()) SWIG_fail;
6456 }
6457 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6458 return resultobj;
6459 fail:
6460 return NULL;
6461 }
6462
6463
6464 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6465 PyObject *resultobj;
6466 wxCaret *arg1 = (wxCaret *) 0 ;
6467 PyObject * obj0 = 0 ;
6468 char *kwnames[] = {
6469 (char *) "self", NULL
6470 };
6471
6472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6474 if (SWIG_arg_fail(1)) SWIG_fail;
6475 {
6476 PyThreadState* __tstate = wxPyBeginAllowThreads();
6477 wxCaret_Destroy(arg1);
6478
6479 wxPyEndAllowThreads(__tstate);
6480 if (PyErr_Occurred()) SWIG_fail;
6481 }
6482 Py_INCREF(Py_None); resultobj = Py_None;
6483 return resultobj;
6484 fail:
6485 return NULL;
6486 }
6487
6488
6489 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6490 PyObject *resultobj;
6491 wxCaret *arg1 = (wxCaret *) 0 ;
6492 bool result;
6493 PyObject * obj0 = 0 ;
6494 char *kwnames[] = {
6495 (char *) "self", NULL
6496 };
6497
6498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6500 if (SWIG_arg_fail(1)) SWIG_fail;
6501 {
6502 PyThreadState* __tstate = wxPyBeginAllowThreads();
6503 result = (bool)(arg1)->IsOk();
6504
6505 wxPyEndAllowThreads(__tstate);
6506 if (PyErr_Occurred()) SWIG_fail;
6507 }
6508 {
6509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6510 }
6511 return resultobj;
6512 fail:
6513 return NULL;
6514 }
6515
6516
6517 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6518 PyObject *resultobj;
6519 wxCaret *arg1 = (wxCaret *) 0 ;
6520 bool result;
6521 PyObject * obj0 = 0 ;
6522 char *kwnames[] = {
6523 (char *) "self", NULL
6524 };
6525
6526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6528 if (SWIG_arg_fail(1)) SWIG_fail;
6529 {
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 result = (bool)(arg1)->IsVisible();
6532
6533 wxPyEndAllowThreads(__tstate);
6534 if (PyErr_Occurred()) SWIG_fail;
6535 }
6536 {
6537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6538 }
6539 return resultobj;
6540 fail:
6541 return NULL;
6542 }
6543
6544
6545 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6546 PyObject *resultobj;
6547 wxCaret *arg1 = (wxCaret *) 0 ;
6548 wxPoint result;
6549 PyObject * obj0 = 0 ;
6550 char *kwnames[] = {
6551 (char *) "self", NULL
6552 };
6553
6554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6556 if (SWIG_arg_fail(1)) SWIG_fail;
6557 {
6558 PyThreadState* __tstate = wxPyBeginAllowThreads();
6559 result = (arg1)->GetPosition();
6560
6561 wxPyEndAllowThreads(__tstate);
6562 if (PyErr_Occurred()) SWIG_fail;
6563 }
6564 {
6565 wxPoint * resultptr;
6566 resultptr = new wxPoint((wxPoint &)(result));
6567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6568 }
6569 return resultobj;
6570 fail:
6571 return NULL;
6572 }
6573
6574
6575 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6576 PyObject *resultobj;
6577 wxCaret *arg1 = (wxCaret *) 0 ;
6578 int *arg2 = (int *) 0 ;
6579 int *arg3 = (int *) 0 ;
6580 int temp2 ;
6581 int res2 = 0 ;
6582 int temp3 ;
6583 int res3 = 0 ;
6584 PyObject * obj0 = 0 ;
6585 char *kwnames[] = {
6586 (char *) "self", NULL
6587 };
6588
6589 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6590 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6593 if (SWIG_arg_fail(1)) SWIG_fail;
6594 {
6595 PyThreadState* __tstate = wxPyBeginAllowThreads();
6596 (arg1)->GetPosition(arg2,arg3);
6597
6598 wxPyEndAllowThreads(__tstate);
6599 if (PyErr_Occurred()) SWIG_fail;
6600 }
6601 Py_INCREF(Py_None); resultobj = Py_None;
6602 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6603 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6604 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6605 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6606 return resultobj;
6607 fail:
6608 return NULL;
6609 }
6610
6611
6612 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6613 PyObject *resultobj;
6614 wxCaret *arg1 = (wxCaret *) 0 ;
6615 wxSize result;
6616 PyObject * obj0 = 0 ;
6617 char *kwnames[] = {
6618 (char *) "self", NULL
6619 };
6620
6621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6623 if (SWIG_arg_fail(1)) SWIG_fail;
6624 {
6625 PyThreadState* __tstate = wxPyBeginAllowThreads();
6626 result = (arg1)->GetSize();
6627
6628 wxPyEndAllowThreads(__tstate);
6629 if (PyErr_Occurred()) SWIG_fail;
6630 }
6631 {
6632 wxSize * resultptr;
6633 resultptr = new wxSize((wxSize &)(result));
6634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6635 }
6636 return resultobj;
6637 fail:
6638 return NULL;
6639 }
6640
6641
6642 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6643 PyObject *resultobj;
6644 wxCaret *arg1 = (wxCaret *) 0 ;
6645 int *arg2 = (int *) 0 ;
6646 int *arg3 = (int *) 0 ;
6647 int temp2 ;
6648 int res2 = 0 ;
6649 int temp3 ;
6650 int res3 = 0 ;
6651 PyObject * obj0 = 0 ;
6652 char *kwnames[] = {
6653 (char *) "self", NULL
6654 };
6655
6656 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6657 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6660 if (SWIG_arg_fail(1)) SWIG_fail;
6661 {
6662 PyThreadState* __tstate = wxPyBeginAllowThreads();
6663 (arg1)->GetSize(arg2,arg3);
6664
6665 wxPyEndAllowThreads(__tstate);
6666 if (PyErr_Occurred()) SWIG_fail;
6667 }
6668 Py_INCREF(Py_None); resultobj = Py_None;
6669 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6670 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6671 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6672 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6673 return resultobj;
6674 fail:
6675 return NULL;
6676 }
6677
6678
6679 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6680 PyObject *resultobj;
6681 wxCaret *arg1 = (wxCaret *) 0 ;
6682 wxWindow *result;
6683 PyObject * obj0 = 0 ;
6684 char *kwnames[] = {
6685 (char *) "self", NULL
6686 };
6687
6688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6690 if (SWIG_arg_fail(1)) SWIG_fail;
6691 {
6692 PyThreadState* __tstate = wxPyBeginAllowThreads();
6693 result = (wxWindow *)(arg1)->GetWindow();
6694
6695 wxPyEndAllowThreads(__tstate);
6696 if (PyErr_Occurred()) SWIG_fail;
6697 }
6698 {
6699 resultobj = wxPyMake_wxObject(result, 0);
6700 }
6701 return resultobj;
6702 fail:
6703 return NULL;
6704 }
6705
6706
6707 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6708 PyObject *resultobj;
6709 wxCaret *arg1 = (wxCaret *) 0 ;
6710 int arg2 ;
6711 int arg3 ;
6712 PyObject * obj0 = 0 ;
6713 PyObject * obj1 = 0 ;
6714 PyObject * obj2 = 0 ;
6715 char *kwnames[] = {
6716 (char *) "self",(char *) "x",(char *) "y", NULL
6717 };
6718
6719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6721 if (SWIG_arg_fail(1)) SWIG_fail;
6722 {
6723 arg2 = (int)(SWIG_As_int(obj1));
6724 if (SWIG_arg_fail(2)) SWIG_fail;
6725 }
6726 {
6727 arg3 = (int)(SWIG_As_int(obj2));
6728 if (SWIG_arg_fail(3)) SWIG_fail;
6729 }
6730 {
6731 PyThreadState* __tstate = wxPyBeginAllowThreads();
6732 (arg1)->Move(arg2,arg3);
6733
6734 wxPyEndAllowThreads(__tstate);
6735 if (PyErr_Occurred()) SWIG_fail;
6736 }
6737 Py_INCREF(Py_None); resultobj = Py_None;
6738 return resultobj;
6739 fail:
6740 return NULL;
6741 }
6742
6743
6744 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6745 PyObject *resultobj;
6746 wxCaret *arg1 = (wxCaret *) 0 ;
6747 wxPoint *arg2 = 0 ;
6748 wxPoint temp2 ;
6749 PyObject * obj0 = 0 ;
6750 PyObject * obj1 = 0 ;
6751 char *kwnames[] = {
6752 (char *) "self",(char *) "pt", NULL
6753 };
6754
6755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6757 if (SWIG_arg_fail(1)) SWIG_fail;
6758 {
6759 arg2 = &temp2;
6760 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6761 }
6762 {
6763 PyThreadState* __tstate = wxPyBeginAllowThreads();
6764 (arg1)->Move((wxPoint const &)*arg2);
6765
6766 wxPyEndAllowThreads(__tstate);
6767 if (PyErr_Occurred()) SWIG_fail;
6768 }
6769 Py_INCREF(Py_None); resultobj = Py_None;
6770 return resultobj;
6771 fail:
6772 return NULL;
6773 }
6774
6775
6776 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6777 PyObject *resultobj;
6778 wxCaret *arg1 = (wxCaret *) 0 ;
6779 int arg2 ;
6780 int arg3 ;
6781 PyObject * obj0 = 0 ;
6782 PyObject * obj1 = 0 ;
6783 PyObject * obj2 = 0 ;
6784 char *kwnames[] = {
6785 (char *) "self",(char *) "width",(char *) "height", NULL
6786 };
6787
6788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6790 if (SWIG_arg_fail(1)) SWIG_fail;
6791 {
6792 arg2 = (int)(SWIG_As_int(obj1));
6793 if (SWIG_arg_fail(2)) SWIG_fail;
6794 }
6795 {
6796 arg3 = (int)(SWIG_As_int(obj2));
6797 if (SWIG_arg_fail(3)) SWIG_fail;
6798 }
6799 {
6800 PyThreadState* __tstate = wxPyBeginAllowThreads();
6801 (arg1)->SetSize(arg2,arg3);
6802
6803 wxPyEndAllowThreads(__tstate);
6804 if (PyErr_Occurred()) SWIG_fail;
6805 }
6806 Py_INCREF(Py_None); resultobj = Py_None;
6807 return resultobj;
6808 fail:
6809 return NULL;
6810 }
6811
6812
6813 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6814 PyObject *resultobj;
6815 wxCaret *arg1 = (wxCaret *) 0 ;
6816 wxSize *arg2 = 0 ;
6817 wxSize temp2 ;
6818 PyObject * obj0 = 0 ;
6819 PyObject * obj1 = 0 ;
6820 char *kwnames[] = {
6821 (char *) "self",(char *) "size", NULL
6822 };
6823
6824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6826 if (SWIG_arg_fail(1)) SWIG_fail;
6827 {
6828 arg2 = &temp2;
6829 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6830 }
6831 {
6832 PyThreadState* __tstate = wxPyBeginAllowThreads();
6833 (arg1)->SetSize((wxSize const &)*arg2);
6834
6835 wxPyEndAllowThreads(__tstate);
6836 if (PyErr_Occurred()) SWIG_fail;
6837 }
6838 Py_INCREF(Py_None); resultobj = Py_None;
6839 return resultobj;
6840 fail:
6841 return NULL;
6842 }
6843
6844
6845 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6846 PyObject *resultobj;
6847 wxCaret *arg1 = (wxCaret *) 0 ;
6848 int arg2 = (int) true ;
6849 PyObject * obj0 = 0 ;
6850 PyObject * obj1 = 0 ;
6851 char *kwnames[] = {
6852 (char *) "self",(char *) "show", NULL
6853 };
6854
6855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6857 if (SWIG_arg_fail(1)) SWIG_fail;
6858 if (obj1) {
6859 {
6860 arg2 = (int)(SWIG_As_int(obj1));
6861 if (SWIG_arg_fail(2)) SWIG_fail;
6862 }
6863 }
6864 {
6865 PyThreadState* __tstate = wxPyBeginAllowThreads();
6866 (arg1)->Show(arg2);
6867
6868 wxPyEndAllowThreads(__tstate);
6869 if (PyErr_Occurred()) SWIG_fail;
6870 }
6871 Py_INCREF(Py_None); resultobj = Py_None;
6872 return resultobj;
6873 fail:
6874 return NULL;
6875 }
6876
6877
6878 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6879 PyObject *resultobj;
6880 wxCaret *arg1 = (wxCaret *) 0 ;
6881 PyObject * obj0 = 0 ;
6882 char *kwnames[] = {
6883 (char *) "self", NULL
6884 };
6885
6886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6888 if (SWIG_arg_fail(1)) SWIG_fail;
6889 {
6890 PyThreadState* __tstate = wxPyBeginAllowThreads();
6891 (arg1)->Hide();
6892
6893 wxPyEndAllowThreads(__tstate);
6894 if (PyErr_Occurred()) SWIG_fail;
6895 }
6896 Py_INCREF(Py_None); resultobj = Py_None;
6897 return resultobj;
6898 fail:
6899 return NULL;
6900 }
6901
6902
6903 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6904 PyObject *resultobj;
6905 int result;
6906 char *kwnames[] = {
6907 NULL
6908 };
6909
6910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6911 {
6912 PyThreadState* __tstate = wxPyBeginAllowThreads();
6913 result = (int)wxCaret::GetBlinkTime();
6914
6915 wxPyEndAllowThreads(__tstate);
6916 if (PyErr_Occurred()) SWIG_fail;
6917 }
6918 {
6919 resultobj = SWIG_From_int((int)(result));
6920 }
6921 return resultobj;
6922 fail:
6923 return NULL;
6924 }
6925
6926
6927 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6928 PyObject *resultobj;
6929 int arg1 ;
6930 PyObject * obj0 = 0 ;
6931 char *kwnames[] = {
6932 (char *) "milliseconds", NULL
6933 };
6934
6935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6936 {
6937 arg1 = (int)(SWIG_As_int(obj0));
6938 if (SWIG_arg_fail(1)) SWIG_fail;
6939 }
6940 {
6941 PyThreadState* __tstate = wxPyBeginAllowThreads();
6942 wxCaret::SetBlinkTime(arg1);
6943
6944 wxPyEndAllowThreads(__tstate);
6945 if (PyErr_Occurred()) SWIG_fail;
6946 }
6947 Py_INCREF(Py_None); resultobj = Py_None;
6948 return resultobj;
6949 fail:
6950 return NULL;
6951 }
6952
6953
6954 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6955 PyObject *obj;
6956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6957 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6958 Py_INCREF(obj);
6959 return Py_BuildValue((char *)"");
6960 }
6961 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6962 PyObject *resultobj;
6963 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6964 wxBusyCursor *result;
6965 PyObject * obj0 = 0 ;
6966 char *kwnames[] = {
6967 (char *) "cursor", NULL
6968 };
6969
6970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6971 if (obj0) {
6972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6973 if (SWIG_arg_fail(1)) SWIG_fail;
6974 }
6975 {
6976 if (!wxPyCheckForApp()) SWIG_fail;
6977 PyThreadState* __tstate = wxPyBeginAllowThreads();
6978 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6979
6980 wxPyEndAllowThreads(__tstate);
6981 if (PyErr_Occurred()) SWIG_fail;
6982 }
6983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6984 return resultobj;
6985 fail:
6986 return NULL;
6987 }
6988
6989
6990 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6991 PyObject *resultobj;
6992 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6993 PyObject * obj0 = 0 ;
6994 char *kwnames[] = {
6995 (char *) "self", NULL
6996 };
6997
6998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
7000 if (SWIG_arg_fail(1)) SWIG_fail;
7001 {
7002 PyThreadState* __tstate = wxPyBeginAllowThreads();
7003 delete arg1;
7004
7005 wxPyEndAllowThreads(__tstate);
7006 if (PyErr_Occurred()) SWIG_fail;
7007 }
7008 Py_INCREF(Py_None); resultobj = Py_None;
7009 return resultobj;
7010 fail:
7011 return NULL;
7012 }
7013
7014
7015 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
7016 PyObject *obj;
7017 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7018 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
7019 Py_INCREF(obj);
7020 return Py_BuildValue((char *)"");
7021 }
7022 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7023 PyObject *resultobj;
7024 wxWindow *arg1 = (wxWindow *) NULL ;
7025 wxWindowDisabler *result;
7026 PyObject * obj0 = 0 ;
7027 char *kwnames[] = {
7028 (char *) "winToSkip", NULL
7029 };
7030
7031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7032 if (obj0) {
7033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7034 if (SWIG_arg_fail(1)) SWIG_fail;
7035 }
7036 {
7037 if (!wxPyCheckForApp()) SWIG_fail;
7038 PyThreadState* __tstate = wxPyBeginAllowThreads();
7039 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7040
7041 wxPyEndAllowThreads(__tstate);
7042 if (PyErr_Occurred()) SWIG_fail;
7043 }
7044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7045 return resultobj;
7046 fail:
7047 return NULL;
7048 }
7049
7050
7051 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7052 PyObject *resultobj;
7053 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7054 PyObject * obj0 = 0 ;
7055 char *kwnames[] = {
7056 (char *) "self", NULL
7057 };
7058
7059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7061 if (SWIG_arg_fail(1)) SWIG_fail;
7062 {
7063 PyThreadState* __tstate = wxPyBeginAllowThreads();
7064 delete arg1;
7065
7066 wxPyEndAllowThreads(__tstate);
7067 if (PyErr_Occurred()) SWIG_fail;
7068 }
7069 Py_INCREF(Py_None); resultobj = Py_None;
7070 return resultobj;
7071 fail:
7072 return NULL;
7073 }
7074
7075
7076 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7077 PyObject *obj;
7078 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7079 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7080 Py_INCREF(obj);
7081 return Py_BuildValue((char *)"");
7082 }
7083 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7084 PyObject *resultobj;
7085 wxString *arg1 = 0 ;
7086 wxBusyInfo *result;
7087 bool temp1 = false ;
7088 PyObject * obj0 = 0 ;
7089 char *kwnames[] = {
7090 (char *) "message", NULL
7091 };
7092
7093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7094 {
7095 arg1 = wxString_in_helper(obj0);
7096 if (arg1 == NULL) SWIG_fail;
7097 temp1 = true;
7098 }
7099 {
7100 if (!wxPyCheckForApp()) SWIG_fail;
7101 PyThreadState* __tstate = wxPyBeginAllowThreads();
7102 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7103
7104 wxPyEndAllowThreads(__tstate);
7105 if (PyErr_Occurred()) SWIG_fail;
7106 }
7107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7108 {
7109 if (temp1)
7110 delete arg1;
7111 }
7112 return resultobj;
7113 fail:
7114 {
7115 if (temp1)
7116 delete arg1;
7117 }
7118 return NULL;
7119 }
7120
7121
7122 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7123 PyObject *resultobj;
7124 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7125 PyObject * obj0 = 0 ;
7126 char *kwnames[] = {
7127 (char *) "self", NULL
7128 };
7129
7130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7132 if (SWIG_arg_fail(1)) SWIG_fail;
7133 {
7134 PyThreadState* __tstate = wxPyBeginAllowThreads();
7135 delete arg1;
7136
7137 wxPyEndAllowThreads(__tstate);
7138 if (PyErr_Occurred()) SWIG_fail;
7139 }
7140 Py_INCREF(Py_None); resultobj = Py_None;
7141 return resultobj;
7142 fail:
7143 return NULL;
7144 }
7145
7146
7147 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7148 PyObject *obj;
7149 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7150 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7151 Py_INCREF(obj);
7152 return Py_BuildValue((char *)"");
7153 }
7154 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7155 PyObject *resultobj;
7156 wxStopWatch *result;
7157 char *kwnames[] = {
7158 NULL
7159 };
7160
7161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7162 {
7163 PyThreadState* __tstate = wxPyBeginAllowThreads();
7164 result = (wxStopWatch *)new wxStopWatch();
7165
7166 wxPyEndAllowThreads(__tstate);
7167 if (PyErr_Occurred()) SWIG_fail;
7168 }
7169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7170 return resultobj;
7171 fail:
7172 return NULL;
7173 }
7174
7175
7176 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7177 PyObject *resultobj;
7178 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7179 long arg2 = (long) 0 ;
7180 PyObject * obj0 = 0 ;
7181 PyObject * obj1 = 0 ;
7182 char *kwnames[] = {
7183 (char *) "self",(char *) "t0", NULL
7184 };
7185
7186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7188 if (SWIG_arg_fail(1)) SWIG_fail;
7189 if (obj1) {
7190 {
7191 arg2 = (long)(SWIG_As_long(obj1));
7192 if (SWIG_arg_fail(2)) SWIG_fail;
7193 }
7194 }
7195 {
7196 PyThreadState* __tstate = wxPyBeginAllowThreads();
7197 (arg1)->Start(arg2);
7198
7199 wxPyEndAllowThreads(__tstate);
7200 if (PyErr_Occurred()) SWIG_fail;
7201 }
7202 Py_INCREF(Py_None); resultobj = Py_None;
7203 return resultobj;
7204 fail:
7205 return NULL;
7206 }
7207
7208
7209 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7210 PyObject *resultobj;
7211 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7212 PyObject * obj0 = 0 ;
7213 char *kwnames[] = {
7214 (char *) "self", NULL
7215 };
7216
7217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7219 if (SWIG_arg_fail(1)) SWIG_fail;
7220 {
7221 PyThreadState* __tstate = wxPyBeginAllowThreads();
7222 (arg1)->Pause();
7223
7224 wxPyEndAllowThreads(__tstate);
7225 if (PyErr_Occurred()) SWIG_fail;
7226 }
7227 Py_INCREF(Py_None); resultobj = Py_None;
7228 return resultobj;
7229 fail:
7230 return NULL;
7231 }
7232
7233
7234 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7235 PyObject *resultobj;
7236 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7237 PyObject * obj0 = 0 ;
7238 char *kwnames[] = {
7239 (char *) "self", NULL
7240 };
7241
7242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7244 if (SWIG_arg_fail(1)) SWIG_fail;
7245 {
7246 PyThreadState* __tstate = wxPyBeginAllowThreads();
7247 (arg1)->Resume();
7248
7249 wxPyEndAllowThreads(__tstate);
7250 if (PyErr_Occurred()) SWIG_fail;
7251 }
7252 Py_INCREF(Py_None); resultobj = Py_None;
7253 return resultobj;
7254 fail:
7255 return NULL;
7256 }
7257
7258
7259 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7260 PyObject *resultobj;
7261 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7262 long result;
7263 PyObject * obj0 = 0 ;
7264 char *kwnames[] = {
7265 (char *) "self", NULL
7266 };
7267
7268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7270 if (SWIG_arg_fail(1)) SWIG_fail;
7271 {
7272 PyThreadState* __tstate = wxPyBeginAllowThreads();
7273 result = (long)((wxStopWatch const *)arg1)->Time();
7274
7275 wxPyEndAllowThreads(__tstate);
7276 if (PyErr_Occurred()) SWIG_fail;
7277 }
7278 {
7279 resultobj = SWIG_From_long((long)(result));
7280 }
7281 return resultobj;
7282 fail:
7283 return NULL;
7284 }
7285
7286
7287 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7288 PyObject *obj;
7289 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7290 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7291 Py_INCREF(obj);
7292 return Py_BuildValue((char *)"");
7293 }
7294 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7295 PyObject *resultobj;
7296 int arg1 = (int) 9 ;
7297 int arg2 = (int) wxID_FILE1 ;
7298 wxFileHistory *result;
7299 PyObject * obj0 = 0 ;
7300 PyObject * obj1 = 0 ;
7301 char *kwnames[] = {
7302 (char *) "maxFiles",(char *) "idBase", NULL
7303 };
7304
7305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7306 if (obj0) {
7307 {
7308 arg1 = (int)(SWIG_As_int(obj0));
7309 if (SWIG_arg_fail(1)) SWIG_fail;
7310 }
7311 }
7312 if (obj1) {
7313 {
7314 arg2 = (int)(SWIG_As_int(obj1));
7315 if (SWIG_arg_fail(2)) SWIG_fail;
7316 }
7317 }
7318 {
7319 PyThreadState* __tstate = wxPyBeginAllowThreads();
7320 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7321
7322 wxPyEndAllowThreads(__tstate);
7323 if (PyErr_Occurred()) SWIG_fail;
7324 }
7325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7326 return resultobj;
7327 fail:
7328 return NULL;
7329 }
7330
7331
7332 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7333 PyObject *resultobj;
7334 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7335 PyObject * obj0 = 0 ;
7336 char *kwnames[] = {
7337 (char *) "self", NULL
7338 };
7339
7340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7342 if (SWIG_arg_fail(1)) SWIG_fail;
7343 {
7344 PyThreadState* __tstate = wxPyBeginAllowThreads();
7345 delete arg1;
7346
7347 wxPyEndAllowThreads(__tstate);
7348 if (PyErr_Occurred()) SWIG_fail;
7349 }
7350 Py_INCREF(Py_None); resultobj = Py_None;
7351 return resultobj;
7352 fail:
7353 return NULL;
7354 }
7355
7356
7357 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7358 PyObject *resultobj;
7359 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7360 wxString *arg2 = 0 ;
7361 bool temp2 = false ;
7362 PyObject * obj0 = 0 ;
7363 PyObject * obj1 = 0 ;
7364 char *kwnames[] = {
7365 (char *) "self",(char *) "file", NULL
7366 };
7367
7368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7370 if (SWIG_arg_fail(1)) SWIG_fail;
7371 {
7372 arg2 = wxString_in_helper(obj1);
7373 if (arg2 == NULL) SWIG_fail;
7374 temp2 = true;
7375 }
7376 {
7377 PyThreadState* __tstate = wxPyBeginAllowThreads();
7378 (arg1)->AddFileToHistory((wxString const &)*arg2);
7379
7380 wxPyEndAllowThreads(__tstate);
7381 if (PyErr_Occurred()) SWIG_fail;
7382 }
7383 Py_INCREF(Py_None); resultobj = Py_None;
7384 {
7385 if (temp2)
7386 delete arg2;
7387 }
7388 return resultobj;
7389 fail:
7390 {
7391 if (temp2)
7392 delete arg2;
7393 }
7394 return NULL;
7395 }
7396
7397
7398 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7399 PyObject *resultobj;
7400 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7401 int arg2 ;
7402 PyObject * obj0 = 0 ;
7403 PyObject * obj1 = 0 ;
7404 char *kwnames[] = {
7405 (char *) "self",(char *) "i", NULL
7406 };
7407
7408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7410 if (SWIG_arg_fail(1)) SWIG_fail;
7411 {
7412 arg2 = (int)(SWIG_As_int(obj1));
7413 if (SWIG_arg_fail(2)) SWIG_fail;
7414 }
7415 {
7416 PyThreadState* __tstate = wxPyBeginAllowThreads();
7417 (arg1)->RemoveFileFromHistory(arg2);
7418
7419 wxPyEndAllowThreads(__tstate);
7420 if (PyErr_Occurred()) SWIG_fail;
7421 }
7422 Py_INCREF(Py_None); resultobj = Py_None;
7423 return resultobj;
7424 fail:
7425 return NULL;
7426 }
7427
7428
7429 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7430 PyObject *resultobj;
7431 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7432 int result;
7433 PyObject * obj0 = 0 ;
7434 char *kwnames[] = {
7435 (char *) "self", NULL
7436 };
7437
7438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7440 if (SWIG_arg_fail(1)) SWIG_fail;
7441 {
7442 PyThreadState* __tstate = wxPyBeginAllowThreads();
7443 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7444
7445 wxPyEndAllowThreads(__tstate);
7446 if (PyErr_Occurred()) SWIG_fail;
7447 }
7448 {
7449 resultobj = SWIG_From_int((int)(result));
7450 }
7451 return resultobj;
7452 fail:
7453 return NULL;
7454 }
7455
7456
7457 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7458 PyObject *resultobj;
7459 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7460 wxMenu *arg2 = (wxMenu *) 0 ;
7461 PyObject * obj0 = 0 ;
7462 PyObject * obj1 = 0 ;
7463 char *kwnames[] = {
7464 (char *) "self",(char *) "menu", NULL
7465 };
7466
7467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7469 if (SWIG_arg_fail(1)) SWIG_fail;
7470 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7471 if (SWIG_arg_fail(2)) SWIG_fail;
7472 {
7473 PyThreadState* __tstate = wxPyBeginAllowThreads();
7474 (arg1)->UseMenu(arg2);
7475
7476 wxPyEndAllowThreads(__tstate);
7477 if (PyErr_Occurred()) SWIG_fail;
7478 }
7479 Py_INCREF(Py_None); resultobj = Py_None;
7480 return resultobj;
7481 fail:
7482 return NULL;
7483 }
7484
7485
7486 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7487 PyObject *resultobj;
7488 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7489 wxMenu *arg2 = (wxMenu *) 0 ;
7490 PyObject * obj0 = 0 ;
7491 PyObject * obj1 = 0 ;
7492 char *kwnames[] = {
7493 (char *) "self",(char *) "menu", NULL
7494 };
7495
7496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7498 if (SWIG_arg_fail(1)) SWIG_fail;
7499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7500 if (SWIG_arg_fail(2)) SWIG_fail;
7501 {
7502 PyThreadState* __tstate = wxPyBeginAllowThreads();
7503 (arg1)->RemoveMenu(arg2);
7504
7505 wxPyEndAllowThreads(__tstate);
7506 if (PyErr_Occurred()) SWIG_fail;
7507 }
7508 Py_INCREF(Py_None); resultobj = Py_None;
7509 return resultobj;
7510 fail:
7511 return NULL;
7512 }
7513
7514
7515 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7516 PyObject *resultobj;
7517 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7518 wxConfigBase *arg2 = 0 ;
7519 PyObject * obj0 = 0 ;
7520 PyObject * obj1 = 0 ;
7521 char *kwnames[] = {
7522 (char *) "self",(char *) "config", NULL
7523 };
7524
7525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7527 if (SWIG_arg_fail(1)) SWIG_fail;
7528 {
7529 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7530 if (SWIG_arg_fail(2)) SWIG_fail;
7531 if (arg2 == NULL) {
7532 SWIG_null_ref("wxConfigBase");
7533 }
7534 if (SWIG_arg_fail(2)) SWIG_fail;
7535 }
7536 {
7537 PyThreadState* __tstate = wxPyBeginAllowThreads();
7538 (arg1)->Load(*arg2);
7539
7540 wxPyEndAllowThreads(__tstate);
7541 if (PyErr_Occurred()) SWIG_fail;
7542 }
7543 Py_INCREF(Py_None); resultobj = Py_None;
7544 return resultobj;
7545 fail:
7546 return NULL;
7547 }
7548
7549
7550 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7551 PyObject *resultobj;
7552 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7553 wxConfigBase *arg2 = 0 ;
7554 PyObject * obj0 = 0 ;
7555 PyObject * obj1 = 0 ;
7556 char *kwnames[] = {
7557 (char *) "self",(char *) "config", NULL
7558 };
7559
7560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7562 if (SWIG_arg_fail(1)) SWIG_fail;
7563 {
7564 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7565 if (SWIG_arg_fail(2)) SWIG_fail;
7566 if (arg2 == NULL) {
7567 SWIG_null_ref("wxConfigBase");
7568 }
7569 if (SWIG_arg_fail(2)) SWIG_fail;
7570 }
7571 {
7572 PyThreadState* __tstate = wxPyBeginAllowThreads();
7573 (arg1)->Save(*arg2);
7574
7575 wxPyEndAllowThreads(__tstate);
7576 if (PyErr_Occurred()) SWIG_fail;
7577 }
7578 Py_INCREF(Py_None); resultobj = Py_None;
7579 return resultobj;
7580 fail:
7581 return NULL;
7582 }
7583
7584
7585 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7586 PyObject *resultobj;
7587 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7588 PyObject * obj0 = 0 ;
7589 char *kwnames[] = {
7590 (char *) "self", NULL
7591 };
7592
7593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7595 if (SWIG_arg_fail(1)) SWIG_fail;
7596 {
7597 PyThreadState* __tstate = wxPyBeginAllowThreads();
7598 (arg1)->AddFilesToMenu();
7599
7600 wxPyEndAllowThreads(__tstate);
7601 if (PyErr_Occurred()) SWIG_fail;
7602 }
7603 Py_INCREF(Py_None); resultobj = Py_None;
7604 return resultobj;
7605 fail:
7606 return NULL;
7607 }
7608
7609
7610 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7611 PyObject *resultobj;
7612 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7613 wxMenu *arg2 = (wxMenu *) 0 ;
7614 PyObject * obj0 = 0 ;
7615 PyObject * obj1 = 0 ;
7616 char *kwnames[] = {
7617 (char *) "self",(char *) "menu", NULL
7618 };
7619
7620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7622 if (SWIG_arg_fail(1)) SWIG_fail;
7623 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7624 if (SWIG_arg_fail(2)) SWIG_fail;
7625 {
7626 PyThreadState* __tstate = wxPyBeginAllowThreads();
7627 (arg1)->AddFilesToMenu(arg2);
7628
7629 wxPyEndAllowThreads(__tstate);
7630 if (PyErr_Occurred()) SWIG_fail;
7631 }
7632 Py_INCREF(Py_None); resultobj = Py_None;
7633 return resultobj;
7634 fail:
7635 return NULL;
7636 }
7637
7638
7639 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7640 PyObject *resultobj;
7641 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7642 int arg2 ;
7643 wxString result;
7644 PyObject * obj0 = 0 ;
7645 PyObject * obj1 = 0 ;
7646 char *kwnames[] = {
7647 (char *) "self",(char *) "i", NULL
7648 };
7649
7650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7652 if (SWIG_arg_fail(1)) SWIG_fail;
7653 {
7654 arg2 = (int)(SWIG_As_int(obj1));
7655 if (SWIG_arg_fail(2)) SWIG_fail;
7656 }
7657 {
7658 PyThreadState* __tstate = wxPyBeginAllowThreads();
7659 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7660
7661 wxPyEndAllowThreads(__tstate);
7662 if (PyErr_Occurred()) SWIG_fail;
7663 }
7664 {
7665 #if wxUSE_UNICODE
7666 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7667 #else
7668 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7669 #endif
7670 }
7671 return resultobj;
7672 fail:
7673 return NULL;
7674 }
7675
7676
7677 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7678 PyObject *resultobj;
7679 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7680 int result;
7681 PyObject * obj0 = 0 ;
7682 char *kwnames[] = {
7683 (char *) "self", NULL
7684 };
7685
7686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7688 if (SWIG_arg_fail(1)) SWIG_fail;
7689 {
7690 PyThreadState* __tstate = wxPyBeginAllowThreads();
7691 result = (int)((wxFileHistory const *)arg1)->GetCount();
7692
7693 wxPyEndAllowThreads(__tstate);
7694 if (PyErr_Occurred()) SWIG_fail;
7695 }
7696 {
7697 resultobj = SWIG_From_int((int)(result));
7698 }
7699 return resultobj;
7700 fail:
7701 return NULL;
7702 }
7703
7704
7705 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7706 PyObject *obj;
7707 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7708 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7709 Py_INCREF(obj);
7710 return Py_BuildValue((char *)"");
7711 }
7712 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7713 PyObject *resultobj;
7714 wxString *arg1 = 0 ;
7715 wxString const &arg2_defvalue = wxPyEmptyString ;
7716 wxString *arg2 = (wxString *) &arg2_defvalue ;
7717 wxSingleInstanceChecker *result;
7718 bool temp1 = false ;
7719 bool temp2 = false ;
7720 PyObject * obj0 = 0 ;
7721 PyObject * obj1 = 0 ;
7722 char *kwnames[] = {
7723 (char *) "name",(char *) "path", NULL
7724 };
7725
7726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7727 {
7728 arg1 = wxString_in_helper(obj0);
7729 if (arg1 == NULL) SWIG_fail;
7730 temp1 = true;
7731 }
7732 if (obj1) {
7733 {
7734 arg2 = wxString_in_helper(obj1);
7735 if (arg2 == NULL) SWIG_fail;
7736 temp2 = true;
7737 }
7738 }
7739 {
7740 PyThreadState* __tstate = wxPyBeginAllowThreads();
7741 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7742
7743 wxPyEndAllowThreads(__tstate);
7744 if (PyErr_Occurred()) SWIG_fail;
7745 }
7746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7747 {
7748 if (temp1)
7749 delete arg1;
7750 }
7751 {
7752 if (temp2)
7753 delete arg2;
7754 }
7755 return resultobj;
7756 fail:
7757 {
7758 if (temp1)
7759 delete arg1;
7760 }
7761 {
7762 if (temp2)
7763 delete arg2;
7764 }
7765 return NULL;
7766 }
7767
7768
7769 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7770 PyObject *resultobj;
7771 wxSingleInstanceChecker *result;
7772 char *kwnames[] = {
7773 NULL
7774 };
7775
7776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7777 {
7778 PyThreadState* __tstate = wxPyBeginAllowThreads();
7779 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7780
7781 wxPyEndAllowThreads(__tstate);
7782 if (PyErr_Occurred()) SWIG_fail;
7783 }
7784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7785 return resultobj;
7786 fail:
7787 return NULL;
7788 }
7789
7790
7791 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7792 PyObject *resultobj;
7793 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7794 PyObject * obj0 = 0 ;
7795 char *kwnames[] = {
7796 (char *) "self", NULL
7797 };
7798
7799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7801 if (SWIG_arg_fail(1)) SWIG_fail;
7802 {
7803 PyThreadState* __tstate = wxPyBeginAllowThreads();
7804 delete arg1;
7805
7806 wxPyEndAllowThreads(__tstate);
7807 if (PyErr_Occurred()) SWIG_fail;
7808 }
7809 Py_INCREF(Py_None); resultobj = Py_None;
7810 return resultobj;
7811 fail:
7812 return NULL;
7813 }
7814
7815
7816 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7817 PyObject *resultobj;
7818 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7819 wxString *arg2 = 0 ;
7820 wxString const &arg3_defvalue = wxPyEmptyString ;
7821 wxString *arg3 = (wxString *) &arg3_defvalue ;
7822 bool result;
7823 bool temp2 = false ;
7824 bool temp3 = false ;
7825 PyObject * obj0 = 0 ;
7826 PyObject * obj1 = 0 ;
7827 PyObject * obj2 = 0 ;
7828 char *kwnames[] = {
7829 (char *) "self",(char *) "name",(char *) "path", NULL
7830 };
7831
7832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7834 if (SWIG_arg_fail(1)) SWIG_fail;
7835 {
7836 arg2 = wxString_in_helper(obj1);
7837 if (arg2 == NULL) SWIG_fail;
7838 temp2 = true;
7839 }
7840 if (obj2) {
7841 {
7842 arg3 = wxString_in_helper(obj2);
7843 if (arg3 == NULL) SWIG_fail;
7844 temp3 = true;
7845 }
7846 }
7847 {
7848 PyThreadState* __tstate = wxPyBeginAllowThreads();
7849 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7850
7851 wxPyEndAllowThreads(__tstate);
7852 if (PyErr_Occurred()) SWIG_fail;
7853 }
7854 {
7855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7856 }
7857 {
7858 if (temp2)
7859 delete arg2;
7860 }
7861 {
7862 if (temp3)
7863 delete arg3;
7864 }
7865 return resultobj;
7866 fail:
7867 {
7868 if (temp2)
7869 delete arg2;
7870 }
7871 {
7872 if (temp3)
7873 delete arg3;
7874 }
7875 return NULL;
7876 }
7877
7878
7879 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7880 PyObject *resultobj;
7881 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7882 bool result;
7883 PyObject * obj0 = 0 ;
7884 char *kwnames[] = {
7885 (char *) "self", NULL
7886 };
7887
7888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7890 if (SWIG_arg_fail(1)) SWIG_fail;
7891 {
7892 PyThreadState* __tstate = wxPyBeginAllowThreads();
7893 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7894
7895 wxPyEndAllowThreads(__tstate);
7896 if (PyErr_Occurred()) SWIG_fail;
7897 }
7898 {
7899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7900 }
7901 return resultobj;
7902 fail:
7903 return NULL;
7904 }
7905
7906
7907 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7908 PyObject *obj;
7909 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7910 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7911 Py_INCREF(obj);
7912 return Py_BuildValue((char *)"");
7913 }
7914 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7915 PyObject *resultobj;
7916 wxWindow *arg1 = (wxWindow *) 0 ;
7917 wxDC *arg2 = 0 ;
7918 bool result;
7919 PyObject * obj0 = 0 ;
7920 PyObject * obj1 = 0 ;
7921 char *kwnames[] = {
7922 (char *) "window",(char *) "dc", NULL
7923 };
7924
7925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7927 if (SWIG_arg_fail(1)) SWIG_fail;
7928 {
7929 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7930 if (SWIG_arg_fail(2)) SWIG_fail;
7931 if (arg2 == NULL) {
7932 SWIG_null_ref("wxDC");
7933 }
7934 if (SWIG_arg_fail(2)) SWIG_fail;
7935 }
7936 {
7937 PyThreadState* __tstate = wxPyBeginAllowThreads();
7938 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7939
7940 wxPyEndAllowThreads(__tstate);
7941 if (PyErr_Occurred()) SWIG_fail;
7942 }
7943 {
7944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7945 }
7946 return resultobj;
7947 fail:
7948 return NULL;
7949 }
7950
7951
7952 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7953 PyObject *resultobj;
7954 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7955 PyObject * obj0 = 0 ;
7956 char *kwnames[] = {
7957 (char *) "self", NULL
7958 };
7959
7960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7962 if (SWIG_arg_fail(1)) SWIG_fail;
7963 {
7964 PyThreadState* __tstate = wxPyBeginAllowThreads();
7965 delete arg1;
7966
7967 wxPyEndAllowThreads(__tstate);
7968 if (PyErr_Occurred()) SWIG_fail;
7969 }
7970 Py_INCREF(Py_None); resultobj = Py_None;
7971 return resultobj;
7972 fail:
7973 return NULL;
7974 }
7975
7976
7977 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7978 PyObject *resultobj;
7979 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7980 wxString result;
7981 PyObject * obj0 = 0 ;
7982 char *kwnames[] = {
7983 (char *) "self", NULL
7984 };
7985
7986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7988 if (SWIG_arg_fail(1)) SWIG_fail;
7989 {
7990 PyThreadState* __tstate = wxPyBeginAllowThreads();
7991 result = (arg1)->GetTip();
7992
7993 wxPyEndAllowThreads(__tstate);
7994 if (PyErr_Occurred()) SWIG_fail;
7995 }
7996 {
7997 #if wxUSE_UNICODE
7998 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7999 #else
8000 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8001 #endif
8002 }
8003 return resultobj;
8004 fail:
8005 return NULL;
8006 }
8007
8008
8009 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
8010 PyObject *resultobj;
8011 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8012 size_t result;
8013 PyObject * obj0 = 0 ;
8014 char *kwnames[] = {
8015 (char *) "self", NULL
8016 };
8017
8018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
8019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8020 if (SWIG_arg_fail(1)) SWIG_fail;
8021 {
8022 PyThreadState* __tstate = wxPyBeginAllowThreads();
8023 result = (size_t)(arg1)->GetCurrentTip();
8024
8025 wxPyEndAllowThreads(__tstate);
8026 if (PyErr_Occurred()) SWIG_fail;
8027 }
8028 {
8029 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8030 }
8031 return resultobj;
8032 fail:
8033 return NULL;
8034 }
8035
8036
8037 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8038 PyObject *resultobj;
8039 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8040 wxString *arg2 = 0 ;
8041 wxString result;
8042 bool temp2 = false ;
8043 PyObject * obj0 = 0 ;
8044 PyObject * obj1 = 0 ;
8045 char *kwnames[] = {
8046 (char *) "self",(char *) "tip", NULL
8047 };
8048
8049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8051 if (SWIG_arg_fail(1)) SWIG_fail;
8052 {
8053 arg2 = wxString_in_helper(obj1);
8054 if (arg2 == NULL) SWIG_fail;
8055 temp2 = true;
8056 }
8057 {
8058 PyThreadState* __tstate = wxPyBeginAllowThreads();
8059 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8060
8061 wxPyEndAllowThreads(__tstate);
8062 if (PyErr_Occurred()) SWIG_fail;
8063 }
8064 {
8065 #if wxUSE_UNICODE
8066 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8067 #else
8068 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8069 #endif
8070 }
8071 {
8072 if (temp2)
8073 delete arg2;
8074 }
8075 return resultobj;
8076 fail:
8077 {
8078 if (temp2)
8079 delete arg2;
8080 }
8081 return NULL;
8082 }
8083
8084
8085 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8086 PyObject *obj;
8087 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8088 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8089 Py_INCREF(obj);
8090 return Py_BuildValue((char *)"");
8091 }
8092 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8093 PyObject *resultobj;
8094 size_t arg1 ;
8095 wxPyTipProvider *result;
8096 PyObject * obj0 = 0 ;
8097 char *kwnames[] = {
8098 (char *) "currentTip", NULL
8099 };
8100
8101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8102 {
8103 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8104 if (SWIG_arg_fail(1)) SWIG_fail;
8105 }
8106 {
8107 PyThreadState* __tstate = wxPyBeginAllowThreads();
8108 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8109
8110 wxPyEndAllowThreads(__tstate);
8111 if (PyErr_Occurred()) SWIG_fail;
8112 }
8113 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8114 return resultobj;
8115 fail:
8116 return NULL;
8117 }
8118
8119
8120 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8121 PyObject *resultobj;
8122 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8123 PyObject *arg2 = (PyObject *) 0 ;
8124 PyObject *arg3 = (PyObject *) 0 ;
8125 PyObject * obj0 = 0 ;
8126 PyObject * obj1 = 0 ;
8127 PyObject * obj2 = 0 ;
8128 char *kwnames[] = {
8129 (char *) "self",(char *) "self",(char *) "_class", NULL
8130 };
8131
8132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8134 if (SWIG_arg_fail(1)) SWIG_fail;
8135 arg2 = obj1;
8136 arg3 = obj2;
8137 {
8138 PyThreadState* __tstate = wxPyBeginAllowThreads();
8139 (arg1)->_setCallbackInfo(arg2,arg3);
8140
8141 wxPyEndAllowThreads(__tstate);
8142 if (PyErr_Occurred()) SWIG_fail;
8143 }
8144 Py_INCREF(Py_None); resultobj = Py_None;
8145 return resultobj;
8146 fail:
8147 return NULL;
8148 }
8149
8150
8151 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8152 PyObject *obj;
8153 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8154 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8155 Py_INCREF(obj);
8156 return Py_BuildValue((char *)"");
8157 }
8158 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8159 PyObject *resultobj;
8160 wxWindow *arg1 = (wxWindow *) 0 ;
8161 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8162 bool arg3 = (bool) true ;
8163 bool result;
8164 PyObject * obj0 = 0 ;
8165 PyObject * obj1 = 0 ;
8166 PyObject * obj2 = 0 ;
8167 char *kwnames[] = {
8168 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8169 };
8170
8171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8173 if (SWIG_arg_fail(1)) SWIG_fail;
8174 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8175 if (SWIG_arg_fail(2)) SWIG_fail;
8176 if (obj2) {
8177 {
8178 arg3 = (bool)(SWIG_As_bool(obj2));
8179 if (SWIG_arg_fail(3)) SWIG_fail;
8180 }
8181 }
8182 {
8183 if (!wxPyCheckForApp()) SWIG_fail;
8184 PyThreadState* __tstate = wxPyBeginAllowThreads();
8185 result = (bool)wxShowTip(arg1,arg2,arg3);
8186
8187 wxPyEndAllowThreads(__tstate);
8188 if (PyErr_Occurred()) SWIG_fail;
8189 }
8190 {
8191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8192 }
8193 return resultobj;
8194 fail:
8195 return NULL;
8196 }
8197
8198
8199 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8200 PyObject *resultobj;
8201 wxString *arg1 = 0 ;
8202 size_t arg2 ;
8203 wxTipProvider *result;
8204 bool temp1 = false ;
8205 PyObject * obj0 = 0 ;
8206 PyObject * obj1 = 0 ;
8207 char *kwnames[] = {
8208 (char *) "filename",(char *) "currentTip", NULL
8209 };
8210
8211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8212 {
8213 arg1 = wxString_in_helper(obj0);
8214 if (arg1 == NULL) SWIG_fail;
8215 temp1 = true;
8216 }
8217 {
8218 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8219 if (SWIG_arg_fail(2)) SWIG_fail;
8220 }
8221 {
8222 if (!wxPyCheckForApp()) SWIG_fail;
8223 PyThreadState* __tstate = wxPyBeginAllowThreads();
8224 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8225
8226 wxPyEndAllowThreads(__tstate);
8227 if (PyErr_Occurred()) SWIG_fail;
8228 }
8229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8230 {
8231 if (temp1)
8232 delete arg1;
8233 }
8234 return resultobj;
8235 fail:
8236 {
8237 if (temp1)
8238 delete arg1;
8239 }
8240 return NULL;
8241 }
8242
8243
8244 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8245 PyObject *resultobj;
8246 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8247 int arg2 = (int) -1 ;
8248 wxPyTimer *result;
8249 PyObject * obj0 = 0 ;
8250 PyObject * obj1 = 0 ;
8251 char *kwnames[] = {
8252 (char *) "owner",(char *) "id", NULL
8253 };
8254
8255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8256 if (obj0) {
8257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8258 if (SWIG_arg_fail(1)) SWIG_fail;
8259 }
8260 if (obj1) {
8261 {
8262 arg2 = (int)(SWIG_As_int(obj1));
8263 if (SWIG_arg_fail(2)) SWIG_fail;
8264 }
8265 }
8266 {
8267 if (!wxPyCheckForApp()) SWIG_fail;
8268 PyThreadState* __tstate = wxPyBeginAllowThreads();
8269 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8270
8271 wxPyEndAllowThreads(__tstate);
8272 if (PyErr_Occurred()) SWIG_fail;
8273 }
8274 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8275 return resultobj;
8276 fail:
8277 return NULL;
8278 }
8279
8280
8281 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8282 PyObject *resultobj;
8283 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8284 PyObject * obj0 = 0 ;
8285 char *kwnames[] = {
8286 (char *) "self", NULL
8287 };
8288
8289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8291 if (SWIG_arg_fail(1)) SWIG_fail;
8292 {
8293 PyThreadState* __tstate = wxPyBeginAllowThreads();
8294 delete arg1;
8295
8296 wxPyEndAllowThreads(__tstate);
8297 if (PyErr_Occurred()) SWIG_fail;
8298 }
8299 Py_INCREF(Py_None); resultobj = Py_None;
8300 return resultobj;
8301 fail:
8302 return NULL;
8303 }
8304
8305
8306 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8307 PyObject *resultobj;
8308 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8309 PyObject *arg2 = (PyObject *) 0 ;
8310 PyObject *arg3 = (PyObject *) 0 ;
8311 int arg4 = (int) 1 ;
8312 PyObject * obj0 = 0 ;
8313 PyObject * obj1 = 0 ;
8314 PyObject * obj2 = 0 ;
8315 PyObject * obj3 = 0 ;
8316 char *kwnames[] = {
8317 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8318 };
8319
8320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8322 if (SWIG_arg_fail(1)) SWIG_fail;
8323 arg2 = obj1;
8324 arg3 = obj2;
8325 if (obj3) {
8326 {
8327 arg4 = (int)(SWIG_As_int(obj3));
8328 if (SWIG_arg_fail(4)) SWIG_fail;
8329 }
8330 }
8331 {
8332 PyThreadState* __tstate = wxPyBeginAllowThreads();
8333 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8334
8335 wxPyEndAllowThreads(__tstate);
8336 if (PyErr_Occurred()) SWIG_fail;
8337 }
8338 Py_INCREF(Py_None); resultobj = Py_None;
8339 return resultobj;
8340 fail:
8341 return NULL;
8342 }
8343
8344
8345 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8346 PyObject *resultobj;
8347 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8348 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8349 int arg3 = (int) -1 ;
8350 PyObject * obj0 = 0 ;
8351 PyObject * obj1 = 0 ;
8352 PyObject * obj2 = 0 ;
8353 char *kwnames[] = {
8354 (char *) "self",(char *) "owner",(char *) "id", NULL
8355 };
8356
8357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8359 if (SWIG_arg_fail(1)) SWIG_fail;
8360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8361 if (SWIG_arg_fail(2)) SWIG_fail;
8362 if (obj2) {
8363 {
8364 arg3 = (int)(SWIG_As_int(obj2));
8365 if (SWIG_arg_fail(3)) SWIG_fail;
8366 }
8367 }
8368 {
8369 PyThreadState* __tstate = wxPyBeginAllowThreads();
8370 (arg1)->SetOwner(arg2,arg3);
8371
8372 wxPyEndAllowThreads(__tstate);
8373 if (PyErr_Occurred()) SWIG_fail;
8374 }
8375 Py_INCREF(Py_None); resultobj = Py_None;
8376 return resultobj;
8377 fail:
8378 return NULL;
8379 }
8380
8381
8382 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8383 PyObject *resultobj;
8384 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8385 wxEvtHandler *result;
8386 PyObject * obj0 = 0 ;
8387 char *kwnames[] = {
8388 (char *) "self", NULL
8389 };
8390
8391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8393 if (SWIG_arg_fail(1)) SWIG_fail;
8394 {
8395 PyThreadState* __tstate = wxPyBeginAllowThreads();
8396 result = (wxEvtHandler *)(arg1)->GetOwner();
8397
8398 wxPyEndAllowThreads(__tstate);
8399 if (PyErr_Occurred()) SWIG_fail;
8400 }
8401 {
8402 resultobj = wxPyMake_wxObject(result, 0);
8403 }
8404 return resultobj;
8405 fail:
8406 return NULL;
8407 }
8408
8409
8410 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8411 PyObject *resultobj;
8412 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8413 int arg2 = (int) -1 ;
8414 bool arg3 = (bool) false ;
8415 bool result;
8416 PyObject * obj0 = 0 ;
8417 PyObject * obj1 = 0 ;
8418 PyObject * obj2 = 0 ;
8419 char *kwnames[] = {
8420 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8421 };
8422
8423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8425 if (SWIG_arg_fail(1)) SWIG_fail;
8426 if (obj1) {
8427 {
8428 arg2 = (int)(SWIG_As_int(obj1));
8429 if (SWIG_arg_fail(2)) SWIG_fail;
8430 }
8431 }
8432 if (obj2) {
8433 {
8434 arg3 = (bool)(SWIG_As_bool(obj2));
8435 if (SWIG_arg_fail(3)) SWIG_fail;
8436 }
8437 }
8438 {
8439 PyThreadState* __tstate = wxPyBeginAllowThreads();
8440 result = (bool)(arg1)->Start(arg2,arg3);
8441
8442 wxPyEndAllowThreads(__tstate);
8443 if (PyErr_Occurred()) SWIG_fail;
8444 }
8445 {
8446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8447 }
8448 return resultobj;
8449 fail:
8450 return NULL;
8451 }
8452
8453
8454 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8455 PyObject *resultobj;
8456 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8457 PyObject * obj0 = 0 ;
8458 char *kwnames[] = {
8459 (char *) "self", NULL
8460 };
8461
8462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8464 if (SWIG_arg_fail(1)) SWIG_fail;
8465 {
8466 PyThreadState* __tstate = wxPyBeginAllowThreads();
8467 (arg1)->Stop();
8468
8469 wxPyEndAllowThreads(__tstate);
8470 if (PyErr_Occurred()) SWIG_fail;
8471 }
8472 Py_INCREF(Py_None); resultobj = Py_None;
8473 return resultobj;
8474 fail:
8475 return NULL;
8476 }
8477
8478
8479 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8480 PyObject *resultobj;
8481 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8482 bool result;
8483 PyObject * obj0 = 0 ;
8484 char *kwnames[] = {
8485 (char *) "self", NULL
8486 };
8487
8488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8490 if (SWIG_arg_fail(1)) SWIG_fail;
8491 {
8492 PyThreadState* __tstate = wxPyBeginAllowThreads();
8493 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8494
8495 wxPyEndAllowThreads(__tstate);
8496 if (PyErr_Occurred()) SWIG_fail;
8497 }
8498 {
8499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8500 }
8501 return resultobj;
8502 fail:
8503 return NULL;
8504 }
8505
8506
8507 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8508 PyObject *resultobj;
8509 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8510 int result;
8511 PyObject * obj0 = 0 ;
8512 char *kwnames[] = {
8513 (char *) "self", NULL
8514 };
8515
8516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8518 if (SWIG_arg_fail(1)) SWIG_fail;
8519 {
8520 PyThreadState* __tstate = wxPyBeginAllowThreads();
8521 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8522
8523 wxPyEndAllowThreads(__tstate);
8524 if (PyErr_Occurred()) SWIG_fail;
8525 }
8526 {
8527 resultobj = SWIG_From_int((int)(result));
8528 }
8529 return resultobj;
8530 fail:
8531 return NULL;
8532 }
8533
8534
8535 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8536 PyObject *resultobj;
8537 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8538 bool result;
8539 PyObject * obj0 = 0 ;
8540 char *kwnames[] = {
8541 (char *) "self", NULL
8542 };
8543
8544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8546 if (SWIG_arg_fail(1)) SWIG_fail;
8547 {
8548 PyThreadState* __tstate = wxPyBeginAllowThreads();
8549 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8550
8551 wxPyEndAllowThreads(__tstate);
8552 if (PyErr_Occurred()) SWIG_fail;
8553 }
8554 {
8555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8556 }
8557 return resultobj;
8558 fail:
8559 return NULL;
8560 }
8561
8562
8563 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8564 PyObject *resultobj;
8565 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8566 int result;
8567 PyObject * obj0 = 0 ;
8568 char *kwnames[] = {
8569 (char *) "self", NULL
8570 };
8571
8572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8574 if (SWIG_arg_fail(1)) SWIG_fail;
8575 {
8576 PyThreadState* __tstate = wxPyBeginAllowThreads();
8577 result = (int)((wxPyTimer const *)arg1)->GetId();
8578
8579 wxPyEndAllowThreads(__tstate);
8580 if (PyErr_Occurred()) SWIG_fail;
8581 }
8582 {
8583 resultobj = SWIG_From_int((int)(result));
8584 }
8585 return resultobj;
8586 fail:
8587 return NULL;
8588 }
8589
8590
8591 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8592 PyObject *obj;
8593 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8594 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8595 Py_INCREF(obj);
8596 return Py_BuildValue((char *)"");
8597 }
8598 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8599 PyObject *resultobj;
8600 int arg1 = (int) 0 ;
8601 int arg2 = (int) 0 ;
8602 wxTimerEvent *result;
8603 PyObject * obj0 = 0 ;
8604 PyObject * obj1 = 0 ;
8605 char *kwnames[] = {
8606 (char *) "timerid",(char *) "interval", NULL
8607 };
8608
8609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8610 if (obj0) {
8611 {
8612 arg1 = (int)(SWIG_As_int(obj0));
8613 if (SWIG_arg_fail(1)) SWIG_fail;
8614 }
8615 }
8616 if (obj1) {
8617 {
8618 arg2 = (int)(SWIG_As_int(obj1));
8619 if (SWIG_arg_fail(2)) SWIG_fail;
8620 }
8621 }
8622 {
8623 PyThreadState* __tstate = wxPyBeginAllowThreads();
8624 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8625
8626 wxPyEndAllowThreads(__tstate);
8627 if (PyErr_Occurred()) SWIG_fail;
8628 }
8629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8630 return resultobj;
8631 fail:
8632 return NULL;
8633 }
8634
8635
8636 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8637 PyObject *resultobj;
8638 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8639 int result;
8640 PyObject * obj0 = 0 ;
8641 char *kwnames[] = {
8642 (char *) "self", NULL
8643 };
8644
8645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8647 if (SWIG_arg_fail(1)) SWIG_fail;
8648 {
8649 PyThreadState* __tstate = wxPyBeginAllowThreads();
8650 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8651
8652 wxPyEndAllowThreads(__tstate);
8653 if (PyErr_Occurred()) SWIG_fail;
8654 }
8655 {
8656 resultobj = SWIG_From_int((int)(result));
8657 }
8658 return resultobj;
8659 fail:
8660 return NULL;
8661 }
8662
8663
8664 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8665 PyObject *obj;
8666 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8667 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8668 Py_INCREF(obj);
8669 return Py_BuildValue((char *)"");
8670 }
8671 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8672 PyObject *resultobj;
8673 wxTimer *arg1 = 0 ;
8674 wxTimerRunner *result;
8675 PyObject * obj0 = 0 ;
8676
8677 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8678 {
8679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8680 if (SWIG_arg_fail(1)) SWIG_fail;
8681 if (arg1 == NULL) {
8682 SWIG_null_ref("wxTimer");
8683 }
8684 if (SWIG_arg_fail(1)) SWIG_fail;
8685 }
8686 {
8687 if (!wxPyCheckForApp()) SWIG_fail;
8688 PyThreadState* __tstate = wxPyBeginAllowThreads();
8689 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8690
8691 wxPyEndAllowThreads(__tstate);
8692 if (PyErr_Occurred()) SWIG_fail;
8693 }
8694 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8695 return resultobj;
8696 fail:
8697 return NULL;
8698 }
8699
8700
8701 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8702 PyObject *resultobj;
8703 wxTimer *arg1 = 0 ;
8704 int arg2 ;
8705 bool arg3 = (bool) false ;
8706 wxTimerRunner *result;
8707 PyObject * obj0 = 0 ;
8708 PyObject * obj1 = 0 ;
8709 PyObject * obj2 = 0 ;
8710
8711 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8712 {
8713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8714 if (SWIG_arg_fail(1)) SWIG_fail;
8715 if (arg1 == NULL) {
8716 SWIG_null_ref("wxTimer");
8717 }
8718 if (SWIG_arg_fail(1)) SWIG_fail;
8719 }
8720 {
8721 arg2 = (int)(SWIG_As_int(obj1));
8722 if (SWIG_arg_fail(2)) SWIG_fail;
8723 }
8724 if (obj2) {
8725 {
8726 arg3 = (bool)(SWIG_As_bool(obj2));
8727 if (SWIG_arg_fail(3)) SWIG_fail;
8728 }
8729 }
8730 {
8731 if (!wxPyCheckForApp()) SWIG_fail;
8732 PyThreadState* __tstate = wxPyBeginAllowThreads();
8733 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8734
8735 wxPyEndAllowThreads(__tstate);
8736 if (PyErr_Occurred()) SWIG_fail;
8737 }
8738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8739 return resultobj;
8740 fail:
8741 return NULL;
8742 }
8743
8744
8745 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8746 int argc;
8747 PyObject *argv[4];
8748 int ii;
8749
8750 argc = PyObject_Length(args);
8751 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8752 argv[ii] = PyTuple_GetItem(args,ii);
8753 }
8754 if (argc == 1) {
8755 int _v;
8756 {
8757 void *ptr = 0;
8758 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8759 _v = 0;
8760 PyErr_Clear();
8761 } else {
8762 _v = (ptr != 0);
8763 }
8764 }
8765 if (_v) {
8766 return _wrap_new_TimerRunner__SWIG_0(self,args);
8767 }
8768 }
8769 if ((argc >= 2) && (argc <= 3)) {
8770 int _v;
8771 {
8772 void *ptr = 0;
8773 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8774 _v = 0;
8775 PyErr_Clear();
8776 } else {
8777 _v = (ptr != 0);
8778 }
8779 }
8780 if (_v) {
8781 _v = SWIG_Check_int(argv[1]);
8782 if (_v) {
8783 if (argc <= 2) {
8784 return _wrap_new_TimerRunner__SWIG_1(self,args);
8785 }
8786 _v = SWIG_Check_bool(argv[2]);
8787 if (_v) {
8788 return _wrap_new_TimerRunner__SWIG_1(self,args);
8789 }
8790 }
8791 }
8792 }
8793
8794 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8795 return NULL;
8796 }
8797
8798
8799 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8800 PyObject *resultobj;
8801 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8802 PyObject * obj0 = 0 ;
8803 char *kwnames[] = {
8804 (char *) "self", NULL
8805 };
8806
8807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8809 if (SWIG_arg_fail(1)) SWIG_fail;
8810 {
8811 PyThreadState* __tstate = wxPyBeginAllowThreads();
8812 delete arg1;
8813
8814 wxPyEndAllowThreads(__tstate);
8815 if (PyErr_Occurred()) SWIG_fail;
8816 }
8817 Py_INCREF(Py_None); resultobj = Py_None;
8818 return resultobj;
8819 fail:
8820 return NULL;
8821 }
8822
8823
8824 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8825 PyObject *resultobj;
8826 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8827 int arg2 ;
8828 bool arg3 = (bool) false ;
8829 PyObject * obj0 = 0 ;
8830 PyObject * obj1 = 0 ;
8831 PyObject * obj2 = 0 ;
8832 char *kwnames[] = {
8833 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8834 };
8835
8836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8838 if (SWIG_arg_fail(1)) SWIG_fail;
8839 {
8840 arg2 = (int)(SWIG_As_int(obj1));
8841 if (SWIG_arg_fail(2)) SWIG_fail;
8842 }
8843 if (obj2) {
8844 {
8845 arg3 = (bool)(SWIG_As_bool(obj2));
8846 if (SWIG_arg_fail(3)) SWIG_fail;
8847 }
8848 }
8849 {
8850 PyThreadState* __tstate = wxPyBeginAllowThreads();
8851 (arg1)->Start(arg2,arg3);
8852
8853 wxPyEndAllowThreads(__tstate);
8854 if (PyErr_Occurred()) SWIG_fail;
8855 }
8856 Py_INCREF(Py_None); resultobj = Py_None;
8857 return resultobj;
8858 fail:
8859 return NULL;
8860 }
8861
8862
8863 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8864 PyObject *obj;
8865 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8866 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8867 Py_INCREF(obj);
8868 return Py_BuildValue((char *)"");
8869 }
8870 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8871 PyObject *resultobj;
8872 wxLog *result;
8873 char *kwnames[] = {
8874 NULL
8875 };
8876
8877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8878 {
8879 PyThreadState* __tstate = wxPyBeginAllowThreads();
8880 result = (wxLog *)new wxLog();
8881
8882 wxPyEndAllowThreads(__tstate);
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8886 return resultobj;
8887 fail:
8888 return NULL;
8889 }
8890
8891
8892 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8893 PyObject *resultobj;
8894 bool result;
8895 char *kwnames[] = {
8896 NULL
8897 };
8898
8899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8900 {
8901 PyThreadState* __tstate = wxPyBeginAllowThreads();
8902 result = (bool)wxLog::IsEnabled();
8903
8904 wxPyEndAllowThreads(__tstate);
8905 if (PyErr_Occurred()) SWIG_fail;
8906 }
8907 {
8908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8909 }
8910 return resultobj;
8911 fail:
8912 return NULL;
8913 }
8914
8915
8916 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8917 PyObject *resultobj;
8918 bool arg1 = (bool) true ;
8919 bool result;
8920 PyObject * obj0 = 0 ;
8921 char *kwnames[] = {
8922 (char *) "doIt", NULL
8923 };
8924
8925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8926 if (obj0) {
8927 {
8928 arg1 = (bool)(SWIG_As_bool(obj0));
8929 if (SWIG_arg_fail(1)) SWIG_fail;
8930 }
8931 }
8932 {
8933 PyThreadState* __tstate = wxPyBeginAllowThreads();
8934 result = (bool)wxLog::EnableLogging(arg1);
8935
8936 wxPyEndAllowThreads(__tstate);
8937 if (PyErr_Occurred()) SWIG_fail;
8938 }
8939 {
8940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8941 }
8942 return resultobj;
8943 fail:
8944 return NULL;
8945 }
8946
8947
8948 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8949 PyObject *resultobj;
8950 wxLogLevel arg1 ;
8951 wxChar *arg2 = (wxChar *) 0 ;
8952 time_t arg3 ;
8953 PyObject * obj0 = 0 ;
8954 PyObject * obj1 = 0 ;
8955 PyObject * obj2 = 0 ;
8956 char *kwnames[] = {
8957 (char *) "level",(char *) "szString",(char *) "t", NULL
8958 };
8959
8960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8961 {
8962 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8963 if (SWIG_arg_fail(1)) SWIG_fail;
8964 }
8965 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8966 if (SWIG_arg_fail(2)) SWIG_fail;
8967 {
8968 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8969 if (SWIG_arg_fail(3)) SWIG_fail;
8970 }
8971 {
8972 PyThreadState* __tstate = wxPyBeginAllowThreads();
8973 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8974
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 Py_INCREF(Py_None); resultobj = Py_None;
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8986 PyObject *resultobj;
8987 wxLog *arg1 = (wxLog *) 0 ;
8988 PyObject * obj0 = 0 ;
8989 char *kwnames[] = {
8990 (char *) "self", NULL
8991 };
8992
8993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8995 if (SWIG_arg_fail(1)) SWIG_fail;
8996 {
8997 PyThreadState* __tstate = wxPyBeginAllowThreads();
8998 (arg1)->Flush();
8999
9000 wxPyEndAllowThreads(__tstate);
9001 if (PyErr_Occurred()) SWIG_fail;
9002 }
9003 Py_INCREF(Py_None); resultobj = Py_None;
9004 return resultobj;
9005 fail:
9006 return NULL;
9007 }
9008
9009
9010 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
9011 PyObject *resultobj;
9012 char *kwnames[] = {
9013 NULL
9014 };
9015
9016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
9017 {
9018 PyThreadState* __tstate = wxPyBeginAllowThreads();
9019 wxLog::FlushActive();
9020
9021 wxPyEndAllowThreads(__tstate);
9022 if (PyErr_Occurred()) SWIG_fail;
9023 }
9024 Py_INCREF(Py_None); resultobj = Py_None;
9025 return resultobj;
9026 fail:
9027 return NULL;
9028 }
9029
9030
9031 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9032 PyObject *resultobj;
9033 wxLog *result;
9034 char *kwnames[] = {
9035 NULL
9036 };
9037
9038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9039 {
9040 PyThreadState* __tstate = wxPyBeginAllowThreads();
9041 result = (wxLog *)wxLog::GetActiveTarget();
9042
9043 wxPyEndAllowThreads(__tstate);
9044 if (PyErr_Occurred()) SWIG_fail;
9045 }
9046 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9047 return resultobj;
9048 fail:
9049 return NULL;
9050 }
9051
9052
9053 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9054 PyObject *resultobj;
9055 wxLog *arg1 = (wxLog *) 0 ;
9056 wxLog *result;
9057 PyObject * obj0 = 0 ;
9058 char *kwnames[] = {
9059 (char *) "pLogger", NULL
9060 };
9061
9062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9064 if (SWIG_arg_fail(1)) SWIG_fail;
9065 {
9066 PyThreadState* __tstate = wxPyBeginAllowThreads();
9067 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9068
9069 wxPyEndAllowThreads(__tstate);
9070 if (PyErr_Occurred()) SWIG_fail;
9071 }
9072 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9073 return resultobj;
9074 fail:
9075 return NULL;
9076 }
9077
9078
9079 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9080 PyObject *resultobj;
9081 char *kwnames[] = {
9082 NULL
9083 };
9084
9085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9086 {
9087 PyThreadState* __tstate = wxPyBeginAllowThreads();
9088 wxLog::Suspend();
9089
9090 wxPyEndAllowThreads(__tstate);
9091 if (PyErr_Occurred()) SWIG_fail;
9092 }
9093 Py_INCREF(Py_None); resultobj = Py_None;
9094 return resultobj;
9095 fail:
9096 return NULL;
9097 }
9098
9099
9100 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9101 PyObject *resultobj;
9102 char *kwnames[] = {
9103 NULL
9104 };
9105
9106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9107 {
9108 PyThreadState* __tstate = wxPyBeginAllowThreads();
9109 wxLog::Resume();
9110
9111 wxPyEndAllowThreads(__tstate);
9112 if (PyErr_Occurred()) SWIG_fail;
9113 }
9114 Py_INCREF(Py_None); resultobj = Py_None;
9115 return resultobj;
9116 fail:
9117 return NULL;
9118 }
9119
9120
9121 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9122 PyObject *resultobj;
9123 bool arg1 = (bool) true ;
9124 PyObject * obj0 = 0 ;
9125 char *kwnames[] = {
9126 (char *) "bVerbose", NULL
9127 };
9128
9129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9130 if (obj0) {
9131 {
9132 arg1 = (bool)(SWIG_As_bool(obj0));
9133 if (SWIG_arg_fail(1)) SWIG_fail;
9134 }
9135 }
9136 {
9137 PyThreadState* __tstate = wxPyBeginAllowThreads();
9138 wxLog::SetVerbose(arg1);
9139
9140 wxPyEndAllowThreads(__tstate);
9141 if (PyErr_Occurred()) SWIG_fail;
9142 }
9143 Py_INCREF(Py_None); resultobj = Py_None;
9144 return resultobj;
9145 fail:
9146 return NULL;
9147 }
9148
9149
9150 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9151 PyObject *resultobj;
9152 wxLogLevel arg1 ;
9153 PyObject * obj0 = 0 ;
9154 char *kwnames[] = {
9155 (char *) "logLevel", NULL
9156 };
9157
9158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9159 {
9160 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9161 if (SWIG_arg_fail(1)) SWIG_fail;
9162 }
9163 {
9164 PyThreadState* __tstate = wxPyBeginAllowThreads();
9165 wxLog::SetLogLevel(arg1);
9166
9167 wxPyEndAllowThreads(__tstate);
9168 if (PyErr_Occurred()) SWIG_fail;
9169 }
9170 Py_INCREF(Py_None); resultobj = Py_None;
9171 return resultobj;
9172 fail:
9173 return NULL;
9174 }
9175
9176
9177 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9178 PyObject *resultobj;
9179 char *kwnames[] = {
9180 NULL
9181 };
9182
9183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9184 {
9185 PyThreadState* __tstate = wxPyBeginAllowThreads();
9186 wxLog::DontCreateOnDemand();
9187
9188 wxPyEndAllowThreads(__tstate);
9189 if (PyErr_Occurred()) SWIG_fail;
9190 }
9191 Py_INCREF(Py_None); resultobj = Py_None;
9192 return resultobj;
9193 fail:
9194 return NULL;
9195 }
9196
9197
9198 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9199 PyObject *resultobj;
9200 wxTraceMask arg1 ;
9201 PyObject * obj0 = 0 ;
9202 char *kwnames[] = {
9203 (char *) "ulMask", NULL
9204 };
9205
9206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9207 {
9208 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9209 if (SWIG_arg_fail(1)) SWIG_fail;
9210 }
9211 {
9212 PyThreadState* __tstate = wxPyBeginAllowThreads();
9213 wxLog::SetTraceMask(arg1);
9214
9215 wxPyEndAllowThreads(__tstate);
9216 if (PyErr_Occurred()) SWIG_fail;
9217 }
9218 Py_INCREF(Py_None); resultobj = Py_None;
9219 return resultobj;
9220 fail:
9221 return NULL;
9222 }
9223
9224
9225 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9226 PyObject *resultobj;
9227 wxString *arg1 = 0 ;
9228 bool temp1 = false ;
9229 PyObject * obj0 = 0 ;
9230 char *kwnames[] = {
9231 (char *) "str", NULL
9232 };
9233
9234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9235 {
9236 arg1 = wxString_in_helper(obj0);
9237 if (arg1 == NULL) SWIG_fail;
9238 temp1 = true;
9239 }
9240 {
9241 PyThreadState* __tstate = wxPyBeginAllowThreads();
9242 wxLog::AddTraceMask((wxString const &)*arg1);
9243
9244 wxPyEndAllowThreads(__tstate);
9245 if (PyErr_Occurred()) SWIG_fail;
9246 }
9247 Py_INCREF(Py_None); resultobj = Py_None;
9248 {
9249 if (temp1)
9250 delete arg1;
9251 }
9252 return resultobj;
9253 fail:
9254 {
9255 if (temp1)
9256 delete arg1;
9257 }
9258 return NULL;
9259 }
9260
9261
9262 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9263 PyObject *resultobj;
9264 wxString *arg1 = 0 ;
9265 bool temp1 = false ;
9266 PyObject * obj0 = 0 ;
9267 char *kwnames[] = {
9268 (char *) "str", NULL
9269 };
9270
9271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9272 {
9273 arg1 = wxString_in_helper(obj0);
9274 if (arg1 == NULL) SWIG_fail;
9275 temp1 = true;
9276 }
9277 {
9278 PyThreadState* __tstate = wxPyBeginAllowThreads();
9279 wxLog::RemoveTraceMask((wxString const &)*arg1);
9280
9281 wxPyEndAllowThreads(__tstate);
9282 if (PyErr_Occurred()) SWIG_fail;
9283 }
9284 Py_INCREF(Py_None); resultobj = Py_None;
9285 {
9286 if (temp1)
9287 delete arg1;
9288 }
9289 return resultobj;
9290 fail:
9291 {
9292 if (temp1)
9293 delete arg1;
9294 }
9295 return NULL;
9296 }
9297
9298
9299 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9300 PyObject *resultobj;
9301 char *kwnames[] = {
9302 NULL
9303 };
9304
9305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9306 {
9307 PyThreadState* __tstate = wxPyBeginAllowThreads();
9308 wxLog::ClearTraceMasks();
9309
9310 wxPyEndAllowThreads(__tstate);
9311 if (PyErr_Occurred()) SWIG_fail;
9312 }
9313 Py_INCREF(Py_None); resultobj = Py_None;
9314 return resultobj;
9315 fail:
9316 return NULL;
9317 }
9318
9319
9320 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9321 PyObject *resultobj;
9322 wxArrayString *result;
9323 char *kwnames[] = {
9324 NULL
9325 };
9326
9327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9328 {
9329 PyThreadState* __tstate = wxPyBeginAllowThreads();
9330 {
9331 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9332 result = (wxArrayString *) &_result_ref;
9333 }
9334
9335 wxPyEndAllowThreads(__tstate);
9336 if (PyErr_Occurred()) SWIG_fail;
9337 }
9338 {
9339 resultobj = wxArrayString2PyList_helper(*result);
9340 }
9341 return resultobj;
9342 fail:
9343 return NULL;
9344 }
9345
9346
9347 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9348 PyObject *resultobj;
9349 wxChar *arg1 = (wxChar *) 0 ;
9350 PyObject * obj0 = 0 ;
9351 char *kwnames[] = {
9352 (char *) "ts", NULL
9353 };
9354
9355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9357 if (SWIG_arg_fail(1)) SWIG_fail;
9358 {
9359 PyThreadState* __tstate = wxPyBeginAllowThreads();
9360 wxLog::SetTimestamp((wxChar const *)arg1);
9361
9362 wxPyEndAllowThreads(__tstate);
9363 if (PyErr_Occurred()) SWIG_fail;
9364 }
9365 Py_INCREF(Py_None); resultobj = Py_None;
9366 return resultobj;
9367 fail:
9368 return NULL;
9369 }
9370
9371
9372 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9373 PyObject *resultobj;
9374 bool result;
9375 char *kwnames[] = {
9376 NULL
9377 };
9378
9379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9380 {
9381 PyThreadState* __tstate = wxPyBeginAllowThreads();
9382 result = (bool)wxLog::GetVerbose();
9383
9384 wxPyEndAllowThreads(__tstate);
9385 if (PyErr_Occurred()) SWIG_fail;
9386 }
9387 {
9388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9389 }
9390 return resultobj;
9391 fail:
9392 return NULL;
9393 }
9394
9395
9396 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9397 PyObject *resultobj;
9398 wxTraceMask result;
9399 char *kwnames[] = {
9400 NULL
9401 };
9402
9403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9404 {
9405 PyThreadState* __tstate = wxPyBeginAllowThreads();
9406 result = (wxTraceMask)wxLog::GetTraceMask();
9407
9408 wxPyEndAllowThreads(__tstate);
9409 if (PyErr_Occurred()) SWIG_fail;
9410 }
9411 {
9412 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9413 }
9414 return resultobj;
9415 fail:
9416 return NULL;
9417 }
9418
9419
9420 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9421 PyObject *resultobj;
9422 wxChar *arg1 = (wxChar *) 0 ;
9423 bool result;
9424 PyObject * obj0 = 0 ;
9425 char *kwnames[] = {
9426 (char *) "mask", NULL
9427 };
9428
9429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9431 if (SWIG_arg_fail(1)) SWIG_fail;
9432 {
9433 PyThreadState* __tstate = wxPyBeginAllowThreads();
9434 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9435
9436 wxPyEndAllowThreads(__tstate);
9437 if (PyErr_Occurred()) SWIG_fail;
9438 }
9439 {
9440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9441 }
9442 return resultobj;
9443 fail:
9444 return NULL;
9445 }
9446
9447
9448 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9449 PyObject *resultobj;
9450 wxLogLevel result;
9451 char *kwnames[] = {
9452 NULL
9453 };
9454
9455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9456 {
9457 PyThreadState* __tstate = wxPyBeginAllowThreads();
9458 result = (wxLogLevel)wxLog::GetLogLevel();
9459
9460 wxPyEndAllowThreads(__tstate);
9461 if (PyErr_Occurred()) SWIG_fail;
9462 }
9463 {
9464 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9465 }
9466 return resultobj;
9467 fail:
9468 return NULL;
9469 }
9470
9471
9472 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9473 PyObject *resultobj;
9474 wxChar *result;
9475 char *kwnames[] = {
9476 NULL
9477 };
9478
9479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9480 {
9481 PyThreadState* __tstate = wxPyBeginAllowThreads();
9482 result = (wxChar *)wxLog::GetTimestamp();
9483
9484 wxPyEndAllowThreads(__tstate);
9485 if (PyErr_Occurred()) SWIG_fail;
9486 }
9487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9488 return resultobj;
9489 fail:
9490 return NULL;
9491 }
9492
9493
9494 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9495 PyObject *resultobj;
9496 wxString result;
9497 char *kwnames[] = {
9498 NULL
9499 };
9500
9501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9502 {
9503 PyThreadState* __tstate = wxPyBeginAllowThreads();
9504 result = Log_TimeStamp();
9505
9506 wxPyEndAllowThreads(__tstate);
9507 if (PyErr_Occurred()) SWIG_fail;
9508 }
9509 {
9510 #if wxUSE_UNICODE
9511 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9512 #else
9513 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9514 #endif
9515 }
9516 return resultobj;
9517 fail:
9518 return NULL;
9519 }
9520
9521
9522 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9523 PyObject *resultobj;
9524 wxLog *arg1 = (wxLog *) 0 ;
9525 PyObject * obj0 = 0 ;
9526 char *kwnames[] = {
9527 (char *) "self", NULL
9528 };
9529
9530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9532 if (SWIG_arg_fail(1)) SWIG_fail;
9533 {
9534 PyThreadState* __tstate = wxPyBeginAllowThreads();
9535 wxLog_Destroy(arg1);
9536
9537 wxPyEndAllowThreads(__tstate);
9538 if (PyErr_Occurred()) SWIG_fail;
9539 }
9540 Py_INCREF(Py_None); resultobj = Py_None;
9541 return resultobj;
9542 fail:
9543 return NULL;
9544 }
9545
9546
9547 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9548 PyObject *obj;
9549 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9550 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9551 Py_INCREF(obj);
9552 return Py_BuildValue((char *)"");
9553 }
9554 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9555 PyObject *resultobj;
9556 wxLogStderr *result;
9557 char *kwnames[] = {
9558 NULL
9559 };
9560
9561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9562 {
9563 PyThreadState* __tstate = wxPyBeginAllowThreads();
9564 result = (wxLogStderr *)new wxLogStderr();
9565
9566 wxPyEndAllowThreads(__tstate);
9567 if (PyErr_Occurred()) SWIG_fail;
9568 }
9569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9570 return resultobj;
9571 fail:
9572 return NULL;
9573 }
9574
9575
9576 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9577 PyObject *obj;
9578 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9579 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9580 Py_INCREF(obj);
9581 return Py_BuildValue((char *)"");
9582 }
9583 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9584 PyObject *resultobj;
9585 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9586 wxLogTextCtrl *result;
9587 PyObject * obj0 = 0 ;
9588 char *kwnames[] = {
9589 (char *) "pTextCtrl", NULL
9590 };
9591
9592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9594 if (SWIG_arg_fail(1)) SWIG_fail;
9595 {
9596 PyThreadState* __tstate = wxPyBeginAllowThreads();
9597 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9598
9599 wxPyEndAllowThreads(__tstate);
9600 if (PyErr_Occurred()) SWIG_fail;
9601 }
9602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9603 return resultobj;
9604 fail:
9605 return NULL;
9606 }
9607
9608
9609 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9610 PyObject *obj;
9611 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9612 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9613 Py_INCREF(obj);
9614 return Py_BuildValue((char *)"");
9615 }
9616 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9617 PyObject *resultobj;
9618 wxLogGui *result;
9619 char *kwnames[] = {
9620 NULL
9621 };
9622
9623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9624 {
9625 PyThreadState* __tstate = wxPyBeginAllowThreads();
9626 result = (wxLogGui *)new wxLogGui();
9627
9628 wxPyEndAllowThreads(__tstate);
9629 if (PyErr_Occurred()) SWIG_fail;
9630 }
9631 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9632 return resultobj;
9633 fail:
9634 return NULL;
9635 }
9636
9637
9638 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9639 PyObject *obj;
9640 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9641 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9642 Py_INCREF(obj);
9643 return Py_BuildValue((char *)"");
9644 }
9645 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9646 PyObject *resultobj;
9647 wxFrame *arg1 = (wxFrame *) 0 ;
9648 wxString *arg2 = 0 ;
9649 bool arg3 = (bool) true ;
9650 bool arg4 = (bool) true ;
9651 wxLogWindow *result;
9652 bool temp2 = false ;
9653 PyObject * obj0 = 0 ;
9654 PyObject * obj1 = 0 ;
9655 PyObject * obj2 = 0 ;
9656 PyObject * obj3 = 0 ;
9657 char *kwnames[] = {
9658 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9659 };
9660
9661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9663 if (SWIG_arg_fail(1)) SWIG_fail;
9664 {
9665 arg2 = wxString_in_helper(obj1);
9666 if (arg2 == NULL) SWIG_fail;
9667 temp2 = true;
9668 }
9669 if (obj2) {
9670 {
9671 arg3 = (bool)(SWIG_As_bool(obj2));
9672 if (SWIG_arg_fail(3)) SWIG_fail;
9673 }
9674 }
9675 if (obj3) {
9676 {
9677 arg4 = (bool)(SWIG_As_bool(obj3));
9678 if (SWIG_arg_fail(4)) SWIG_fail;
9679 }
9680 }
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9684
9685 wxPyEndAllowThreads(__tstate);
9686 if (PyErr_Occurred()) SWIG_fail;
9687 }
9688 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9689 {
9690 if (temp2)
9691 delete arg2;
9692 }
9693 return resultobj;
9694 fail:
9695 {
9696 if (temp2)
9697 delete arg2;
9698 }
9699 return NULL;
9700 }
9701
9702
9703 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9704 PyObject *resultobj;
9705 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9706 bool arg2 = (bool) true ;
9707 PyObject * obj0 = 0 ;
9708 PyObject * obj1 = 0 ;
9709 char *kwnames[] = {
9710 (char *) "self",(char *) "bShow", NULL
9711 };
9712
9713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9715 if (SWIG_arg_fail(1)) SWIG_fail;
9716 if (obj1) {
9717 {
9718 arg2 = (bool)(SWIG_As_bool(obj1));
9719 if (SWIG_arg_fail(2)) SWIG_fail;
9720 }
9721 }
9722 {
9723 PyThreadState* __tstate = wxPyBeginAllowThreads();
9724 (arg1)->Show(arg2);
9725
9726 wxPyEndAllowThreads(__tstate);
9727 if (PyErr_Occurred()) SWIG_fail;
9728 }
9729 Py_INCREF(Py_None); resultobj = Py_None;
9730 return resultobj;
9731 fail:
9732 return NULL;
9733 }
9734
9735
9736 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9737 PyObject *resultobj;
9738 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9739 wxFrame *result;
9740 PyObject * obj0 = 0 ;
9741 char *kwnames[] = {
9742 (char *) "self", NULL
9743 };
9744
9745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9747 if (SWIG_arg_fail(1)) SWIG_fail;
9748 {
9749 PyThreadState* __tstate = wxPyBeginAllowThreads();
9750 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9751
9752 wxPyEndAllowThreads(__tstate);
9753 if (PyErr_Occurred()) SWIG_fail;
9754 }
9755 {
9756 resultobj = wxPyMake_wxObject(result, 0);
9757 }
9758 return resultobj;
9759 fail:
9760 return NULL;
9761 }
9762
9763
9764 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9765 PyObject *resultobj;
9766 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9767 wxLog *result;
9768 PyObject * obj0 = 0 ;
9769 char *kwnames[] = {
9770 (char *) "self", NULL
9771 };
9772
9773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9775 if (SWIG_arg_fail(1)) SWIG_fail;
9776 {
9777 PyThreadState* __tstate = wxPyBeginAllowThreads();
9778 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9779
9780 wxPyEndAllowThreads(__tstate);
9781 if (PyErr_Occurred()) SWIG_fail;
9782 }
9783 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9784 return resultobj;
9785 fail:
9786 return NULL;
9787 }
9788
9789
9790 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9791 PyObject *resultobj;
9792 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9793 bool result;
9794 PyObject * obj0 = 0 ;
9795 char *kwnames[] = {
9796 (char *) "self", NULL
9797 };
9798
9799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9801 if (SWIG_arg_fail(1)) SWIG_fail;
9802 {
9803 PyThreadState* __tstate = wxPyBeginAllowThreads();
9804 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9805
9806 wxPyEndAllowThreads(__tstate);
9807 if (PyErr_Occurred()) SWIG_fail;
9808 }
9809 {
9810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9811 }
9812 return resultobj;
9813 fail:
9814 return NULL;
9815 }
9816
9817
9818 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9819 PyObject *resultobj;
9820 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9821 bool arg2 ;
9822 PyObject * obj0 = 0 ;
9823 PyObject * obj1 = 0 ;
9824 char *kwnames[] = {
9825 (char *) "self",(char *) "bDoPass", NULL
9826 };
9827
9828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9830 if (SWIG_arg_fail(1)) SWIG_fail;
9831 {
9832 arg2 = (bool)(SWIG_As_bool(obj1));
9833 if (SWIG_arg_fail(2)) SWIG_fail;
9834 }
9835 {
9836 PyThreadState* __tstate = wxPyBeginAllowThreads();
9837 (arg1)->PassMessages(arg2);
9838
9839 wxPyEndAllowThreads(__tstate);
9840 if (PyErr_Occurred()) SWIG_fail;
9841 }
9842 Py_INCREF(Py_None); resultobj = Py_None;
9843 return resultobj;
9844 fail:
9845 return NULL;
9846 }
9847
9848
9849 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9850 PyObject *obj;
9851 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9852 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9853 Py_INCREF(obj);
9854 return Py_BuildValue((char *)"");
9855 }
9856 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9857 PyObject *resultobj;
9858 wxLog *arg1 = (wxLog *) 0 ;
9859 wxLogChain *result;
9860 PyObject * obj0 = 0 ;
9861 char *kwnames[] = {
9862 (char *) "logger", NULL
9863 };
9864
9865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9867 if (SWIG_arg_fail(1)) SWIG_fail;
9868 {
9869 PyThreadState* __tstate = wxPyBeginAllowThreads();
9870 result = (wxLogChain *)new wxLogChain(arg1);
9871
9872 wxPyEndAllowThreads(__tstate);
9873 if (PyErr_Occurred()) SWIG_fail;
9874 }
9875 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9876 return resultobj;
9877 fail:
9878 return NULL;
9879 }
9880
9881
9882 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9883 PyObject *resultobj;
9884 wxLogChain *arg1 = (wxLogChain *) 0 ;
9885 wxLog *arg2 = (wxLog *) 0 ;
9886 PyObject * obj0 = 0 ;
9887 PyObject * obj1 = 0 ;
9888 char *kwnames[] = {
9889 (char *) "self",(char *) "logger", NULL
9890 };
9891
9892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9894 if (SWIG_arg_fail(1)) SWIG_fail;
9895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9896 if (SWIG_arg_fail(2)) SWIG_fail;
9897 {
9898 PyThreadState* __tstate = wxPyBeginAllowThreads();
9899 (arg1)->SetLog(arg2);
9900
9901 wxPyEndAllowThreads(__tstate);
9902 if (PyErr_Occurred()) SWIG_fail;
9903 }
9904 Py_INCREF(Py_None); resultobj = Py_None;
9905 return resultobj;
9906 fail:
9907 return NULL;
9908 }
9909
9910
9911 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9912 PyObject *resultobj;
9913 wxLogChain *arg1 = (wxLogChain *) 0 ;
9914 bool arg2 ;
9915 PyObject * obj0 = 0 ;
9916 PyObject * obj1 = 0 ;
9917 char *kwnames[] = {
9918 (char *) "self",(char *) "bDoPass", NULL
9919 };
9920
9921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9923 if (SWIG_arg_fail(1)) SWIG_fail;
9924 {
9925 arg2 = (bool)(SWIG_As_bool(obj1));
9926 if (SWIG_arg_fail(2)) SWIG_fail;
9927 }
9928 {
9929 PyThreadState* __tstate = wxPyBeginAllowThreads();
9930 (arg1)->PassMessages(arg2);
9931
9932 wxPyEndAllowThreads(__tstate);
9933 if (PyErr_Occurred()) SWIG_fail;
9934 }
9935 Py_INCREF(Py_None); resultobj = Py_None;
9936 return resultobj;
9937 fail:
9938 return NULL;
9939 }
9940
9941
9942 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9943 PyObject *resultobj;
9944 wxLogChain *arg1 = (wxLogChain *) 0 ;
9945 bool result;
9946 PyObject * obj0 = 0 ;
9947 char *kwnames[] = {
9948 (char *) "self", NULL
9949 };
9950
9951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9953 if (SWIG_arg_fail(1)) SWIG_fail;
9954 {
9955 PyThreadState* __tstate = wxPyBeginAllowThreads();
9956 result = (bool)(arg1)->IsPassingMessages();
9957
9958 wxPyEndAllowThreads(__tstate);
9959 if (PyErr_Occurred()) SWIG_fail;
9960 }
9961 {
9962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9963 }
9964 return resultobj;
9965 fail:
9966 return NULL;
9967 }
9968
9969
9970 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9971 PyObject *resultobj;
9972 wxLogChain *arg1 = (wxLogChain *) 0 ;
9973 wxLog *result;
9974 PyObject * obj0 = 0 ;
9975 char *kwnames[] = {
9976 (char *) "self", NULL
9977 };
9978
9979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9981 if (SWIG_arg_fail(1)) SWIG_fail;
9982 {
9983 PyThreadState* __tstate = wxPyBeginAllowThreads();
9984 result = (wxLog *)(arg1)->GetOldLog();
9985
9986 wxPyEndAllowThreads(__tstate);
9987 if (PyErr_Occurred()) SWIG_fail;
9988 }
9989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9990 return resultobj;
9991 fail:
9992 return NULL;
9993 }
9994
9995
9996 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9997 PyObject *obj;
9998 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9999 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
10000 Py_INCREF(obj);
10001 return Py_BuildValue((char *)"");
10002 }
10003 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10004 PyObject *resultobj;
10005 unsigned long result;
10006 char *kwnames[] = {
10007 NULL
10008 };
10009
10010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10011 {
10012 PyThreadState* __tstate = wxPyBeginAllowThreads();
10013 result = (unsigned long)wxSysErrorCode();
10014
10015 wxPyEndAllowThreads(__tstate);
10016 if (PyErr_Occurred()) SWIG_fail;
10017 }
10018 {
10019 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10020 }
10021 return resultobj;
10022 fail:
10023 return NULL;
10024 }
10025
10026
10027 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10028 PyObject *resultobj;
10029 unsigned long arg1 = (unsigned long) 0 ;
10030 wxString result;
10031 PyObject * obj0 = 0 ;
10032 char *kwnames[] = {
10033 (char *) "nErrCode", NULL
10034 };
10035
10036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10037 if (obj0) {
10038 {
10039 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10040 if (SWIG_arg_fail(1)) SWIG_fail;
10041 }
10042 }
10043 {
10044 PyThreadState* __tstate = wxPyBeginAllowThreads();
10045 result = wxSysErrorMsg(arg1);
10046
10047 wxPyEndAllowThreads(__tstate);
10048 if (PyErr_Occurred()) SWIG_fail;
10049 }
10050 {
10051 #if wxUSE_UNICODE
10052 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10053 #else
10054 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10055 #endif
10056 }
10057 return resultobj;
10058 fail:
10059 return NULL;
10060 }
10061
10062
10063 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10064 PyObject *resultobj;
10065 wxString *arg1 = 0 ;
10066 bool temp1 = false ;
10067 PyObject * obj0 = 0 ;
10068 char *kwnames[] = {
10069 (char *) "msg", NULL
10070 };
10071
10072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10073 {
10074 arg1 = wxString_in_helper(obj0);
10075 if (arg1 == NULL) SWIG_fail;
10076 temp1 = true;
10077 }
10078 {
10079 PyThreadState* __tstate = wxPyBeginAllowThreads();
10080 wxPyLogFatalError((wxString const &)*arg1);
10081
10082 wxPyEndAllowThreads(__tstate);
10083 if (PyErr_Occurred()) SWIG_fail;
10084 }
10085 Py_INCREF(Py_None); resultobj = Py_None;
10086 {
10087 if (temp1)
10088 delete arg1;
10089 }
10090 return resultobj;
10091 fail:
10092 {
10093 if (temp1)
10094 delete arg1;
10095 }
10096 return NULL;
10097 }
10098
10099
10100 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10101 PyObject *resultobj;
10102 wxString *arg1 = 0 ;
10103 bool temp1 = false ;
10104 PyObject * obj0 = 0 ;
10105 char *kwnames[] = {
10106 (char *) "msg", NULL
10107 };
10108
10109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10110 {
10111 arg1 = wxString_in_helper(obj0);
10112 if (arg1 == NULL) SWIG_fail;
10113 temp1 = true;
10114 }
10115 {
10116 PyThreadState* __tstate = wxPyBeginAllowThreads();
10117 wxPyLogError((wxString const &)*arg1);
10118
10119 wxPyEndAllowThreads(__tstate);
10120 if (PyErr_Occurred()) SWIG_fail;
10121 }
10122 Py_INCREF(Py_None); resultobj = Py_None;
10123 {
10124 if (temp1)
10125 delete arg1;
10126 }
10127 return resultobj;
10128 fail:
10129 {
10130 if (temp1)
10131 delete arg1;
10132 }
10133 return NULL;
10134 }
10135
10136
10137 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10138 PyObject *resultobj;
10139 wxString *arg1 = 0 ;
10140 bool temp1 = false ;
10141 PyObject * obj0 = 0 ;
10142 char *kwnames[] = {
10143 (char *) "msg", NULL
10144 };
10145
10146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10147 {
10148 arg1 = wxString_in_helper(obj0);
10149 if (arg1 == NULL) SWIG_fail;
10150 temp1 = true;
10151 }
10152 {
10153 PyThreadState* __tstate = wxPyBeginAllowThreads();
10154 wxPyLogWarning((wxString const &)*arg1);
10155
10156 wxPyEndAllowThreads(__tstate);
10157 if (PyErr_Occurred()) SWIG_fail;
10158 }
10159 Py_INCREF(Py_None); resultobj = Py_None;
10160 {
10161 if (temp1)
10162 delete arg1;
10163 }
10164 return resultobj;
10165 fail:
10166 {
10167 if (temp1)
10168 delete arg1;
10169 }
10170 return NULL;
10171 }
10172
10173
10174 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10175 PyObject *resultobj;
10176 wxString *arg1 = 0 ;
10177 bool temp1 = false ;
10178 PyObject * obj0 = 0 ;
10179 char *kwnames[] = {
10180 (char *) "msg", NULL
10181 };
10182
10183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10184 {
10185 arg1 = wxString_in_helper(obj0);
10186 if (arg1 == NULL) SWIG_fail;
10187 temp1 = true;
10188 }
10189 {
10190 PyThreadState* __tstate = wxPyBeginAllowThreads();
10191 wxPyLogMessage((wxString const &)*arg1);
10192
10193 wxPyEndAllowThreads(__tstate);
10194 if (PyErr_Occurred()) SWIG_fail;
10195 }
10196 Py_INCREF(Py_None); resultobj = Py_None;
10197 {
10198 if (temp1)
10199 delete arg1;
10200 }
10201 return resultobj;
10202 fail:
10203 {
10204 if (temp1)
10205 delete arg1;
10206 }
10207 return NULL;
10208 }
10209
10210
10211 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10212 PyObject *resultobj;
10213 wxString *arg1 = 0 ;
10214 bool temp1 = false ;
10215 PyObject * obj0 = 0 ;
10216 char *kwnames[] = {
10217 (char *) "msg", NULL
10218 };
10219
10220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10221 {
10222 arg1 = wxString_in_helper(obj0);
10223 if (arg1 == NULL) SWIG_fail;
10224 temp1 = true;
10225 }
10226 {
10227 PyThreadState* __tstate = wxPyBeginAllowThreads();
10228 wxPyLogInfo((wxString const &)*arg1);
10229
10230 wxPyEndAllowThreads(__tstate);
10231 if (PyErr_Occurred()) SWIG_fail;
10232 }
10233 Py_INCREF(Py_None); resultobj = Py_None;
10234 {
10235 if (temp1)
10236 delete arg1;
10237 }
10238 return resultobj;
10239 fail:
10240 {
10241 if (temp1)
10242 delete arg1;
10243 }
10244 return NULL;
10245 }
10246
10247
10248 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10249 PyObject *resultobj;
10250 wxString *arg1 = 0 ;
10251 bool temp1 = false ;
10252 PyObject * obj0 = 0 ;
10253 char *kwnames[] = {
10254 (char *) "msg", NULL
10255 };
10256
10257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10258 {
10259 arg1 = wxString_in_helper(obj0);
10260 if (arg1 == NULL) SWIG_fail;
10261 temp1 = true;
10262 }
10263 {
10264 PyThreadState* __tstate = wxPyBeginAllowThreads();
10265 wxPyLogDebug((wxString const &)*arg1);
10266
10267 wxPyEndAllowThreads(__tstate);
10268 if (PyErr_Occurred()) SWIG_fail;
10269 }
10270 Py_INCREF(Py_None); resultobj = Py_None;
10271 {
10272 if (temp1)
10273 delete arg1;
10274 }
10275 return resultobj;
10276 fail:
10277 {
10278 if (temp1)
10279 delete arg1;
10280 }
10281 return NULL;
10282 }
10283
10284
10285 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10286 PyObject *resultobj;
10287 wxString *arg1 = 0 ;
10288 bool temp1 = false ;
10289 PyObject * obj0 = 0 ;
10290 char *kwnames[] = {
10291 (char *) "msg", NULL
10292 };
10293
10294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10295 {
10296 arg1 = wxString_in_helper(obj0);
10297 if (arg1 == NULL) SWIG_fail;
10298 temp1 = true;
10299 }
10300 {
10301 PyThreadState* __tstate = wxPyBeginAllowThreads();
10302 wxPyLogVerbose((wxString const &)*arg1);
10303
10304 wxPyEndAllowThreads(__tstate);
10305 if (PyErr_Occurred()) SWIG_fail;
10306 }
10307 Py_INCREF(Py_None); resultobj = Py_None;
10308 {
10309 if (temp1)
10310 delete arg1;
10311 }
10312 return resultobj;
10313 fail:
10314 {
10315 if (temp1)
10316 delete arg1;
10317 }
10318 return NULL;
10319 }
10320
10321
10322 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10323 PyObject *resultobj;
10324 wxString *arg1 = 0 ;
10325 bool temp1 = false ;
10326 PyObject * obj0 = 0 ;
10327 char *kwnames[] = {
10328 (char *) "msg", NULL
10329 };
10330
10331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10332 {
10333 arg1 = wxString_in_helper(obj0);
10334 if (arg1 == NULL) SWIG_fail;
10335 temp1 = true;
10336 }
10337 {
10338 PyThreadState* __tstate = wxPyBeginAllowThreads();
10339 wxPyLogStatus((wxString const &)*arg1);
10340
10341 wxPyEndAllowThreads(__tstate);
10342 if (PyErr_Occurred()) SWIG_fail;
10343 }
10344 Py_INCREF(Py_None); resultobj = Py_None;
10345 {
10346 if (temp1)
10347 delete arg1;
10348 }
10349 return resultobj;
10350 fail:
10351 {
10352 if (temp1)
10353 delete arg1;
10354 }
10355 return NULL;
10356 }
10357
10358
10359 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10360 PyObject *resultobj;
10361 wxFrame *arg1 = (wxFrame *) 0 ;
10362 wxString *arg2 = 0 ;
10363 bool temp2 = false ;
10364 PyObject * obj0 = 0 ;
10365 PyObject * obj1 = 0 ;
10366 char *kwnames[] = {
10367 (char *) "pFrame",(char *) "msg", NULL
10368 };
10369
10370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10372 if (SWIG_arg_fail(1)) SWIG_fail;
10373 {
10374 arg2 = wxString_in_helper(obj1);
10375 if (arg2 == NULL) SWIG_fail;
10376 temp2 = true;
10377 }
10378 {
10379 PyThreadState* __tstate = wxPyBeginAllowThreads();
10380 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10381
10382 wxPyEndAllowThreads(__tstate);
10383 if (PyErr_Occurred()) SWIG_fail;
10384 }
10385 Py_INCREF(Py_None); resultobj = Py_None;
10386 {
10387 if (temp2)
10388 delete arg2;
10389 }
10390 return resultobj;
10391 fail:
10392 {
10393 if (temp2)
10394 delete arg2;
10395 }
10396 return NULL;
10397 }
10398
10399
10400 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10401 PyObject *resultobj;
10402 wxString *arg1 = 0 ;
10403 bool temp1 = false ;
10404 PyObject * obj0 = 0 ;
10405 char *kwnames[] = {
10406 (char *) "msg", NULL
10407 };
10408
10409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10410 {
10411 arg1 = wxString_in_helper(obj0);
10412 if (arg1 == NULL) SWIG_fail;
10413 temp1 = true;
10414 }
10415 {
10416 PyThreadState* __tstate = wxPyBeginAllowThreads();
10417 wxPyLogSysError((wxString const &)*arg1);
10418
10419 wxPyEndAllowThreads(__tstate);
10420 if (PyErr_Occurred()) SWIG_fail;
10421 }
10422 Py_INCREF(Py_None); resultobj = Py_None;
10423 {
10424 if (temp1)
10425 delete arg1;
10426 }
10427 return resultobj;
10428 fail:
10429 {
10430 if (temp1)
10431 delete arg1;
10432 }
10433 return NULL;
10434 }
10435
10436
10437 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10438 PyObject *resultobj;
10439 unsigned long arg1 ;
10440 wxString *arg2 = 0 ;
10441 bool temp2 = false ;
10442 PyObject * obj0 = 0 ;
10443 PyObject * obj1 = 0 ;
10444 char *kwnames[] = {
10445 (char *) "level",(char *) "msg", NULL
10446 };
10447
10448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10449 {
10450 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10451 if (SWIG_arg_fail(1)) SWIG_fail;
10452 }
10453 {
10454 arg2 = wxString_in_helper(obj1);
10455 if (arg2 == NULL) SWIG_fail;
10456 temp2 = true;
10457 }
10458 {
10459 PyThreadState* __tstate = wxPyBeginAllowThreads();
10460 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10461
10462 wxPyEndAllowThreads(__tstate);
10463 if (PyErr_Occurred()) SWIG_fail;
10464 }
10465 Py_INCREF(Py_None); resultobj = Py_None;
10466 {
10467 if (temp2)
10468 delete arg2;
10469 }
10470 return resultobj;
10471 fail:
10472 {
10473 if (temp2)
10474 delete arg2;
10475 }
10476 return NULL;
10477 }
10478
10479
10480 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10481 PyObject *resultobj;
10482 unsigned long arg1 ;
10483 wxString *arg2 = 0 ;
10484 bool temp2 = false ;
10485 PyObject * obj0 = 0 ;
10486 PyObject * obj1 = 0 ;
10487
10488 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10489 {
10490 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10491 if (SWIG_arg_fail(1)) SWIG_fail;
10492 }
10493 {
10494 arg2 = wxString_in_helper(obj1);
10495 if (arg2 == NULL) SWIG_fail;
10496 temp2 = true;
10497 }
10498 {
10499 PyThreadState* __tstate = wxPyBeginAllowThreads();
10500 wxPyLogTrace(arg1,(wxString const &)*arg2);
10501
10502 wxPyEndAllowThreads(__tstate);
10503 if (PyErr_Occurred()) SWIG_fail;
10504 }
10505 Py_INCREF(Py_None); resultobj = Py_None;
10506 {
10507 if (temp2)
10508 delete arg2;
10509 }
10510 return resultobj;
10511 fail:
10512 {
10513 if (temp2)
10514 delete arg2;
10515 }
10516 return NULL;
10517 }
10518
10519
10520 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10521 PyObject *resultobj;
10522 wxString *arg1 = 0 ;
10523 wxString *arg2 = 0 ;
10524 bool temp1 = false ;
10525 bool temp2 = false ;
10526 PyObject * obj0 = 0 ;
10527 PyObject * obj1 = 0 ;
10528
10529 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10530 {
10531 arg1 = wxString_in_helper(obj0);
10532 if (arg1 == NULL) SWIG_fail;
10533 temp1 = true;
10534 }
10535 {
10536 arg2 = wxString_in_helper(obj1);
10537 if (arg2 == NULL) SWIG_fail;
10538 temp2 = true;
10539 }
10540 {
10541 PyThreadState* __tstate = wxPyBeginAllowThreads();
10542 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10543
10544 wxPyEndAllowThreads(__tstate);
10545 if (PyErr_Occurred()) SWIG_fail;
10546 }
10547 Py_INCREF(Py_None); resultobj = Py_None;
10548 {
10549 if (temp1)
10550 delete arg1;
10551 }
10552 {
10553 if (temp2)
10554 delete arg2;
10555 }
10556 return resultobj;
10557 fail:
10558 {
10559 if (temp1)
10560 delete arg1;
10561 }
10562 {
10563 if (temp2)
10564 delete arg2;
10565 }
10566 return NULL;
10567 }
10568
10569
10570 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10571 int argc;
10572 PyObject *argv[3];
10573 int ii;
10574
10575 argc = PyObject_Length(args);
10576 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10577 argv[ii] = PyTuple_GetItem(args,ii);
10578 }
10579 if (argc == 2) {
10580 int _v;
10581 {
10582 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10583 }
10584 if (_v) {
10585 {
10586 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10587 }
10588 if (_v) {
10589 return _wrap_LogTrace__SWIG_1(self,args);
10590 }
10591 }
10592 }
10593 if (argc == 2) {
10594 int _v;
10595 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10596 if (_v) {
10597 {
10598 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10599 }
10600 if (_v) {
10601 return _wrap_LogTrace__SWIG_0(self,args);
10602 }
10603 }
10604 }
10605
10606 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10607 return NULL;
10608 }
10609
10610
10611 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10612 PyObject *resultobj;
10613 wxString *arg1 = 0 ;
10614 wxString *arg2 = 0 ;
10615 bool temp1 = false ;
10616 bool temp2 = false ;
10617 PyObject * obj0 = 0 ;
10618 PyObject * obj1 = 0 ;
10619 char *kwnames[] = {
10620 (char *) "title",(char *) "text", NULL
10621 };
10622
10623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10624 {
10625 arg1 = wxString_in_helper(obj0);
10626 if (arg1 == NULL) SWIG_fail;
10627 temp1 = true;
10628 }
10629 {
10630 arg2 = wxString_in_helper(obj1);
10631 if (arg2 == NULL) SWIG_fail;
10632 temp2 = true;
10633 }
10634 {
10635 PyThreadState* __tstate = wxPyBeginAllowThreads();
10636 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10637
10638 wxPyEndAllowThreads(__tstate);
10639 if (PyErr_Occurred()) SWIG_fail;
10640 }
10641 Py_INCREF(Py_None); resultobj = Py_None;
10642 {
10643 if (temp1)
10644 delete arg1;
10645 }
10646 {
10647 if (temp2)
10648 delete arg2;
10649 }
10650 return resultobj;
10651 fail:
10652 {
10653 if (temp1)
10654 delete arg1;
10655 }
10656 {
10657 if (temp2)
10658 delete arg2;
10659 }
10660 return NULL;
10661 }
10662
10663
10664 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10665 PyObject *resultobj;
10666 wxLogNull *result;
10667 char *kwnames[] = {
10668 NULL
10669 };
10670
10671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10672 {
10673 PyThreadState* __tstate = wxPyBeginAllowThreads();
10674 result = (wxLogNull *)new wxLogNull();
10675
10676 wxPyEndAllowThreads(__tstate);
10677 if (PyErr_Occurred()) SWIG_fail;
10678 }
10679 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10680 return resultobj;
10681 fail:
10682 return NULL;
10683 }
10684
10685
10686 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10687 PyObject *resultobj;
10688 wxLogNull *arg1 = (wxLogNull *) 0 ;
10689 PyObject * obj0 = 0 ;
10690 char *kwnames[] = {
10691 (char *) "self", NULL
10692 };
10693
10694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10696 if (SWIG_arg_fail(1)) SWIG_fail;
10697 {
10698 PyThreadState* __tstate = wxPyBeginAllowThreads();
10699 delete arg1;
10700
10701 wxPyEndAllowThreads(__tstate);
10702 if (PyErr_Occurred()) SWIG_fail;
10703 }
10704 Py_INCREF(Py_None); resultobj = Py_None;
10705 return resultobj;
10706 fail:
10707 return NULL;
10708 }
10709
10710
10711 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10712 PyObject *obj;
10713 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10714 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10715 Py_INCREF(obj);
10716 return Py_BuildValue((char *)"");
10717 }
10718 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10719 PyObject *resultobj;
10720 wxPyLog *result;
10721 char *kwnames[] = {
10722 NULL
10723 };
10724
10725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10726 {
10727 PyThreadState* __tstate = wxPyBeginAllowThreads();
10728 result = (wxPyLog *)new wxPyLog();
10729
10730 wxPyEndAllowThreads(__tstate);
10731 if (PyErr_Occurred()) SWIG_fail;
10732 }
10733 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10734 return resultobj;
10735 fail:
10736 return NULL;
10737 }
10738
10739
10740 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10741 PyObject *resultobj;
10742 wxPyLog *arg1 = (wxPyLog *) 0 ;
10743 PyObject *arg2 = (PyObject *) 0 ;
10744 PyObject *arg3 = (PyObject *) 0 ;
10745 PyObject * obj0 = 0 ;
10746 PyObject * obj1 = 0 ;
10747 PyObject * obj2 = 0 ;
10748 char *kwnames[] = {
10749 (char *) "self",(char *) "self",(char *) "_class", NULL
10750 };
10751
10752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10754 if (SWIG_arg_fail(1)) SWIG_fail;
10755 arg2 = obj1;
10756 arg3 = obj2;
10757 {
10758 PyThreadState* __tstate = wxPyBeginAllowThreads();
10759 (arg1)->_setCallbackInfo(arg2,arg3);
10760
10761 wxPyEndAllowThreads(__tstate);
10762 if (PyErr_Occurred()) SWIG_fail;
10763 }
10764 Py_INCREF(Py_None); resultobj = Py_None;
10765 return resultobj;
10766 fail:
10767 return NULL;
10768 }
10769
10770
10771 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10772 PyObject *obj;
10773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10774 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10775 Py_INCREF(obj);
10776 return Py_BuildValue((char *)"");
10777 }
10778 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10779 PyObject *resultobj;
10780 int arg1 ;
10781 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10782 int arg3 = (int) wxKILL_NOCHILDREN ;
10783 wxKillError result;
10784 PyObject * obj0 = 0 ;
10785 PyObject * obj1 = 0 ;
10786 PyObject * obj2 = 0 ;
10787 char *kwnames[] = {
10788 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10789 };
10790
10791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10792 {
10793 arg1 = (int)(SWIG_As_int(obj0));
10794 if (SWIG_arg_fail(1)) SWIG_fail;
10795 }
10796 if (obj1) {
10797 {
10798 arg2 = (wxSignal)(SWIG_As_int(obj1));
10799 if (SWIG_arg_fail(2)) SWIG_fail;
10800 }
10801 }
10802 if (obj2) {
10803 {
10804 arg3 = (int)(SWIG_As_int(obj2));
10805 if (SWIG_arg_fail(3)) SWIG_fail;
10806 }
10807 }
10808 {
10809 PyThreadState* __tstate = wxPyBeginAllowThreads();
10810 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10811
10812 wxPyEndAllowThreads(__tstate);
10813 if (PyErr_Occurred()) SWIG_fail;
10814 }
10815 resultobj = SWIG_From_int((result));
10816 return resultobj;
10817 fail:
10818 return NULL;
10819 }
10820
10821
10822 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10823 PyObject *resultobj;
10824 int arg1 ;
10825 bool result;
10826 PyObject * obj0 = 0 ;
10827 char *kwnames[] = {
10828 (char *) "pid", NULL
10829 };
10830
10831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10832 {
10833 arg1 = (int)(SWIG_As_int(obj0));
10834 if (SWIG_arg_fail(1)) SWIG_fail;
10835 }
10836 {
10837 PyThreadState* __tstate = wxPyBeginAllowThreads();
10838 result = (bool)wxPyProcess::Exists(arg1);
10839
10840 wxPyEndAllowThreads(__tstate);
10841 if (PyErr_Occurred()) SWIG_fail;
10842 }
10843 {
10844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10845 }
10846 return resultobj;
10847 fail:
10848 return NULL;
10849 }
10850
10851
10852 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10853 PyObject *resultobj;
10854 wxString *arg1 = 0 ;
10855 int arg2 = (int) wxEXEC_ASYNC ;
10856 wxPyProcess *result;
10857 bool temp1 = false ;
10858 PyObject * obj0 = 0 ;
10859 PyObject * obj1 = 0 ;
10860 char *kwnames[] = {
10861 (char *) "cmd",(char *) "flags", NULL
10862 };
10863
10864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10865 {
10866 arg1 = wxString_in_helper(obj0);
10867 if (arg1 == NULL) SWIG_fail;
10868 temp1 = true;
10869 }
10870 if (obj1) {
10871 {
10872 arg2 = (int)(SWIG_As_int(obj1));
10873 if (SWIG_arg_fail(2)) SWIG_fail;
10874 }
10875 }
10876 {
10877 PyThreadState* __tstate = wxPyBeginAllowThreads();
10878 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10879
10880 wxPyEndAllowThreads(__tstate);
10881 if (PyErr_Occurred()) SWIG_fail;
10882 }
10883 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10884 {
10885 if (temp1)
10886 delete arg1;
10887 }
10888 return resultobj;
10889 fail:
10890 {
10891 if (temp1)
10892 delete arg1;
10893 }
10894 return NULL;
10895 }
10896
10897
10898 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10899 PyObject *resultobj;
10900 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10901 int arg2 = (int) -1 ;
10902 wxPyProcess *result;
10903 PyObject * obj0 = 0 ;
10904 PyObject * obj1 = 0 ;
10905 char *kwnames[] = {
10906 (char *) "parent",(char *) "id", NULL
10907 };
10908
10909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10910 if (obj0) {
10911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10912 if (SWIG_arg_fail(1)) SWIG_fail;
10913 }
10914 if (obj1) {
10915 {
10916 arg2 = (int)(SWIG_As_int(obj1));
10917 if (SWIG_arg_fail(2)) SWIG_fail;
10918 }
10919 }
10920 {
10921 PyThreadState* __tstate = wxPyBeginAllowThreads();
10922 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10923
10924 wxPyEndAllowThreads(__tstate);
10925 if (PyErr_Occurred()) SWIG_fail;
10926 }
10927 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10928 return resultobj;
10929 fail:
10930 return NULL;
10931 }
10932
10933
10934 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10935 PyObject *resultobj;
10936 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10937 PyObject *arg2 = (PyObject *) 0 ;
10938 PyObject *arg3 = (PyObject *) 0 ;
10939 PyObject * obj0 = 0 ;
10940 PyObject * obj1 = 0 ;
10941 PyObject * obj2 = 0 ;
10942 char *kwnames[] = {
10943 (char *) "self",(char *) "self",(char *) "_class", NULL
10944 };
10945
10946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10948 if (SWIG_arg_fail(1)) SWIG_fail;
10949 arg2 = obj1;
10950 arg3 = obj2;
10951 {
10952 PyThreadState* __tstate = wxPyBeginAllowThreads();
10953 (arg1)->_setCallbackInfo(arg2,arg3);
10954
10955 wxPyEndAllowThreads(__tstate);
10956 if (PyErr_Occurred()) SWIG_fail;
10957 }
10958 Py_INCREF(Py_None); resultobj = Py_None;
10959 return resultobj;
10960 fail:
10961 return NULL;
10962 }
10963
10964
10965 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10966 PyObject *resultobj;
10967 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10968 int arg2 ;
10969 int arg3 ;
10970 PyObject * obj0 = 0 ;
10971 PyObject * obj1 = 0 ;
10972 PyObject * obj2 = 0 ;
10973 char *kwnames[] = {
10974 (char *) "self",(char *) "pid",(char *) "status", NULL
10975 };
10976
10977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10979 if (SWIG_arg_fail(1)) SWIG_fail;
10980 {
10981 arg2 = (int)(SWIG_As_int(obj1));
10982 if (SWIG_arg_fail(2)) SWIG_fail;
10983 }
10984 {
10985 arg3 = (int)(SWIG_As_int(obj2));
10986 if (SWIG_arg_fail(3)) SWIG_fail;
10987 }
10988 {
10989 PyThreadState* __tstate = wxPyBeginAllowThreads();
10990 (arg1)->base_OnTerminate(arg2,arg3);
10991
10992 wxPyEndAllowThreads(__tstate);
10993 if (PyErr_Occurred()) SWIG_fail;
10994 }
10995 Py_INCREF(Py_None); resultobj = Py_None;
10996 return resultobj;
10997 fail:
10998 return NULL;
10999 }
11000
11001
11002 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11003 PyObject *resultobj;
11004 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11005 PyObject * obj0 = 0 ;
11006 char *kwnames[] = {
11007 (char *) "self", NULL
11008 };
11009
11010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11012 if (SWIG_arg_fail(1)) SWIG_fail;
11013 {
11014 PyThreadState* __tstate = wxPyBeginAllowThreads();
11015 (arg1)->Redirect();
11016
11017 wxPyEndAllowThreads(__tstate);
11018 if (PyErr_Occurred()) SWIG_fail;
11019 }
11020 Py_INCREF(Py_None); resultobj = Py_None;
11021 return resultobj;
11022 fail:
11023 return NULL;
11024 }
11025
11026
11027 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11028 PyObject *resultobj;
11029 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11030 bool result;
11031 PyObject * obj0 = 0 ;
11032 char *kwnames[] = {
11033 (char *) "self", NULL
11034 };
11035
11036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11038 if (SWIG_arg_fail(1)) SWIG_fail;
11039 {
11040 PyThreadState* __tstate = wxPyBeginAllowThreads();
11041 result = (bool)(arg1)->IsRedirected();
11042
11043 wxPyEndAllowThreads(__tstate);
11044 if (PyErr_Occurred()) SWIG_fail;
11045 }
11046 {
11047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11048 }
11049 return resultobj;
11050 fail:
11051 return NULL;
11052 }
11053
11054
11055 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11056 PyObject *resultobj;
11057 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11058 PyObject * obj0 = 0 ;
11059 char *kwnames[] = {
11060 (char *) "self", NULL
11061 };
11062
11063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11065 if (SWIG_arg_fail(1)) SWIG_fail;
11066 {
11067 PyThreadState* __tstate = wxPyBeginAllowThreads();
11068 (arg1)->Detach();
11069
11070 wxPyEndAllowThreads(__tstate);
11071 if (PyErr_Occurred()) SWIG_fail;
11072 }
11073 Py_INCREF(Py_None); resultobj = Py_None;
11074 return resultobj;
11075 fail:
11076 return NULL;
11077 }
11078
11079
11080 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11081 PyObject *resultobj;
11082 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11083 wxInputStream *result;
11084 PyObject * obj0 = 0 ;
11085 char *kwnames[] = {
11086 (char *) "self", NULL
11087 };
11088
11089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11091 if (SWIG_arg_fail(1)) SWIG_fail;
11092 {
11093 PyThreadState* __tstate = wxPyBeginAllowThreads();
11094 result = (wxInputStream *)(arg1)->GetInputStream();
11095
11096 wxPyEndAllowThreads(__tstate);
11097 if (PyErr_Occurred()) SWIG_fail;
11098 }
11099 {
11100 wxPyInputStream * _ptr = NULL;
11101
11102 if (result) {
11103 _ptr = new wxPyInputStream(result);
11104 }
11105 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11106 }
11107 return resultobj;
11108 fail:
11109 return NULL;
11110 }
11111
11112
11113 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11114 PyObject *resultobj;
11115 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11116 wxInputStream *result;
11117 PyObject * obj0 = 0 ;
11118 char *kwnames[] = {
11119 (char *) "self", NULL
11120 };
11121
11122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11124 if (SWIG_arg_fail(1)) SWIG_fail;
11125 {
11126 PyThreadState* __tstate = wxPyBeginAllowThreads();
11127 result = (wxInputStream *)(arg1)->GetErrorStream();
11128
11129 wxPyEndAllowThreads(__tstate);
11130 if (PyErr_Occurred()) SWIG_fail;
11131 }
11132 {
11133 wxPyInputStream * _ptr = NULL;
11134
11135 if (result) {
11136 _ptr = new wxPyInputStream(result);
11137 }
11138 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11139 }
11140 return resultobj;
11141 fail:
11142 return NULL;
11143 }
11144
11145
11146 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11147 PyObject *resultobj;
11148 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11149 wxOutputStream *result;
11150 PyObject * obj0 = 0 ;
11151 char *kwnames[] = {
11152 (char *) "self", NULL
11153 };
11154
11155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11157 if (SWIG_arg_fail(1)) SWIG_fail;
11158 {
11159 PyThreadState* __tstate = wxPyBeginAllowThreads();
11160 result = (wxOutputStream *)(arg1)->GetOutputStream();
11161
11162 wxPyEndAllowThreads(__tstate);
11163 if (PyErr_Occurred()) SWIG_fail;
11164 }
11165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11166 return resultobj;
11167 fail:
11168 return NULL;
11169 }
11170
11171
11172 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11173 PyObject *resultobj;
11174 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11175 PyObject * obj0 = 0 ;
11176 char *kwnames[] = {
11177 (char *) "self", NULL
11178 };
11179
11180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11182 if (SWIG_arg_fail(1)) SWIG_fail;
11183 {
11184 PyThreadState* __tstate = wxPyBeginAllowThreads();
11185 (arg1)->CloseOutput();
11186
11187 wxPyEndAllowThreads(__tstate);
11188 if (PyErr_Occurred()) SWIG_fail;
11189 }
11190 Py_INCREF(Py_None); resultobj = Py_None;
11191 return resultobj;
11192 fail:
11193 return NULL;
11194 }
11195
11196
11197 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11198 PyObject *resultobj;
11199 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11200 bool result;
11201 PyObject * obj0 = 0 ;
11202 char *kwnames[] = {
11203 (char *) "self", NULL
11204 };
11205
11206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11208 if (SWIG_arg_fail(1)) SWIG_fail;
11209 {
11210 PyThreadState* __tstate = wxPyBeginAllowThreads();
11211 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11212
11213 wxPyEndAllowThreads(__tstate);
11214 if (PyErr_Occurred()) SWIG_fail;
11215 }
11216 {
11217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11218 }
11219 return resultobj;
11220 fail:
11221 return NULL;
11222 }
11223
11224
11225 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11226 PyObject *resultobj;
11227 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11228 bool result;
11229 PyObject * obj0 = 0 ;
11230 char *kwnames[] = {
11231 (char *) "self", NULL
11232 };
11233
11234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11236 if (SWIG_arg_fail(1)) SWIG_fail;
11237 {
11238 PyThreadState* __tstate = wxPyBeginAllowThreads();
11239 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11240
11241 wxPyEndAllowThreads(__tstate);
11242 if (PyErr_Occurred()) SWIG_fail;
11243 }
11244 {
11245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11246 }
11247 return resultobj;
11248 fail:
11249 return NULL;
11250 }
11251
11252
11253 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11254 PyObject *resultobj;
11255 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11256 bool result;
11257 PyObject * obj0 = 0 ;
11258 char *kwnames[] = {
11259 (char *) "self", NULL
11260 };
11261
11262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11264 if (SWIG_arg_fail(1)) SWIG_fail;
11265 {
11266 PyThreadState* __tstate = wxPyBeginAllowThreads();
11267 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11268
11269 wxPyEndAllowThreads(__tstate);
11270 if (PyErr_Occurred()) SWIG_fail;
11271 }
11272 {
11273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11274 }
11275 return resultobj;
11276 fail:
11277 return NULL;
11278 }
11279
11280
11281 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11282 PyObject *obj;
11283 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11284 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11285 Py_INCREF(obj);
11286 return Py_BuildValue((char *)"");
11287 }
11288 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11289 PyObject *resultobj;
11290 int arg1 = (int) 0 ;
11291 int arg2 = (int) 0 ;
11292 int arg3 = (int) 0 ;
11293 wxProcessEvent *result;
11294 PyObject * obj0 = 0 ;
11295 PyObject * obj1 = 0 ;
11296 PyObject * obj2 = 0 ;
11297 char *kwnames[] = {
11298 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11299 };
11300
11301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11302 if (obj0) {
11303 {
11304 arg1 = (int)(SWIG_As_int(obj0));
11305 if (SWIG_arg_fail(1)) SWIG_fail;
11306 }
11307 }
11308 if (obj1) {
11309 {
11310 arg2 = (int)(SWIG_As_int(obj1));
11311 if (SWIG_arg_fail(2)) SWIG_fail;
11312 }
11313 }
11314 if (obj2) {
11315 {
11316 arg3 = (int)(SWIG_As_int(obj2));
11317 if (SWIG_arg_fail(3)) SWIG_fail;
11318 }
11319 }
11320 {
11321 PyThreadState* __tstate = wxPyBeginAllowThreads();
11322 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11323
11324 wxPyEndAllowThreads(__tstate);
11325 if (PyErr_Occurred()) SWIG_fail;
11326 }
11327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11328 return resultobj;
11329 fail:
11330 return NULL;
11331 }
11332
11333
11334 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11335 PyObject *resultobj;
11336 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11337 int result;
11338 PyObject * obj0 = 0 ;
11339 char *kwnames[] = {
11340 (char *) "self", NULL
11341 };
11342
11343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11345 if (SWIG_arg_fail(1)) SWIG_fail;
11346 {
11347 PyThreadState* __tstate = wxPyBeginAllowThreads();
11348 result = (int)(arg1)->GetPid();
11349
11350 wxPyEndAllowThreads(__tstate);
11351 if (PyErr_Occurred()) SWIG_fail;
11352 }
11353 {
11354 resultobj = SWIG_From_int((int)(result));
11355 }
11356 return resultobj;
11357 fail:
11358 return NULL;
11359 }
11360
11361
11362 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11363 PyObject *resultobj;
11364 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11365 int result;
11366 PyObject * obj0 = 0 ;
11367 char *kwnames[] = {
11368 (char *) "self", NULL
11369 };
11370
11371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11373 if (SWIG_arg_fail(1)) SWIG_fail;
11374 {
11375 PyThreadState* __tstate = wxPyBeginAllowThreads();
11376 result = (int)(arg1)->GetExitCode();
11377
11378 wxPyEndAllowThreads(__tstate);
11379 if (PyErr_Occurred()) SWIG_fail;
11380 }
11381 {
11382 resultobj = SWIG_From_int((int)(result));
11383 }
11384 return resultobj;
11385 fail:
11386 return NULL;
11387 }
11388
11389
11390 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11391 PyObject *resultobj;
11392 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11393 int arg2 ;
11394 PyObject * obj0 = 0 ;
11395 PyObject * obj1 = 0 ;
11396 char *kwnames[] = {
11397 (char *) "self",(char *) "m_pid", NULL
11398 };
11399
11400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11402 if (SWIG_arg_fail(1)) SWIG_fail;
11403 {
11404 arg2 = (int)(SWIG_As_int(obj1));
11405 if (SWIG_arg_fail(2)) SWIG_fail;
11406 }
11407 if (arg1) (arg1)->m_pid = arg2;
11408
11409 Py_INCREF(Py_None); resultobj = Py_None;
11410 return resultobj;
11411 fail:
11412 return NULL;
11413 }
11414
11415
11416 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11417 PyObject *resultobj;
11418 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11419 int result;
11420 PyObject * obj0 = 0 ;
11421 char *kwnames[] = {
11422 (char *) "self", NULL
11423 };
11424
11425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11427 if (SWIG_arg_fail(1)) SWIG_fail;
11428 result = (int) ((arg1)->m_pid);
11429
11430 {
11431 resultobj = SWIG_From_int((int)(result));
11432 }
11433 return resultobj;
11434 fail:
11435 return NULL;
11436 }
11437
11438
11439 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11440 PyObject *resultobj;
11441 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11442 int arg2 ;
11443 PyObject * obj0 = 0 ;
11444 PyObject * obj1 = 0 ;
11445 char *kwnames[] = {
11446 (char *) "self",(char *) "m_exitcode", NULL
11447 };
11448
11449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11451 if (SWIG_arg_fail(1)) SWIG_fail;
11452 {
11453 arg2 = (int)(SWIG_As_int(obj1));
11454 if (SWIG_arg_fail(2)) SWIG_fail;
11455 }
11456 if (arg1) (arg1)->m_exitcode = arg2;
11457
11458 Py_INCREF(Py_None); resultobj = Py_None;
11459 return resultobj;
11460 fail:
11461 return NULL;
11462 }
11463
11464
11465 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11466 PyObject *resultobj;
11467 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11468 int result;
11469 PyObject * obj0 = 0 ;
11470 char *kwnames[] = {
11471 (char *) "self", NULL
11472 };
11473
11474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11476 if (SWIG_arg_fail(1)) SWIG_fail;
11477 result = (int) ((arg1)->m_exitcode);
11478
11479 {
11480 resultobj = SWIG_From_int((int)(result));
11481 }
11482 return resultobj;
11483 fail:
11484 return NULL;
11485 }
11486
11487
11488 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11489 PyObject *obj;
11490 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11491 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11492 Py_INCREF(obj);
11493 return Py_BuildValue((char *)"");
11494 }
11495 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11496 PyObject *resultobj;
11497 wxString *arg1 = 0 ;
11498 int arg2 = (int) wxEXEC_ASYNC ;
11499 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11500 long result;
11501 bool temp1 = false ;
11502 PyObject * obj0 = 0 ;
11503 PyObject * obj1 = 0 ;
11504 PyObject * obj2 = 0 ;
11505 char *kwnames[] = {
11506 (char *) "command",(char *) "flags",(char *) "process", NULL
11507 };
11508
11509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11510 {
11511 arg1 = wxString_in_helper(obj0);
11512 if (arg1 == NULL) SWIG_fail;
11513 temp1 = true;
11514 }
11515 if (obj1) {
11516 {
11517 arg2 = (int)(SWIG_As_int(obj1));
11518 if (SWIG_arg_fail(2)) SWIG_fail;
11519 }
11520 }
11521 if (obj2) {
11522 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11523 if (SWIG_arg_fail(3)) SWIG_fail;
11524 }
11525 {
11526 if (!wxPyCheckForApp()) SWIG_fail;
11527 PyThreadState* __tstate = wxPyBeginAllowThreads();
11528 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11529
11530 wxPyEndAllowThreads(__tstate);
11531 if (PyErr_Occurred()) SWIG_fail;
11532 }
11533 {
11534 resultobj = SWIG_From_long((long)(result));
11535 }
11536 {
11537 if (temp1)
11538 delete arg1;
11539 }
11540 return resultobj;
11541 fail:
11542 {
11543 if (temp1)
11544 delete arg1;
11545 }
11546 return NULL;
11547 }
11548
11549
11550 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11551 PyObject *resultobj;
11552 long arg1 ;
11553 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11554 wxKillError *arg3 = (wxKillError *) 0 ;
11555 int arg4 = (int) wxKILL_NOCHILDREN ;
11556 int result;
11557 wxKillError temp3 ;
11558 PyObject * obj0 = 0 ;
11559 PyObject * obj1 = 0 ;
11560 PyObject * obj2 = 0 ;
11561 char *kwnames[] = {
11562 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11563 };
11564
11565 {
11566 arg3 = &temp3;
11567 }
11568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11569 {
11570 arg1 = (long)(SWIG_As_long(obj0));
11571 if (SWIG_arg_fail(1)) SWIG_fail;
11572 }
11573 if (obj1) {
11574 {
11575 arg2 = (wxSignal)(SWIG_As_int(obj1));
11576 if (SWIG_arg_fail(2)) SWIG_fail;
11577 }
11578 }
11579 if (obj2) {
11580 {
11581 arg4 = (int)(SWIG_As_int(obj2));
11582 if (SWIG_arg_fail(4)) SWIG_fail;
11583 }
11584 }
11585 {
11586 PyThreadState* __tstate = wxPyBeginAllowThreads();
11587 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11588
11589 wxPyEndAllowThreads(__tstate);
11590 if (PyErr_Occurred()) SWIG_fail;
11591 }
11592 {
11593 resultobj = SWIG_From_int((int)(result));
11594 }
11595 {
11596 PyObject* o;
11597 o = PyInt_FromLong((long) (*arg3));
11598 resultobj = t_output_helper(resultobj, o);
11599 }
11600 return resultobj;
11601 fail:
11602 return NULL;
11603 }
11604
11605
11606 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11607 PyObject *resultobj;
11608 int arg1 = (int) wxJOYSTICK1 ;
11609 wxJoystick *result;
11610 PyObject * obj0 = 0 ;
11611 char *kwnames[] = {
11612 (char *) "joystick", NULL
11613 };
11614
11615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11616 if (obj0) {
11617 {
11618 arg1 = (int)(SWIG_As_int(obj0));
11619 if (SWIG_arg_fail(1)) SWIG_fail;
11620 }
11621 }
11622 {
11623 if (!wxPyCheckForApp()) SWIG_fail;
11624 PyThreadState* __tstate = wxPyBeginAllowThreads();
11625 result = (wxJoystick *)new wxJoystick(arg1);
11626
11627 wxPyEndAllowThreads(__tstate);
11628 if (PyErr_Occurred()) SWIG_fail;
11629 }
11630 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11631 return resultobj;
11632 fail:
11633 return NULL;
11634 }
11635
11636
11637 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11638 PyObject *resultobj;
11639 wxJoystick *arg1 = (wxJoystick *) 0 ;
11640 PyObject * obj0 = 0 ;
11641 char *kwnames[] = {
11642 (char *) "self", NULL
11643 };
11644
11645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11647 if (SWIG_arg_fail(1)) SWIG_fail;
11648 {
11649 PyThreadState* __tstate = wxPyBeginAllowThreads();
11650 delete arg1;
11651
11652 wxPyEndAllowThreads(__tstate);
11653 if (PyErr_Occurred()) SWIG_fail;
11654 }
11655 Py_INCREF(Py_None); resultobj = Py_None;
11656 return resultobj;
11657 fail:
11658 return NULL;
11659 }
11660
11661
11662 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11663 PyObject *resultobj;
11664 wxJoystick *arg1 = (wxJoystick *) 0 ;
11665 wxPoint result;
11666 PyObject * obj0 = 0 ;
11667 char *kwnames[] = {
11668 (char *) "self", NULL
11669 };
11670
11671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11673 if (SWIG_arg_fail(1)) SWIG_fail;
11674 {
11675 PyThreadState* __tstate = wxPyBeginAllowThreads();
11676 result = (arg1)->GetPosition();
11677
11678 wxPyEndAllowThreads(__tstate);
11679 if (PyErr_Occurred()) SWIG_fail;
11680 }
11681 {
11682 wxPoint * resultptr;
11683 resultptr = new wxPoint((wxPoint &)(result));
11684 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11685 }
11686 return resultobj;
11687 fail:
11688 return NULL;
11689 }
11690
11691
11692 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11693 PyObject *resultobj;
11694 wxJoystick *arg1 = (wxJoystick *) 0 ;
11695 int result;
11696 PyObject * obj0 = 0 ;
11697 char *kwnames[] = {
11698 (char *) "self", NULL
11699 };
11700
11701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11703 if (SWIG_arg_fail(1)) SWIG_fail;
11704 {
11705 PyThreadState* __tstate = wxPyBeginAllowThreads();
11706 result = (int)(arg1)->GetZPosition();
11707
11708 wxPyEndAllowThreads(__tstate);
11709 if (PyErr_Occurred()) SWIG_fail;
11710 }
11711 {
11712 resultobj = SWIG_From_int((int)(result));
11713 }
11714 return resultobj;
11715 fail:
11716 return NULL;
11717 }
11718
11719
11720 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11721 PyObject *resultobj;
11722 wxJoystick *arg1 = (wxJoystick *) 0 ;
11723 int result;
11724 PyObject * obj0 = 0 ;
11725 char *kwnames[] = {
11726 (char *) "self", NULL
11727 };
11728
11729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11731 if (SWIG_arg_fail(1)) SWIG_fail;
11732 {
11733 PyThreadState* __tstate = wxPyBeginAllowThreads();
11734 result = (int)(arg1)->GetButtonState();
11735
11736 wxPyEndAllowThreads(__tstate);
11737 if (PyErr_Occurred()) SWIG_fail;
11738 }
11739 {
11740 resultobj = SWIG_From_int((int)(result));
11741 }
11742 return resultobj;
11743 fail:
11744 return NULL;
11745 }
11746
11747
11748 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11749 PyObject *resultobj;
11750 wxJoystick *arg1 = (wxJoystick *) 0 ;
11751 int result;
11752 PyObject * obj0 = 0 ;
11753 char *kwnames[] = {
11754 (char *) "self", NULL
11755 };
11756
11757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11759 if (SWIG_arg_fail(1)) SWIG_fail;
11760 {
11761 PyThreadState* __tstate = wxPyBeginAllowThreads();
11762 result = (int)(arg1)->GetPOVPosition();
11763
11764 wxPyEndAllowThreads(__tstate);
11765 if (PyErr_Occurred()) SWIG_fail;
11766 }
11767 {
11768 resultobj = SWIG_From_int((int)(result));
11769 }
11770 return resultobj;
11771 fail:
11772 return NULL;
11773 }
11774
11775
11776 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11777 PyObject *resultobj;
11778 wxJoystick *arg1 = (wxJoystick *) 0 ;
11779 int result;
11780 PyObject * obj0 = 0 ;
11781 char *kwnames[] = {
11782 (char *) "self", NULL
11783 };
11784
11785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11787 if (SWIG_arg_fail(1)) SWIG_fail;
11788 {
11789 PyThreadState* __tstate = wxPyBeginAllowThreads();
11790 result = (int)(arg1)->GetPOVCTSPosition();
11791
11792 wxPyEndAllowThreads(__tstate);
11793 if (PyErr_Occurred()) SWIG_fail;
11794 }
11795 {
11796 resultobj = SWIG_From_int((int)(result));
11797 }
11798 return resultobj;
11799 fail:
11800 return NULL;
11801 }
11802
11803
11804 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11805 PyObject *resultobj;
11806 wxJoystick *arg1 = (wxJoystick *) 0 ;
11807 int result;
11808 PyObject * obj0 = 0 ;
11809 char *kwnames[] = {
11810 (char *) "self", NULL
11811 };
11812
11813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11815 if (SWIG_arg_fail(1)) SWIG_fail;
11816 {
11817 PyThreadState* __tstate = wxPyBeginAllowThreads();
11818 result = (int)(arg1)->GetRudderPosition();
11819
11820 wxPyEndAllowThreads(__tstate);
11821 if (PyErr_Occurred()) SWIG_fail;
11822 }
11823 {
11824 resultobj = SWIG_From_int((int)(result));
11825 }
11826 return resultobj;
11827 fail:
11828 return NULL;
11829 }
11830
11831
11832 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11833 PyObject *resultobj;
11834 wxJoystick *arg1 = (wxJoystick *) 0 ;
11835 int result;
11836 PyObject * obj0 = 0 ;
11837 char *kwnames[] = {
11838 (char *) "self", NULL
11839 };
11840
11841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11843 if (SWIG_arg_fail(1)) SWIG_fail;
11844 {
11845 PyThreadState* __tstate = wxPyBeginAllowThreads();
11846 result = (int)(arg1)->GetUPosition();
11847
11848 wxPyEndAllowThreads(__tstate);
11849 if (PyErr_Occurred()) SWIG_fail;
11850 }
11851 {
11852 resultobj = SWIG_From_int((int)(result));
11853 }
11854 return resultobj;
11855 fail:
11856 return NULL;
11857 }
11858
11859
11860 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11861 PyObject *resultobj;
11862 wxJoystick *arg1 = (wxJoystick *) 0 ;
11863 int result;
11864 PyObject * obj0 = 0 ;
11865 char *kwnames[] = {
11866 (char *) "self", NULL
11867 };
11868
11869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11871 if (SWIG_arg_fail(1)) SWIG_fail;
11872 {
11873 PyThreadState* __tstate = wxPyBeginAllowThreads();
11874 result = (int)(arg1)->GetVPosition();
11875
11876 wxPyEndAllowThreads(__tstate);
11877 if (PyErr_Occurred()) SWIG_fail;
11878 }
11879 {
11880 resultobj = SWIG_From_int((int)(result));
11881 }
11882 return resultobj;
11883 fail:
11884 return NULL;
11885 }
11886
11887
11888 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11889 PyObject *resultobj;
11890 wxJoystick *arg1 = (wxJoystick *) 0 ;
11891 int result;
11892 PyObject * obj0 = 0 ;
11893 char *kwnames[] = {
11894 (char *) "self", NULL
11895 };
11896
11897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11899 if (SWIG_arg_fail(1)) SWIG_fail;
11900 {
11901 PyThreadState* __tstate = wxPyBeginAllowThreads();
11902 result = (int)(arg1)->GetMovementThreshold();
11903
11904 wxPyEndAllowThreads(__tstate);
11905 if (PyErr_Occurred()) SWIG_fail;
11906 }
11907 {
11908 resultobj = SWIG_From_int((int)(result));
11909 }
11910 return resultobj;
11911 fail:
11912 return NULL;
11913 }
11914
11915
11916 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11917 PyObject *resultobj;
11918 wxJoystick *arg1 = (wxJoystick *) 0 ;
11919 int arg2 ;
11920 PyObject * obj0 = 0 ;
11921 PyObject * obj1 = 0 ;
11922 char *kwnames[] = {
11923 (char *) "self",(char *) "threshold", NULL
11924 };
11925
11926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11928 if (SWIG_arg_fail(1)) SWIG_fail;
11929 {
11930 arg2 = (int)(SWIG_As_int(obj1));
11931 if (SWIG_arg_fail(2)) SWIG_fail;
11932 }
11933 {
11934 PyThreadState* __tstate = wxPyBeginAllowThreads();
11935 (arg1)->SetMovementThreshold(arg2);
11936
11937 wxPyEndAllowThreads(__tstate);
11938 if (PyErr_Occurred()) SWIG_fail;
11939 }
11940 Py_INCREF(Py_None); resultobj = Py_None;
11941 return resultobj;
11942 fail:
11943 return NULL;
11944 }
11945
11946
11947 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11948 PyObject *resultobj;
11949 wxJoystick *arg1 = (wxJoystick *) 0 ;
11950 bool result;
11951 PyObject * obj0 = 0 ;
11952 char *kwnames[] = {
11953 (char *) "self", NULL
11954 };
11955
11956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11958 if (SWIG_arg_fail(1)) SWIG_fail;
11959 {
11960 PyThreadState* __tstate = wxPyBeginAllowThreads();
11961 result = (bool)(arg1)->IsOk();
11962
11963 wxPyEndAllowThreads(__tstate);
11964 if (PyErr_Occurred()) SWIG_fail;
11965 }
11966 {
11967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11968 }
11969 return resultobj;
11970 fail:
11971 return NULL;
11972 }
11973
11974
11975 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11976 PyObject *resultobj;
11977 wxJoystick *arg1 = (wxJoystick *) 0 ;
11978 int result;
11979 PyObject * obj0 = 0 ;
11980 char *kwnames[] = {
11981 (char *) "self", NULL
11982 };
11983
11984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11986 if (SWIG_arg_fail(1)) SWIG_fail;
11987 {
11988 PyThreadState* __tstate = wxPyBeginAllowThreads();
11989 result = (int)(arg1)->GetNumberJoysticks();
11990
11991 wxPyEndAllowThreads(__tstate);
11992 if (PyErr_Occurred()) SWIG_fail;
11993 }
11994 {
11995 resultobj = SWIG_From_int((int)(result));
11996 }
11997 return resultobj;
11998 fail:
11999 return NULL;
12000 }
12001
12002
12003 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12004 PyObject *resultobj;
12005 wxJoystick *arg1 = (wxJoystick *) 0 ;
12006 int result;
12007 PyObject * obj0 = 0 ;
12008 char *kwnames[] = {
12009 (char *) "self", NULL
12010 };
12011
12012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12014 if (SWIG_arg_fail(1)) SWIG_fail;
12015 {
12016 PyThreadState* __tstate = wxPyBeginAllowThreads();
12017 result = (int)(arg1)->GetManufacturerId();
12018
12019 wxPyEndAllowThreads(__tstate);
12020 if (PyErr_Occurred()) SWIG_fail;
12021 }
12022 {
12023 resultobj = SWIG_From_int((int)(result));
12024 }
12025 return resultobj;
12026 fail:
12027 return NULL;
12028 }
12029
12030
12031 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12032 PyObject *resultobj;
12033 wxJoystick *arg1 = (wxJoystick *) 0 ;
12034 int result;
12035 PyObject * obj0 = 0 ;
12036 char *kwnames[] = {
12037 (char *) "self", NULL
12038 };
12039
12040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12042 if (SWIG_arg_fail(1)) SWIG_fail;
12043 {
12044 PyThreadState* __tstate = wxPyBeginAllowThreads();
12045 result = (int)(arg1)->GetProductId();
12046
12047 wxPyEndAllowThreads(__tstate);
12048 if (PyErr_Occurred()) SWIG_fail;
12049 }
12050 {
12051 resultobj = SWIG_From_int((int)(result));
12052 }
12053 return resultobj;
12054 fail:
12055 return NULL;
12056 }
12057
12058
12059 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12060 PyObject *resultobj;
12061 wxJoystick *arg1 = (wxJoystick *) 0 ;
12062 wxString result;
12063 PyObject * obj0 = 0 ;
12064 char *kwnames[] = {
12065 (char *) "self", NULL
12066 };
12067
12068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12070 if (SWIG_arg_fail(1)) SWIG_fail;
12071 {
12072 PyThreadState* __tstate = wxPyBeginAllowThreads();
12073 result = (arg1)->GetProductName();
12074
12075 wxPyEndAllowThreads(__tstate);
12076 if (PyErr_Occurred()) SWIG_fail;
12077 }
12078 {
12079 #if wxUSE_UNICODE
12080 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12081 #else
12082 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12083 #endif
12084 }
12085 return resultobj;
12086 fail:
12087 return NULL;
12088 }
12089
12090
12091 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12092 PyObject *resultobj;
12093 wxJoystick *arg1 = (wxJoystick *) 0 ;
12094 int result;
12095 PyObject * obj0 = 0 ;
12096 char *kwnames[] = {
12097 (char *) "self", NULL
12098 };
12099
12100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12102 if (SWIG_arg_fail(1)) SWIG_fail;
12103 {
12104 PyThreadState* __tstate = wxPyBeginAllowThreads();
12105 result = (int)(arg1)->GetXMin();
12106
12107 wxPyEndAllowThreads(__tstate);
12108 if (PyErr_Occurred()) SWIG_fail;
12109 }
12110 {
12111 resultobj = SWIG_From_int((int)(result));
12112 }
12113 return resultobj;
12114 fail:
12115 return NULL;
12116 }
12117
12118
12119 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12120 PyObject *resultobj;
12121 wxJoystick *arg1 = (wxJoystick *) 0 ;
12122 int result;
12123 PyObject * obj0 = 0 ;
12124 char *kwnames[] = {
12125 (char *) "self", NULL
12126 };
12127
12128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12130 if (SWIG_arg_fail(1)) SWIG_fail;
12131 {
12132 PyThreadState* __tstate = wxPyBeginAllowThreads();
12133 result = (int)(arg1)->GetYMin();
12134
12135 wxPyEndAllowThreads(__tstate);
12136 if (PyErr_Occurred()) SWIG_fail;
12137 }
12138 {
12139 resultobj = SWIG_From_int((int)(result));
12140 }
12141 return resultobj;
12142 fail:
12143 return NULL;
12144 }
12145
12146
12147 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12148 PyObject *resultobj;
12149 wxJoystick *arg1 = (wxJoystick *) 0 ;
12150 int result;
12151 PyObject * obj0 = 0 ;
12152 char *kwnames[] = {
12153 (char *) "self", NULL
12154 };
12155
12156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12158 if (SWIG_arg_fail(1)) SWIG_fail;
12159 {
12160 PyThreadState* __tstate = wxPyBeginAllowThreads();
12161 result = (int)(arg1)->GetZMin();
12162
12163 wxPyEndAllowThreads(__tstate);
12164 if (PyErr_Occurred()) SWIG_fail;
12165 }
12166 {
12167 resultobj = SWIG_From_int((int)(result));
12168 }
12169 return resultobj;
12170 fail:
12171 return NULL;
12172 }
12173
12174
12175 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12176 PyObject *resultobj;
12177 wxJoystick *arg1 = (wxJoystick *) 0 ;
12178 int result;
12179 PyObject * obj0 = 0 ;
12180 char *kwnames[] = {
12181 (char *) "self", NULL
12182 };
12183
12184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12186 if (SWIG_arg_fail(1)) SWIG_fail;
12187 {
12188 PyThreadState* __tstate = wxPyBeginAllowThreads();
12189 result = (int)(arg1)->GetXMax();
12190
12191 wxPyEndAllowThreads(__tstate);
12192 if (PyErr_Occurred()) SWIG_fail;
12193 }
12194 {
12195 resultobj = SWIG_From_int((int)(result));
12196 }
12197 return resultobj;
12198 fail:
12199 return NULL;
12200 }
12201
12202
12203 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12204 PyObject *resultobj;
12205 wxJoystick *arg1 = (wxJoystick *) 0 ;
12206 int result;
12207 PyObject * obj0 = 0 ;
12208 char *kwnames[] = {
12209 (char *) "self", NULL
12210 };
12211
12212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12214 if (SWIG_arg_fail(1)) SWIG_fail;
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 result = (int)(arg1)->GetYMax();
12218
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 {
12223 resultobj = SWIG_From_int((int)(result));
12224 }
12225 return resultobj;
12226 fail:
12227 return NULL;
12228 }
12229
12230
12231 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12232 PyObject *resultobj;
12233 wxJoystick *arg1 = (wxJoystick *) 0 ;
12234 int result;
12235 PyObject * obj0 = 0 ;
12236 char *kwnames[] = {
12237 (char *) "self", NULL
12238 };
12239
12240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12242 if (SWIG_arg_fail(1)) SWIG_fail;
12243 {
12244 PyThreadState* __tstate = wxPyBeginAllowThreads();
12245 result = (int)(arg1)->GetZMax();
12246
12247 wxPyEndAllowThreads(__tstate);
12248 if (PyErr_Occurred()) SWIG_fail;
12249 }
12250 {
12251 resultobj = SWIG_From_int((int)(result));
12252 }
12253 return resultobj;
12254 fail:
12255 return NULL;
12256 }
12257
12258
12259 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12260 PyObject *resultobj;
12261 wxJoystick *arg1 = (wxJoystick *) 0 ;
12262 int result;
12263 PyObject * obj0 = 0 ;
12264 char *kwnames[] = {
12265 (char *) "self", NULL
12266 };
12267
12268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12270 if (SWIG_arg_fail(1)) SWIG_fail;
12271 {
12272 PyThreadState* __tstate = wxPyBeginAllowThreads();
12273 result = (int)(arg1)->GetNumberButtons();
12274
12275 wxPyEndAllowThreads(__tstate);
12276 if (PyErr_Occurred()) SWIG_fail;
12277 }
12278 {
12279 resultobj = SWIG_From_int((int)(result));
12280 }
12281 return resultobj;
12282 fail:
12283 return NULL;
12284 }
12285
12286
12287 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12288 PyObject *resultobj;
12289 wxJoystick *arg1 = (wxJoystick *) 0 ;
12290 int result;
12291 PyObject * obj0 = 0 ;
12292 char *kwnames[] = {
12293 (char *) "self", NULL
12294 };
12295
12296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12298 if (SWIG_arg_fail(1)) SWIG_fail;
12299 {
12300 PyThreadState* __tstate = wxPyBeginAllowThreads();
12301 result = (int)(arg1)->GetNumberAxes();
12302
12303 wxPyEndAllowThreads(__tstate);
12304 if (PyErr_Occurred()) SWIG_fail;
12305 }
12306 {
12307 resultobj = SWIG_From_int((int)(result));
12308 }
12309 return resultobj;
12310 fail:
12311 return NULL;
12312 }
12313
12314
12315 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12316 PyObject *resultobj;
12317 wxJoystick *arg1 = (wxJoystick *) 0 ;
12318 int result;
12319 PyObject * obj0 = 0 ;
12320 char *kwnames[] = {
12321 (char *) "self", NULL
12322 };
12323
12324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12326 if (SWIG_arg_fail(1)) SWIG_fail;
12327 {
12328 PyThreadState* __tstate = wxPyBeginAllowThreads();
12329 result = (int)(arg1)->GetMaxButtons();
12330
12331 wxPyEndAllowThreads(__tstate);
12332 if (PyErr_Occurred()) SWIG_fail;
12333 }
12334 {
12335 resultobj = SWIG_From_int((int)(result));
12336 }
12337 return resultobj;
12338 fail:
12339 return NULL;
12340 }
12341
12342
12343 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12344 PyObject *resultobj;
12345 wxJoystick *arg1 = (wxJoystick *) 0 ;
12346 int result;
12347 PyObject * obj0 = 0 ;
12348 char *kwnames[] = {
12349 (char *) "self", NULL
12350 };
12351
12352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12354 if (SWIG_arg_fail(1)) SWIG_fail;
12355 {
12356 PyThreadState* __tstate = wxPyBeginAllowThreads();
12357 result = (int)(arg1)->GetMaxAxes();
12358
12359 wxPyEndAllowThreads(__tstate);
12360 if (PyErr_Occurred()) SWIG_fail;
12361 }
12362 {
12363 resultobj = SWIG_From_int((int)(result));
12364 }
12365 return resultobj;
12366 fail:
12367 return NULL;
12368 }
12369
12370
12371 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12372 PyObject *resultobj;
12373 wxJoystick *arg1 = (wxJoystick *) 0 ;
12374 int result;
12375 PyObject * obj0 = 0 ;
12376 char *kwnames[] = {
12377 (char *) "self", NULL
12378 };
12379
12380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12382 if (SWIG_arg_fail(1)) SWIG_fail;
12383 {
12384 PyThreadState* __tstate = wxPyBeginAllowThreads();
12385 result = (int)(arg1)->GetPollingMin();
12386
12387 wxPyEndAllowThreads(__tstate);
12388 if (PyErr_Occurred()) SWIG_fail;
12389 }
12390 {
12391 resultobj = SWIG_From_int((int)(result));
12392 }
12393 return resultobj;
12394 fail:
12395 return NULL;
12396 }
12397
12398
12399 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12400 PyObject *resultobj;
12401 wxJoystick *arg1 = (wxJoystick *) 0 ;
12402 int result;
12403 PyObject * obj0 = 0 ;
12404 char *kwnames[] = {
12405 (char *) "self", NULL
12406 };
12407
12408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12410 if (SWIG_arg_fail(1)) SWIG_fail;
12411 {
12412 PyThreadState* __tstate = wxPyBeginAllowThreads();
12413 result = (int)(arg1)->GetPollingMax();
12414
12415 wxPyEndAllowThreads(__tstate);
12416 if (PyErr_Occurred()) SWIG_fail;
12417 }
12418 {
12419 resultobj = SWIG_From_int((int)(result));
12420 }
12421 return resultobj;
12422 fail:
12423 return NULL;
12424 }
12425
12426
12427 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12428 PyObject *resultobj;
12429 wxJoystick *arg1 = (wxJoystick *) 0 ;
12430 int result;
12431 PyObject * obj0 = 0 ;
12432 char *kwnames[] = {
12433 (char *) "self", NULL
12434 };
12435
12436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12438 if (SWIG_arg_fail(1)) SWIG_fail;
12439 {
12440 PyThreadState* __tstate = wxPyBeginAllowThreads();
12441 result = (int)(arg1)->GetRudderMin();
12442
12443 wxPyEndAllowThreads(__tstate);
12444 if (PyErr_Occurred()) SWIG_fail;
12445 }
12446 {
12447 resultobj = SWIG_From_int((int)(result));
12448 }
12449 return resultobj;
12450 fail:
12451 return NULL;
12452 }
12453
12454
12455 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12456 PyObject *resultobj;
12457 wxJoystick *arg1 = (wxJoystick *) 0 ;
12458 int result;
12459 PyObject * obj0 = 0 ;
12460 char *kwnames[] = {
12461 (char *) "self", NULL
12462 };
12463
12464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12466 if (SWIG_arg_fail(1)) SWIG_fail;
12467 {
12468 PyThreadState* __tstate = wxPyBeginAllowThreads();
12469 result = (int)(arg1)->GetRudderMax();
12470
12471 wxPyEndAllowThreads(__tstate);
12472 if (PyErr_Occurred()) SWIG_fail;
12473 }
12474 {
12475 resultobj = SWIG_From_int((int)(result));
12476 }
12477 return resultobj;
12478 fail:
12479 return NULL;
12480 }
12481
12482
12483 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12484 PyObject *resultobj;
12485 wxJoystick *arg1 = (wxJoystick *) 0 ;
12486 int result;
12487 PyObject * obj0 = 0 ;
12488 char *kwnames[] = {
12489 (char *) "self", NULL
12490 };
12491
12492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12494 if (SWIG_arg_fail(1)) SWIG_fail;
12495 {
12496 PyThreadState* __tstate = wxPyBeginAllowThreads();
12497 result = (int)(arg1)->GetUMin();
12498
12499 wxPyEndAllowThreads(__tstate);
12500 if (PyErr_Occurred()) SWIG_fail;
12501 }
12502 {
12503 resultobj = SWIG_From_int((int)(result));
12504 }
12505 return resultobj;
12506 fail:
12507 return NULL;
12508 }
12509
12510
12511 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12512 PyObject *resultobj;
12513 wxJoystick *arg1 = (wxJoystick *) 0 ;
12514 int result;
12515 PyObject * obj0 = 0 ;
12516 char *kwnames[] = {
12517 (char *) "self", NULL
12518 };
12519
12520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12522 if (SWIG_arg_fail(1)) SWIG_fail;
12523 {
12524 PyThreadState* __tstate = wxPyBeginAllowThreads();
12525 result = (int)(arg1)->GetUMax();
12526
12527 wxPyEndAllowThreads(__tstate);
12528 if (PyErr_Occurred()) SWIG_fail;
12529 }
12530 {
12531 resultobj = SWIG_From_int((int)(result));
12532 }
12533 return resultobj;
12534 fail:
12535 return NULL;
12536 }
12537
12538
12539 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12540 PyObject *resultobj;
12541 wxJoystick *arg1 = (wxJoystick *) 0 ;
12542 int result;
12543 PyObject * obj0 = 0 ;
12544 char *kwnames[] = {
12545 (char *) "self", NULL
12546 };
12547
12548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12550 if (SWIG_arg_fail(1)) SWIG_fail;
12551 {
12552 PyThreadState* __tstate = wxPyBeginAllowThreads();
12553 result = (int)(arg1)->GetVMin();
12554
12555 wxPyEndAllowThreads(__tstate);
12556 if (PyErr_Occurred()) SWIG_fail;
12557 }
12558 {
12559 resultobj = SWIG_From_int((int)(result));
12560 }
12561 return resultobj;
12562 fail:
12563 return NULL;
12564 }
12565
12566
12567 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12568 PyObject *resultobj;
12569 wxJoystick *arg1 = (wxJoystick *) 0 ;
12570 int result;
12571 PyObject * obj0 = 0 ;
12572 char *kwnames[] = {
12573 (char *) "self", NULL
12574 };
12575
12576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12578 if (SWIG_arg_fail(1)) SWIG_fail;
12579 {
12580 PyThreadState* __tstate = wxPyBeginAllowThreads();
12581 result = (int)(arg1)->GetVMax();
12582
12583 wxPyEndAllowThreads(__tstate);
12584 if (PyErr_Occurred()) SWIG_fail;
12585 }
12586 {
12587 resultobj = SWIG_From_int((int)(result));
12588 }
12589 return resultobj;
12590 fail:
12591 return NULL;
12592 }
12593
12594
12595 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12596 PyObject *resultobj;
12597 wxJoystick *arg1 = (wxJoystick *) 0 ;
12598 bool result;
12599 PyObject * obj0 = 0 ;
12600 char *kwnames[] = {
12601 (char *) "self", NULL
12602 };
12603
12604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12606 if (SWIG_arg_fail(1)) SWIG_fail;
12607 {
12608 PyThreadState* __tstate = wxPyBeginAllowThreads();
12609 result = (bool)(arg1)->HasRudder();
12610
12611 wxPyEndAllowThreads(__tstate);
12612 if (PyErr_Occurred()) SWIG_fail;
12613 }
12614 {
12615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12616 }
12617 return resultobj;
12618 fail:
12619 return NULL;
12620 }
12621
12622
12623 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12624 PyObject *resultobj;
12625 wxJoystick *arg1 = (wxJoystick *) 0 ;
12626 bool result;
12627 PyObject * obj0 = 0 ;
12628 char *kwnames[] = {
12629 (char *) "self", NULL
12630 };
12631
12632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12634 if (SWIG_arg_fail(1)) SWIG_fail;
12635 {
12636 PyThreadState* __tstate = wxPyBeginAllowThreads();
12637 result = (bool)(arg1)->HasZ();
12638
12639 wxPyEndAllowThreads(__tstate);
12640 if (PyErr_Occurred()) SWIG_fail;
12641 }
12642 {
12643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12644 }
12645 return resultobj;
12646 fail:
12647 return NULL;
12648 }
12649
12650
12651 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12652 PyObject *resultobj;
12653 wxJoystick *arg1 = (wxJoystick *) 0 ;
12654 bool result;
12655 PyObject * obj0 = 0 ;
12656 char *kwnames[] = {
12657 (char *) "self", NULL
12658 };
12659
12660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12662 if (SWIG_arg_fail(1)) SWIG_fail;
12663 {
12664 PyThreadState* __tstate = wxPyBeginAllowThreads();
12665 result = (bool)(arg1)->HasU();
12666
12667 wxPyEndAllowThreads(__tstate);
12668 if (PyErr_Occurred()) SWIG_fail;
12669 }
12670 {
12671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12672 }
12673 return resultobj;
12674 fail:
12675 return NULL;
12676 }
12677
12678
12679 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12680 PyObject *resultobj;
12681 wxJoystick *arg1 = (wxJoystick *) 0 ;
12682 bool result;
12683 PyObject * obj0 = 0 ;
12684 char *kwnames[] = {
12685 (char *) "self", NULL
12686 };
12687
12688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12690 if (SWIG_arg_fail(1)) SWIG_fail;
12691 {
12692 PyThreadState* __tstate = wxPyBeginAllowThreads();
12693 result = (bool)(arg1)->HasV();
12694
12695 wxPyEndAllowThreads(__tstate);
12696 if (PyErr_Occurred()) SWIG_fail;
12697 }
12698 {
12699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12700 }
12701 return resultobj;
12702 fail:
12703 return NULL;
12704 }
12705
12706
12707 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12708 PyObject *resultobj;
12709 wxJoystick *arg1 = (wxJoystick *) 0 ;
12710 bool result;
12711 PyObject * obj0 = 0 ;
12712 char *kwnames[] = {
12713 (char *) "self", NULL
12714 };
12715
12716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12718 if (SWIG_arg_fail(1)) SWIG_fail;
12719 {
12720 PyThreadState* __tstate = wxPyBeginAllowThreads();
12721 result = (bool)(arg1)->HasPOV();
12722
12723 wxPyEndAllowThreads(__tstate);
12724 if (PyErr_Occurred()) SWIG_fail;
12725 }
12726 {
12727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12728 }
12729 return resultobj;
12730 fail:
12731 return NULL;
12732 }
12733
12734
12735 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12736 PyObject *resultobj;
12737 wxJoystick *arg1 = (wxJoystick *) 0 ;
12738 bool result;
12739 PyObject * obj0 = 0 ;
12740 char *kwnames[] = {
12741 (char *) "self", NULL
12742 };
12743
12744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12746 if (SWIG_arg_fail(1)) SWIG_fail;
12747 {
12748 PyThreadState* __tstate = wxPyBeginAllowThreads();
12749 result = (bool)(arg1)->HasPOV4Dir();
12750
12751 wxPyEndAllowThreads(__tstate);
12752 if (PyErr_Occurred()) SWIG_fail;
12753 }
12754 {
12755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12756 }
12757 return resultobj;
12758 fail:
12759 return NULL;
12760 }
12761
12762
12763 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12764 PyObject *resultobj;
12765 wxJoystick *arg1 = (wxJoystick *) 0 ;
12766 bool result;
12767 PyObject * obj0 = 0 ;
12768 char *kwnames[] = {
12769 (char *) "self", NULL
12770 };
12771
12772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12774 if (SWIG_arg_fail(1)) SWIG_fail;
12775 {
12776 PyThreadState* __tstate = wxPyBeginAllowThreads();
12777 result = (bool)(arg1)->HasPOVCTS();
12778
12779 wxPyEndAllowThreads(__tstate);
12780 if (PyErr_Occurred()) SWIG_fail;
12781 }
12782 {
12783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12784 }
12785 return resultobj;
12786 fail:
12787 return NULL;
12788 }
12789
12790
12791 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12792 PyObject *resultobj;
12793 wxJoystick *arg1 = (wxJoystick *) 0 ;
12794 wxWindow *arg2 = (wxWindow *) 0 ;
12795 int arg3 = (int) 0 ;
12796 bool result;
12797 PyObject * obj0 = 0 ;
12798 PyObject * obj1 = 0 ;
12799 PyObject * obj2 = 0 ;
12800 char *kwnames[] = {
12801 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12802 };
12803
12804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12806 if (SWIG_arg_fail(1)) SWIG_fail;
12807 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12808 if (SWIG_arg_fail(2)) SWIG_fail;
12809 if (obj2) {
12810 {
12811 arg3 = (int)(SWIG_As_int(obj2));
12812 if (SWIG_arg_fail(3)) SWIG_fail;
12813 }
12814 }
12815 {
12816 PyThreadState* __tstate = wxPyBeginAllowThreads();
12817 result = (bool)(arg1)->SetCapture(arg2,arg3);
12818
12819 wxPyEndAllowThreads(__tstate);
12820 if (PyErr_Occurred()) SWIG_fail;
12821 }
12822 {
12823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12824 }
12825 return resultobj;
12826 fail:
12827 return NULL;
12828 }
12829
12830
12831 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12832 PyObject *resultobj;
12833 wxJoystick *arg1 = (wxJoystick *) 0 ;
12834 bool result;
12835 PyObject * obj0 = 0 ;
12836 char *kwnames[] = {
12837 (char *) "self", NULL
12838 };
12839
12840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12842 if (SWIG_arg_fail(1)) SWIG_fail;
12843 {
12844 PyThreadState* __tstate = wxPyBeginAllowThreads();
12845 result = (bool)(arg1)->ReleaseCapture();
12846
12847 wxPyEndAllowThreads(__tstate);
12848 if (PyErr_Occurred()) SWIG_fail;
12849 }
12850 {
12851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12852 }
12853 return resultobj;
12854 fail:
12855 return NULL;
12856 }
12857
12858
12859 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12860 PyObject *obj;
12861 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12862 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12863 Py_INCREF(obj);
12864 return Py_BuildValue((char *)"");
12865 }
12866 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12867 PyObject *resultobj;
12868 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12869 int arg2 = (int) 0 ;
12870 int arg3 = (int) wxJOYSTICK1 ;
12871 int arg4 = (int) 0 ;
12872 wxJoystickEvent *result;
12873 PyObject * obj0 = 0 ;
12874 PyObject * obj1 = 0 ;
12875 PyObject * obj2 = 0 ;
12876 PyObject * obj3 = 0 ;
12877 char *kwnames[] = {
12878 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12879 };
12880
12881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12882 if (obj0) {
12883 {
12884 arg1 = (wxEventType)(SWIG_As_int(obj0));
12885 if (SWIG_arg_fail(1)) SWIG_fail;
12886 }
12887 }
12888 if (obj1) {
12889 {
12890 arg2 = (int)(SWIG_As_int(obj1));
12891 if (SWIG_arg_fail(2)) SWIG_fail;
12892 }
12893 }
12894 if (obj2) {
12895 {
12896 arg3 = (int)(SWIG_As_int(obj2));
12897 if (SWIG_arg_fail(3)) SWIG_fail;
12898 }
12899 }
12900 if (obj3) {
12901 {
12902 arg4 = (int)(SWIG_As_int(obj3));
12903 if (SWIG_arg_fail(4)) SWIG_fail;
12904 }
12905 }
12906 {
12907 PyThreadState* __tstate = wxPyBeginAllowThreads();
12908 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12909
12910 wxPyEndAllowThreads(__tstate);
12911 if (PyErr_Occurred()) SWIG_fail;
12912 }
12913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12914 return resultobj;
12915 fail:
12916 return NULL;
12917 }
12918
12919
12920 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12921 PyObject *resultobj;
12922 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12923 wxPoint result;
12924 PyObject * obj0 = 0 ;
12925 char *kwnames[] = {
12926 (char *) "self", NULL
12927 };
12928
12929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12931 if (SWIG_arg_fail(1)) SWIG_fail;
12932 {
12933 PyThreadState* __tstate = wxPyBeginAllowThreads();
12934 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12935
12936 wxPyEndAllowThreads(__tstate);
12937 if (PyErr_Occurred()) SWIG_fail;
12938 }
12939 {
12940 wxPoint * resultptr;
12941 resultptr = new wxPoint((wxPoint &)(result));
12942 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12943 }
12944 return resultobj;
12945 fail:
12946 return NULL;
12947 }
12948
12949
12950 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12951 PyObject *resultobj;
12952 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12953 int result;
12954 PyObject * obj0 = 0 ;
12955 char *kwnames[] = {
12956 (char *) "self", NULL
12957 };
12958
12959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12961 if (SWIG_arg_fail(1)) SWIG_fail;
12962 {
12963 PyThreadState* __tstate = wxPyBeginAllowThreads();
12964 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12965
12966 wxPyEndAllowThreads(__tstate);
12967 if (PyErr_Occurred()) SWIG_fail;
12968 }
12969 {
12970 resultobj = SWIG_From_int((int)(result));
12971 }
12972 return resultobj;
12973 fail:
12974 return NULL;
12975 }
12976
12977
12978 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12979 PyObject *resultobj;
12980 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12981 int result;
12982 PyObject * obj0 = 0 ;
12983 char *kwnames[] = {
12984 (char *) "self", NULL
12985 };
12986
12987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12989 if (SWIG_arg_fail(1)) SWIG_fail;
12990 {
12991 PyThreadState* __tstate = wxPyBeginAllowThreads();
12992 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12993
12994 wxPyEndAllowThreads(__tstate);
12995 if (PyErr_Occurred()) SWIG_fail;
12996 }
12997 {
12998 resultobj = SWIG_From_int((int)(result));
12999 }
13000 return resultobj;
13001 fail:
13002 return NULL;
13003 }
13004
13005
13006 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13007 PyObject *resultobj;
13008 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13009 int result;
13010 PyObject * obj0 = 0 ;
13011 char *kwnames[] = {
13012 (char *) "self", NULL
13013 };
13014
13015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13017 if (SWIG_arg_fail(1)) SWIG_fail;
13018 {
13019 PyThreadState* __tstate = wxPyBeginAllowThreads();
13020 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13021
13022 wxPyEndAllowThreads(__tstate);
13023 if (PyErr_Occurred()) SWIG_fail;
13024 }
13025 {
13026 resultobj = SWIG_From_int((int)(result));
13027 }
13028 return resultobj;
13029 fail:
13030 return NULL;
13031 }
13032
13033
13034 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13035 PyObject *resultobj;
13036 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13037 int result;
13038 PyObject * obj0 = 0 ;
13039 char *kwnames[] = {
13040 (char *) "self", NULL
13041 };
13042
13043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13045 if (SWIG_arg_fail(1)) SWIG_fail;
13046 {
13047 PyThreadState* __tstate = wxPyBeginAllowThreads();
13048 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13049
13050 wxPyEndAllowThreads(__tstate);
13051 if (PyErr_Occurred()) SWIG_fail;
13052 }
13053 {
13054 resultobj = SWIG_From_int((int)(result));
13055 }
13056 return resultobj;
13057 fail:
13058 return NULL;
13059 }
13060
13061
13062 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13063 PyObject *resultobj;
13064 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13065 int arg2 ;
13066 PyObject * obj0 = 0 ;
13067 PyObject * obj1 = 0 ;
13068 char *kwnames[] = {
13069 (char *) "self",(char *) "stick", NULL
13070 };
13071
13072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13074 if (SWIG_arg_fail(1)) SWIG_fail;
13075 {
13076 arg2 = (int)(SWIG_As_int(obj1));
13077 if (SWIG_arg_fail(2)) SWIG_fail;
13078 }
13079 {
13080 PyThreadState* __tstate = wxPyBeginAllowThreads();
13081 (arg1)->SetJoystick(arg2);
13082
13083 wxPyEndAllowThreads(__tstate);
13084 if (PyErr_Occurred()) SWIG_fail;
13085 }
13086 Py_INCREF(Py_None); resultobj = Py_None;
13087 return resultobj;
13088 fail:
13089 return NULL;
13090 }
13091
13092
13093 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13094 PyObject *resultobj;
13095 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13096 int arg2 ;
13097 PyObject * obj0 = 0 ;
13098 PyObject * obj1 = 0 ;
13099 char *kwnames[] = {
13100 (char *) "self",(char *) "state", NULL
13101 };
13102
13103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13105 if (SWIG_arg_fail(1)) SWIG_fail;
13106 {
13107 arg2 = (int)(SWIG_As_int(obj1));
13108 if (SWIG_arg_fail(2)) SWIG_fail;
13109 }
13110 {
13111 PyThreadState* __tstate = wxPyBeginAllowThreads();
13112 (arg1)->SetButtonState(arg2);
13113
13114 wxPyEndAllowThreads(__tstate);
13115 if (PyErr_Occurred()) SWIG_fail;
13116 }
13117 Py_INCREF(Py_None); resultobj = Py_None;
13118 return resultobj;
13119 fail:
13120 return NULL;
13121 }
13122
13123
13124 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13125 PyObject *resultobj;
13126 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13127 int arg2 ;
13128 PyObject * obj0 = 0 ;
13129 PyObject * obj1 = 0 ;
13130 char *kwnames[] = {
13131 (char *) "self",(char *) "change", NULL
13132 };
13133
13134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13136 if (SWIG_arg_fail(1)) SWIG_fail;
13137 {
13138 arg2 = (int)(SWIG_As_int(obj1));
13139 if (SWIG_arg_fail(2)) SWIG_fail;
13140 }
13141 {
13142 PyThreadState* __tstate = wxPyBeginAllowThreads();
13143 (arg1)->SetButtonChange(arg2);
13144
13145 wxPyEndAllowThreads(__tstate);
13146 if (PyErr_Occurred()) SWIG_fail;
13147 }
13148 Py_INCREF(Py_None); resultobj = Py_None;
13149 return resultobj;
13150 fail:
13151 return NULL;
13152 }
13153
13154
13155 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13156 PyObject *resultobj;
13157 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13158 wxPoint *arg2 = 0 ;
13159 wxPoint temp2 ;
13160 PyObject * obj0 = 0 ;
13161 PyObject * obj1 = 0 ;
13162 char *kwnames[] = {
13163 (char *) "self",(char *) "pos", NULL
13164 };
13165
13166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13168 if (SWIG_arg_fail(1)) SWIG_fail;
13169 {
13170 arg2 = &temp2;
13171 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13172 }
13173 {
13174 PyThreadState* __tstate = wxPyBeginAllowThreads();
13175 (arg1)->SetPosition((wxPoint const &)*arg2);
13176
13177 wxPyEndAllowThreads(__tstate);
13178 if (PyErr_Occurred()) SWIG_fail;
13179 }
13180 Py_INCREF(Py_None); resultobj = Py_None;
13181 return resultobj;
13182 fail:
13183 return NULL;
13184 }
13185
13186
13187 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13188 PyObject *resultobj;
13189 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13190 int arg2 ;
13191 PyObject * obj0 = 0 ;
13192 PyObject * obj1 = 0 ;
13193 char *kwnames[] = {
13194 (char *) "self",(char *) "zPos", NULL
13195 };
13196
13197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13199 if (SWIG_arg_fail(1)) SWIG_fail;
13200 {
13201 arg2 = (int)(SWIG_As_int(obj1));
13202 if (SWIG_arg_fail(2)) SWIG_fail;
13203 }
13204 {
13205 PyThreadState* __tstate = wxPyBeginAllowThreads();
13206 (arg1)->SetZPosition(arg2);
13207
13208 wxPyEndAllowThreads(__tstate);
13209 if (PyErr_Occurred()) SWIG_fail;
13210 }
13211 Py_INCREF(Py_None); resultobj = Py_None;
13212 return resultobj;
13213 fail:
13214 return NULL;
13215 }
13216
13217
13218 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13219 PyObject *resultobj;
13220 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13221 bool result;
13222 PyObject * obj0 = 0 ;
13223 char *kwnames[] = {
13224 (char *) "self", NULL
13225 };
13226
13227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13229 if (SWIG_arg_fail(1)) SWIG_fail;
13230 {
13231 PyThreadState* __tstate = wxPyBeginAllowThreads();
13232 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13233
13234 wxPyEndAllowThreads(__tstate);
13235 if (PyErr_Occurred()) SWIG_fail;
13236 }
13237 {
13238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13239 }
13240 return resultobj;
13241 fail:
13242 return NULL;
13243 }
13244
13245
13246 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13247 PyObject *resultobj;
13248 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13249 bool result;
13250 PyObject * obj0 = 0 ;
13251 char *kwnames[] = {
13252 (char *) "self", NULL
13253 };
13254
13255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13257 if (SWIG_arg_fail(1)) SWIG_fail;
13258 {
13259 PyThreadState* __tstate = wxPyBeginAllowThreads();
13260 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13261
13262 wxPyEndAllowThreads(__tstate);
13263 if (PyErr_Occurred()) SWIG_fail;
13264 }
13265 {
13266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13267 }
13268 return resultobj;
13269 fail:
13270 return NULL;
13271 }
13272
13273
13274 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13275 PyObject *resultobj;
13276 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13277 bool result;
13278 PyObject * obj0 = 0 ;
13279 char *kwnames[] = {
13280 (char *) "self", NULL
13281 };
13282
13283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13285 if (SWIG_arg_fail(1)) SWIG_fail;
13286 {
13287 PyThreadState* __tstate = wxPyBeginAllowThreads();
13288 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13289
13290 wxPyEndAllowThreads(__tstate);
13291 if (PyErr_Occurred()) SWIG_fail;
13292 }
13293 {
13294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13295 }
13296 return resultobj;
13297 fail:
13298 return NULL;
13299 }
13300
13301
13302 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13303 PyObject *resultobj;
13304 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13305 int arg2 = (int) wxJOY_BUTTON_ANY ;
13306 bool result;
13307 PyObject * obj0 = 0 ;
13308 PyObject * obj1 = 0 ;
13309 char *kwnames[] = {
13310 (char *) "self",(char *) "but", NULL
13311 };
13312
13313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13315 if (SWIG_arg_fail(1)) SWIG_fail;
13316 if (obj1) {
13317 {
13318 arg2 = (int)(SWIG_As_int(obj1));
13319 if (SWIG_arg_fail(2)) SWIG_fail;
13320 }
13321 }
13322 {
13323 PyThreadState* __tstate = wxPyBeginAllowThreads();
13324 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13325
13326 wxPyEndAllowThreads(__tstate);
13327 if (PyErr_Occurred()) SWIG_fail;
13328 }
13329 {
13330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13331 }
13332 return resultobj;
13333 fail:
13334 return NULL;
13335 }
13336
13337
13338 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13339 PyObject *resultobj;
13340 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13341 int arg2 = (int) wxJOY_BUTTON_ANY ;
13342 bool result;
13343 PyObject * obj0 = 0 ;
13344 PyObject * obj1 = 0 ;
13345 char *kwnames[] = {
13346 (char *) "self",(char *) "but", NULL
13347 };
13348
13349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13351 if (SWIG_arg_fail(1)) SWIG_fail;
13352 if (obj1) {
13353 {
13354 arg2 = (int)(SWIG_As_int(obj1));
13355 if (SWIG_arg_fail(2)) SWIG_fail;
13356 }
13357 }
13358 {
13359 PyThreadState* __tstate = wxPyBeginAllowThreads();
13360 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13361
13362 wxPyEndAllowThreads(__tstate);
13363 if (PyErr_Occurred()) SWIG_fail;
13364 }
13365 {
13366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13367 }
13368 return resultobj;
13369 fail:
13370 return NULL;
13371 }
13372
13373
13374 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13375 PyObject *resultobj;
13376 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13377 int arg2 = (int) wxJOY_BUTTON_ANY ;
13378 bool result;
13379 PyObject * obj0 = 0 ;
13380 PyObject * obj1 = 0 ;
13381 char *kwnames[] = {
13382 (char *) "self",(char *) "but", NULL
13383 };
13384
13385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13387 if (SWIG_arg_fail(1)) SWIG_fail;
13388 if (obj1) {
13389 {
13390 arg2 = (int)(SWIG_As_int(obj1));
13391 if (SWIG_arg_fail(2)) SWIG_fail;
13392 }
13393 }
13394 {
13395 PyThreadState* __tstate = wxPyBeginAllowThreads();
13396 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13397
13398 wxPyEndAllowThreads(__tstate);
13399 if (PyErr_Occurred()) SWIG_fail;
13400 }
13401 {
13402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13403 }
13404 return resultobj;
13405 fail:
13406 return NULL;
13407 }
13408
13409
13410 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13411 PyObject *obj;
13412 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13413 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13414 Py_INCREF(obj);
13415 return Py_BuildValue((char *)"");
13416 }
13417 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13418 PyObject *resultobj;
13419 wxString const &arg1_defvalue = wxPyEmptyString ;
13420 wxString *arg1 = (wxString *) &arg1_defvalue ;
13421 wxSound *result;
13422 bool temp1 = false ;
13423 PyObject * obj0 = 0 ;
13424 char *kwnames[] = {
13425 (char *) "fileName", NULL
13426 };
13427
13428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13429 if (obj0) {
13430 {
13431 arg1 = wxString_in_helper(obj0);
13432 if (arg1 == NULL) SWIG_fail;
13433 temp1 = true;
13434 }
13435 }
13436 {
13437 if (!wxPyCheckForApp()) SWIG_fail;
13438 PyThreadState* __tstate = wxPyBeginAllowThreads();
13439 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13440
13441 wxPyEndAllowThreads(__tstate);
13442 if (PyErr_Occurred()) SWIG_fail;
13443 }
13444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13445 {
13446 if (temp1)
13447 delete arg1;
13448 }
13449 return resultobj;
13450 fail:
13451 {
13452 if (temp1)
13453 delete arg1;
13454 }
13455 return NULL;
13456 }
13457
13458
13459 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13460 PyObject *resultobj;
13461 PyObject *arg1 = (PyObject *) 0 ;
13462 wxSound *result;
13463 PyObject * obj0 = 0 ;
13464 char *kwnames[] = {
13465 (char *) "data", NULL
13466 };
13467
13468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13469 arg1 = obj0;
13470 {
13471 if (!wxPyCheckForApp()) SWIG_fail;
13472 PyThreadState* __tstate = wxPyBeginAllowThreads();
13473 result = (wxSound *)new_wxSound(arg1);
13474
13475 wxPyEndAllowThreads(__tstate);
13476 if (PyErr_Occurred()) SWIG_fail;
13477 }
13478 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13479 return resultobj;
13480 fail:
13481 return NULL;
13482 }
13483
13484
13485 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13486 PyObject *resultobj;
13487 wxSound *arg1 = (wxSound *) 0 ;
13488 PyObject * obj0 = 0 ;
13489 char *kwnames[] = {
13490 (char *) "self", NULL
13491 };
13492
13493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13495 if (SWIG_arg_fail(1)) SWIG_fail;
13496 {
13497 PyThreadState* __tstate = wxPyBeginAllowThreads();
13498 delete arg1;
13499
13500 wxPyEndAllowThreads(__tstate);
13501 if (PyErr_Occurred()) SWIG_fail;
13502 }
13503 Py_INCREF(Py_None); resultobj = Py_None;
13504 return resultobj;
13505 fail:
13506 return NULL;
13507 }
13508
13509
13510 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13511 PyObject *resultobj;
13512 wxSound *arg1 = (wxSound *) 0 ;
13513 wxString *arg2 = 0 ;
13514 bool result;
13515 bool temp2 = false ;
13516 PyObject * obj0 = 0 ;
13517 PyObject * obj1 = 0 ;
13518 char *kwnames[] = {
13519 (char *) "self",(char *) "fileName", NULL
13520 };
13521
13522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13524 if (SWIG_arg_fail(1)) SWIG_fail;
13525 {
13526 arg2 = wxString_in_helper(obj1);
13527 if (arg2 == NULL) SWIG_fail;
13528 temp2 = true;
13529 }
13530 {
13531 PyThreadState* __tstate = wxPyBeginAllowThreads();
13532 result = (bool)(arg1)->Create((wxString const &)*arg2);
13533
13534 wxPyEndAllowThreads(__tstate);
13535 if (PyErr_Occurred()) SWIG_fail;
13536 }
13537 {
13538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13539 }
13540 {
13541 if (temp2)
13542 delete arg2;
13543 }
13544 return resultobj;
13545 fail:
13546 {
13547 if (temp2)
13548 delete arg2;
13549 }
13550 return NULL;
13551 }
13552
13553
13554 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13555 PyObject *resultobj;
13556 wxSound *arg1 = (wxSound *) 0 ;
13557 PyObject *arg2 = (PyObject *) 0 ;
13558 bool result;
13559 PyObject * obj0 = 0 ;
13560 PyObject * obj1 = 0 ;
13561 char *kwnames[] = {
13562 (char *) "self",(char *) "data", NULL
13563 };
13564
13565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13567 if (SWIG_arg_fail(1)) SWIG_fail;
13568 arg2 = obj1;
13569 {
13570 PyThreadState* __tstate = wxPyBeginAllowThreads();
13571 result = (bool)wxSound_CreateFromData(arg1,arg2);
13572
13573 wxPyEndAllowThreads(__tstate);
13574 if (PyErr_Occurred()) SWIG_fail;
13575 }
13576 {
13577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13578 }
13579 return resultobj;
13580 fail:
13581 return NULL;
13582 }
13583
13584
13585 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13586 PyObject *resultobj;
13587 wxSound *arg1 = (wxSound *) 0 ;
13588 bool result;
13589 PyObject * obj0 = 0 ;
13590 char *kwnames[] = {
13591 (char *) "self", NULL
13592 };
13593
13594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13596 if (SWIG_arg_fail(1)) SWIG_fail;
13597 {
13598 PyThreadState* __tstate = wxPyBeginAllowThreads();
13599 result = (bool)(arg1)->IsOk();
13600
13601 wxPyEndAllowThreads(__tstate);
13602 if (PyErr_Occurred()) SWIG_fail;
13603 }
13604 {
13605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13606 }
13607 return resultobj;
13608 fail:
13609 return NULL;
13610 }
13611
13612
13613 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13614 PyObject *resultobj;
13615 wxSound *arg1 = (wxSound *) 0 ;
13616 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13617 bool result;
13618 PyObject * obj0 = 0 ;
13619 PyObject * obj1 = 0 ;
13620 char *kwnames[] = {
13621 (char *) "self",(char *) "flags", NULL
13622 };
13623
13624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13626 if (SWIG_arg_fail(1)) SWIG_fail;
13627 if (obj1) {
13628 {
13629 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13630 if (SWIG_arg_fail(2)) SWIG_fail;
13631 }
13632 }
13633 {
13634 if (!wxPyCheckForApp()) SWIG_fail;
13635 PyThreadState* __tstate = wxPyBeginAllowThreads();
13636 result = (bool)((wxSound const *)arg1)->Play(arg2);
13637
13638 wxPyEndAllowThreads(__tstate);
13639 if (PyErr_Occurred()) SWIG_fail;
13640 }
13641 {
13642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13643 }
13644 return resultobj;
13645 fail:
13646 return NULL;
13647 }
13648
13649
13650 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13651 PyObject *resultobj;
13652 wxString *arg1 = 0 ;
13653 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13654 bool result;
13655 bool temp1 = false ;
13656 PyObject * obj0 = 0 ;
13657 PyObject * obj1 = 0 ;
13658 char *kwnames[] = {
13659 (char *) "filename",(char *) "flags", NULL
13660 };
13661
13662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13663 {
13664 arg1 = wxString_in_helper(obj0);
13665 if (arg1 == NULL) SWIG_fail;
13666 temp1 = true;
13667 }
13668 if (obj1) {
13669 {
13670 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13671 if (SWIG_arg_fail(2)) SWIG_fail;
13672 }
13673 }
13674 {
13675 if (!wxPyCheckForApp()) SWIG_fail;
13676 PyThreadState* __tstate = wxPyBeginAllowThreads();
13677 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13678
13679 wxPyEndAllowThreads(__tstate);
13680 if (PyErr_Occurred()) SWIG_fail;
13681 }
13682 {
13683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13684 }
13685 {
13686 if (temp1)
13687 delete arg1;
13688 }
13689 return resultobj;
13690 fail:
13691 {
13692 if (temp1)
13693 delete arg1;
13694 }
13695 return NULL;
13696 }
13697
13698
13699 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13700 PyObject *resultobj;
13701 char *kwnames[] = {
13702 NULL
13703 };
13704
13705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13706 {
13707 if (!wxPyCheckForApp()) SWIG_fail;
13708 PyThreadState* __tstate = wxPyBeginAllowThreads();
13709 wxSound::Stop();
13710
13711 wxPyEndAllowThreads(__tstate);
13712 if (PyErr_Occurred()) SWIG_fail;
13713 }
13714 Py_INCREF(Py_None); resultobj = Py_None;
13715 return resultobj;
13716 fail:
13717 return NULL;
13718 }
13719
13720
13721 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13722 PyObject *obj;
13723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13724 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13725 Py_INCREF(obj);
13726 return Py_BuildValue((char *)"");
13727 }
13728 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13729 PyObject *resultobj;
13730 wxString *arg1 = 0 ;
13731 wxString *arg2 = 0 ;
13732 wxString *arg3 = 0 ;
13733 wxString *arg4 = 0 ;
13734 wxFileTypeInfo *result;
13735 bool temp1 = false ;
13736 bool temp2 = false ;
13737 bool temp3 = false ;
13738 bool temp4 = false ;
13739 PyObject * obj0 = 0 ;
13740 PyObject * obj1 = 0 ;
13741 PyObject * obj2 = 0 ;
13742 PyObject * obj3 = 0 ;
13743 char *kwnames[] = {
13744 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13745 };
13746
13747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13748 {
13749 arg1 = wxString_in_helper(obj0);
13750 if (arg1 == NULL) SWIG_fail;
13751 temp1 = true;
13752 }
13753 {
13754 arg2 = wxString_in_helper(obj1);
13755 if (arg2 == NULL) SWIG_fail;
13756 temp2 = true;
13757 }
13758 {
13759 arg3 = wxString_in_helper(obj2);
13760 if (arg3 == NULL) SWIG_fail;
13761 temp3 = true;
13762 }
13763 {
13764 arg4 = wxString_in_helper(obj3);
13765 if (arg4 == NULL) SWIG_fail;
13766 temp4 = true;
13767 }
13768 {
13769 PyThreadState* __tstate = wxPyBeginAllowThreads();
13770 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13771
13772 wxPyEndAllowThreads(__tstate);
13773 if (PyErr_Occurred()) SWIG_fail;
13774 }
13775 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13776 {
13777 if (temp1)
13778 delete arg1;
13779 }
13780 {
13781 if (temp2)
13782 delete arg2;
13783 }
13784 {
13785 if (temp3)
13786 delete arg3;
13787 }
13788 {
13789 if (temp4)
13790 delete arg4;
13791 }
13792 return resultobj;
13793 fail:
13794 {
13795 if (temp1)
13796 delete arg1;
13797 }
13798 {
13799 if (temp2)
13800 delete arg2;
13801 }
13802 {
13803 if (temp3)
13804 delete arg3;
13805 }
13806 {
13807 if (temp4)
13808 delete arg4;
13809 }
13810 return NULL;
13811 }
13812
13813
13814 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13815 PyObject *resultobj;
13816 wxArrayString *arg1 = 0 ;
13817 wxFileTypeInfo *result;
13818 bool temp1 = false ;
13819 PyObject * obj0 = 0 ;
13820 char *kwnames[] = {
13821 (char *) "sArray", NULL
13822 };
13823
13824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13825 {
13826 if (! PySequence_Check(obj0)) {
13827 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13828 SWIG_fail;
13829 }
13830 arg1 = new wxArrayString;
13831 temp1 = true;
13832 int i, len=PySequence_Length(obj0);
13833 for (i=0; i<len; i++) {
13834 PyObject* item = PySequence_GetItem(obj0, i);
13835 wxString* s = wxString_in_helper(item);
13836 if (PyErr_Occurred()) SWIG_fail;
13837 arg1->Add(*s);
13838 delete s;
13839 Py_DECREF(item);
13840 }
13841 }
13842 {
13843 PyThreadState* __tstate = wxPyBeginAllowThreads();
13844 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13845
13846 wxPyEndAllowThreads(__tstate);
13847 if (PyErr_Occurred()) SWIG_fail;
13848 }
13849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13850 {
13851 if (temp1) delete arg1;
13852 }
13853 return resultobj;
13854 fail:
13855 {
13856 if (temp1) delete arg1;
13857 }
13858 return NULL;
13859 }
13860
13861
13862 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13863 PyObject *resultobj;
13864 wxFileTypeInfo *result;
13865 char *kwnames[] = {
13866 NULL
13867 };
13868
13869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13870 {
13871 PyThreadState* __tstate = wxPyBeginAllowThreads();
13872 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13873
13874 wxPyEndAllowThreads(__tstate);
13875 if (PyErr_Occurred()) SWIG_fail;
13876 }
13877 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13878 return resultobj;
13879 fail:
13880 return NULL;
13881 }
13882
13883
13884 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13885 PyObject *resultobj;
13886 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13887 bool result;
13888 PyObject * obj0 = 0 ;
13889 char *kwnames[] = {
13890 (char *) "self", NULL
13891 };
13892
13893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13895 if (SWIG_arg_fail(1)) SWIG_fail;
13896 {
13897 PyThreadState* __tstate = wxPyBeginAllowThreads();
13898 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13899
13900 wxPyEndAllowThreads(__tstate);
13901 if (PyErr_Occurred()) SWIG_fail;
13902 }
13903 {
13904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13905 }
13906 return resultobj;
13907 fail:
13908 return NULL;
13909 }
13910
13911
13912 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13913 PyObject *resultobj;
13914 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13915 wxString *arg2 = 0 ;
13916 int arg3 = (int) 0 ;
13917 bool temp2 = false ;
13918 PyObject * obj0 = 0 ;
13919 PyObject * obj1 = 0 ;
13920 PyObject * obj2 = 0 ;
13921 char *kwnames[] = {
13922 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13923 };
13924
13925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13927 if (SWIG_arg_fail(1)) SWIG_fail;
13928 {
13929 arg2 = wxString_in_helper(obj1);
13930 if (arg2 == NULL) SWIG_fail;
13931 temp2 = true;
13932 }
13933 if (obj2) {
13934 {
13935 arg3 = (int)(SWIG_As_int(obj2));
13936 if (SWIG_arg_fail(3)) SWIG_fail;
13937 }
13938 }
13939 {
13940 PyThreadState* __tstate = wxPyBeginAllowThreads();
13941 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13942
13943 wxPyEndAllowThreads(__tstate);
13944 if (PyErr_Occurred()) SWIG_fail;
13945 }
13946 Py_INCREF(Py_None); resultobj = Py_None;
13947 {
13948 if (temp2)
13949 delete arg2;
13950 }
13951 return resultobj;
13952 fail:
13953 {
13954 if (temp2)
13955 delete arg2;
13956 }
13957 return NULL;
13958 }
13959
13960
13961 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13962 PyObject *resultobj;
13963 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13964 wxString *arg2 = 0 ;
13965 bool temp2 = false ;
13966 PyObject * obj0 = 0 ;
13967 PyObject * obj1 = 0 ;
13968 char *kwnames[] = {
13969 (char *) "self",(char *) "shortDesc", NULL
13970 };
13971
13972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13974 if (SWIG_arg_fail(1)) SWIG_fail;
13975 {
13976 arg2 = wxString_in_helper(obj1);
13977 if (arg2 == NULL) SWIG_fail;
13978 temp2 = true;
13979 }
13980 {
13981 PyThreadState* __tstate = wxPyBeginAllowThreads();
13982 (arg1)->SetShortDesc((wxString const &)*arg2);
13983
13984 wxPyEndAllowThreads(__tstate);
13985 if (PyErr_Occurred()) SWIG_fail;
13986 }
13987 Py_INCREF(Py_None); resultobj = Py_None;
13988 {
13989 if (temp2)
13990 delete arg2;
13991 }
13992 return resultobj;
13993 fail:
13994 {
13995 if (temp2)
13996 delete arg2;
13997 }
13998 return NULL;
13999 }
14000
14001
14002 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14003 PyObject *resultobj;
14004 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14005 wxString *result;
14006 PyObject * obj0 = 0 ;
14007 char *kwnames[] = {
14008 (char *) "self", NULL
14009 };
14010
14011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14013 if (SWIG_arg_fail(1)) SWIG_fail;
14014 {
14015 PyThreadState* __tstate = wxPyBeginAllowThreads();
14016 {
14017 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14018 result = (wxString *) &_result_ref;
14019 }
14020
14021 wxPyEndAllowThreads(__tstate);
14022 if (PyErr_Occurred()) SWIG_fail;
14023 }
14024 {
14025 #if wxUSE_UNICODE
14026 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14027 #else
14028 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14029 #endif
14030 }
14031 return resultobj;
14032 fail:
14033 return NULL;
14034 }
14035
14036
14037 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14038 PyObject *resultobj;
14039 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14040 wxString *result;
14041 PyObject * obj0 = 0 ;
14042 char *kwnames[] = {
14043 (char *) "self", NULL
14044 };
14045
14046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14048 if (SWIG_arg_fail(1)) SWIG_fail;
14049 {
14050 PyThreadState* __tstate = wxPyBeginAllowThreads();
14051 {
14052 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14053 result = (wxString *) &_result_ref;
14054 }
14055
14056 wxPyEndAllowThreads(__tstate);
14057 if (PyErr_Occurred()) SWIG_fail;
14058 }
14059 {
14060 #if wxUSE_UNICODE
14061 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14062 #else
14063 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14064 #endif
14065 }
14066 return resultobj;
14067 fail:
14068 return NULL;
14069 }
14070
14071
14072 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14073 PyObject *resultobj;
14074 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14075 wxString *result;
14076 PyObject * obj0 = 0 ;
14077 char *kwnames[] = {
14078 (char *) "self", NULL
14079 };
14080
14081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14083 if (SWIG_arg_fail(1)) SWIG_fail;
14084 {
14085 PyThreadState* __tstate = wxPyBeginAllowThreads();
14086 {
14087 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14088 result = (wxString *) &_result_ref;
14089 }
14090
14091 wxPyEndAllowThreads(__tstate);
14092 if (PyErr_Occurred()) SWIG_fail;
14093 }
14094 {
14095 #if wxUSE_UNICODE
14096 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14097 #else
14098 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14099 #endif
14100 }
14101 return resultobj;
14102 fail:
14103 return NULL;
14104 }
14105
14106
14107 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14108 PyObject *resultobj;
14109 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14110 wxString *result;
14111 PyObject * obj0 = 0 ;
14112 char *kwnames[] = {
14113 (char *) "self", NULL
14114 };
14115
14116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14118 if (SWIG_arg_fail(1)) SWIG_fail;
14119 {
14120 PyThreadState* __tstate = wxPyBeginAllowThreads();
14121 {
14122 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14123 result = (wxString *) &_result_ref;
14124 }
14125
14126 wxPyEndAllowThreads(__tstate);
14127 if (PyErr_Occurred()) SWIG_fail;
14128 }
14129 {
14130 #if wxUSE_UNICODE
14131 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14132 #else
14133 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14134 #endif
14135 }
14136 return resultobj;
14137 fail:
14138 return NULL;
14139 }
14140
14141
14142 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14143 PyObject *resultobj;
14144 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14145 wxString *result;
14146 PyObject * obj0 = 0 ;
14147 char *kwnames[] = {
14148 (char *) "self", NULL
14149 };
14150
14151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14153 if (SWIG_arg_fail(1)) SWIG_fail;
14154 {
14155 PyThreadState* __tstate = wxPyBeginAllowThreads();
14156 {
14157 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14158 result = (wxString *) &_result_ref;
14159 }
14160
14161 wxPyEndAllowThreads(__tstate);
14162 if (PyErr_Occurred()) SWIG_fail;
14163 }
14164 {
14165 #if wxUSE_UNICODE
14166 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14167 #else
14168 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14169 #endif
14170 }
14171 return resultobj;
14172 fail:
14173 return NULL;
14174 }
14175
14176
14177 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14178 PyObject *resultobj;
14179 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14180 wxArrayString *result;
14181 PyObject * obj0 = 0 ;
14182 char *kwnames[] = {
14183 (char *) "self", NULL
14184 };
14185
14186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14188 if (SWIG_arg_fail(1)) SWIG_fail;
14189 {
14190 PyThreadState* __tstate = wxPyBeginAllowThreads();
14191 {
14192 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14193 result = (wxArrayString *) &_result_ref;
14194 }
14195
14196 wxPyEndAllowThreads(__tstate);
14197 if (PyErr_Occurred()) SWIG_fail;
14198 }
14199 {
14200 resultobj = wxArrayString2PyList_helper(*result);
14201 }
14202 return resultobj;
14203 fail:
14204 return NULL;
14205 }
14206
14207
14208 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14209 PyObject *resultobj;
14210 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14211 int result;
14212 PyObject * obj0 = 0 ;
14213 char *kwnames[] = {
14214 (char *) "self", NULL
14215 };
14216
14217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14219 if (SWIG_arg_fail(1)) SWIG_fail;
14220 {
14221 PyThreadState* __tstate = wxPyBeginAllowThreads();
14222 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14223
14224 wxPyEndAllowThreads(__tstate);
14225 if (PyErr_Occurred()) SWIG_fail;
14226 }
14227 {
14228 resultobj = SWIG_From_int((int)(result));
14229 }
14230 return resultobj;
14231 fail:
14232 return NULL;
14233 }
14234
14235
14236 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14237 PyObject *resultobj;
14238 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14239 wxString *result;
14240 PyObject * obj0 = 0 ;
14241 char *kwnames[] = {
14242 (char *) "self", NULL
14243 };
14244
14245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14247 if (SWIG_arg_fail(1)) SWIG_fail;
14248 {
14249 PyThreadState* __tstate = wxPyBeginAllowThreads();
14250 {
14251 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14252 result = (wxString *) &_result_ref;
14253 }
14254
14255 wxPyEndAllowThreads(__tstate);
14256 if (PyErr_Occurred()) SWIG_fail;
14257 }
14258 {
14259 #if wxUSE_UNICODE
14260 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14261 #else
14262 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14263 #endif
14264 }
14265 return resultobj;
14266 fail:
14267 return NULL;
14268 }
14269
14270
14271 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14272 PyObject *resultobj;
14273 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14274 int result;
14275 PyObject * obj0 = 0 ;
14276 char *kwnames[] = {
14277 (char *) "self", NULL
14278 };
14279
14280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14282 if (SWIG_arg_fail(1)) SWIG_fail;
14283 {
14284 PyThreadState* __tstate = wxPyBeginAllowThreads();
14285 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14286
14287 wxPyEndAllowThreads(__tstate);
14288 if (PyErr_Occurred()) SWIG_fail;
14289 }
14290 {
14291 resultobj = SWIG_From_int((int)(result));
14292 }
14293 return resultobj;
14294 fail:
14295 return NULL;
14296 }
14297
14298
14299 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14300 PyObject *obj;
14301 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14302 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14303 Py_INCREF(obj);
14304 return Py_BuildValue((char *)"");
14305 }
14306 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14307 PyObject *resultobj;
14308 wxFileTypeInfo *arg1 = 0 ;
14309 wxFileType *result;
14310 PyObject * obj0 = 0 ;
14311 char *kwnames[] = {
14312 (char *) "ftInfo", NULL
14313 };
14314
14315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14316 {
14317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14318 if (SWIG_arg_fail(1)) SWIG_fail;
14319 if (arg1 == NULL) {
14320 SWIG_null_ref("wxFileTypeInfo");
14321 }
14322 if (SWIG_arg_fail(1)) SWIG_fail;
14323 }
14324 {
14325 PyThreadState* __tstate = wxPyBeginAllowThreads();
14326 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14327
14328 wxPyEndAllowThreads(__tstate);
14329 if (PyErr_Occurred()) SWIG_fail;
14330 }
14331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14332 return resultobj;
14333 fail:
14334 return NULL;
14335 }
14336
14337
14338 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14339 PyObject *resultobj;
14340 wxFileType *arg1 = (wxFileType *) 0 ;
14341 PyObject * obj0 = 0 ;
14342 char *kwnames[] = {
14343 (char *) "self", NULL
14344 };
14345
14346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14348 if (SWIG_arg_fail(1)) SWIG_fail;
14349 {
14350 PyThreadState* __tstate = wxPyBeginAllowThreads();
14351 delete arg1;
14352
14353 wxPyEndAllowThreads(__tstate);
14354 if (PyErr_Occurred()) SWIG_fail;
14355 }
14356 Py_INCREF(Py_None); resultobj = Py_None;
14357 return resultobj;
14358 fail:
14359 return NULL;
14360 }
14361
14362
14363 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14364 PyObject *resultobj;
14365 wxFileType *arg1 = (wxFileType *) 0 ;
14366 PyObject *result;
14367 PyObject * obj0 = 0 ;
14368 char *kwnames[] = {
14369 (char *) "self", NULL
14370 };
14371
14372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14374 if (SWIG_arg_fail(1)) SWIG_fail;
14375 {
14376 PyThreadState* __tstate = wxPyBeginAllowThreads();
14377 result = (PyObject *)wxFileType_GetMimeType(arg1);
14378
14379 wxPyEndAllowThreads(__tstate);
14380 if (PyErr_Occurred()) SWIG_fail;
14381 }
14382 resultobj = result;
14383 return resultobj;
14384 fail:
14385 return NULL;
14386 }
14387
14388
14389 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14390 PyObject *resultobj;
14391 wxFileType *arg1 = (wxFileType *) 0 ;
14392 PyObject *result;
14393 PyObject * obj0 = 0 ;
14394 char *kwnames[] = {
14395 (char *) "self", NULL
14396 };
14397
14398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14400 if (SWIG_arg_fail(1)) SWIG_fail;
14401 {
14402 PyThreadState* __tstate = wxPyBeginAllowThreads();
14403 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14404
14405 wxPyEndAllowThreads(__tstate);
14406 if (PyErr_Occurred()) SWIG_fail;
14407 }
14408 resultobj = result;
14409 return resultobj;
14410 fail:
14411 return NULL;
14412 }
14413
14414
14415 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14416 PyObject *resultobj;
14417 wxFileType *arg1 = (wxFileType *) 0 ;
14418 PyObject *result;
14419 PyObject * obj0 = 0 ;
14420 char *kwnames[] = {
14421 (char *) "self", NULL
14422 };
14423
14424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14426 if (SWIG_arg_fail(1)) SWIG_fail;
14427 {
14428 PyThreadState* __tstate = wxPyBeginAllowThreads();
14429 result = (PyObject *)wxFileType_GetExtensions(arg1);
14430
14431 wxPyEndAllowThreads(__tstate);
14432 if (PyErr_Occurred()) SWIG_fail;
14433 }
14434 resultobj = result;
14435 return resultobj;
14436 fail:
14437 return NULL;
14438 }
14439
14440
14441 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14442 PyObject *resultobj;
14443 wxFileType *arg1 = (wxFileType *) 0 ;
14444 wxIcon *result;
14445 PyObject * obj0 = 0 ;
14446 char *kwnames[] = {
14447 (char *) "self", NULL
14448 };
14449
14450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14452 if (SWIG_arg_fail(1)) SWIG_fail;
14453 {
14454 PyThreadState* __tstate = wxPyBeginAllowThreads();
14455 result = (wxIcon *)wxFileType_GetIcon(arg1);
14456
14457 wxPyEndAllowThreads(__tstate);
14458 if (PyErr_Occurred()) SWIG_fail;
14459 }
14460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14461 return resultobj;
14462 fail:
14463 return NULL;
14464 }
14465
14466
14467 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14468 PyObject *resultobj;
14469 wxFileType *arg1 = (wxFileType *) 0 ;
14470 PyObject *result;
14471 PyObject * obj0 = 0 ;
14472 char *kwnames[] = {
14473 (char *) "self", NULL
14474 };
14475
14476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14478 if (SWIG_arg_fail(1)) SWIG_fail;
14479 {
14480 PyThreadState* __tstate = wxPyBeginAllowThreads();
14481 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14482
14483 wxPyEndAllowThreads(__tstate);
14484 if (PyErr_Occurred()) SWIG_fail;
14485 }
14486 resultobj = result;
14487 return resultobj;
14488 fail:
14489 return NULL;
14490 }
14491
14492
14493 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14494 PyObject *resultobj;
14495 wxFileType *arg1 = (wxFileType *) 0 ;
14496 PyObject *result;
14497 PyObject * obj0 = 0 ;
14498 char *kwnames[] = {
14499 (char *) "self", NULL
14500 };
14501
14502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14504 if (SWIG_arg_fail(1)) SWIG_fail;
14505 {
14506 PyThreadState* __tstate = wxPyBeginAllowThreads();
14507 result = (PyObject *)wxFileType_GetDescription(arg1);
14508
14509 wxPyEndAllowThreads(__tstate);
14510 if (PyErr_Occurred()) SWIG_fail;
14511 }
14512 resultobj = result;
14513 return resultobj;
14514 fail:
14515 return NULL;
14516 }
14517
14518
14519 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14520 PyObject *resultobj;
14521 wxFileType *arg1 = (wxFileType *) 0 ;
14522 wxString *arg2 = 0 ;
14523 wxString const &arg3_defvalue = wxPyEmptyString ;
14524 wxString *arg3 = (wxString *) &arg3_defvalue ;
14525 PyObject *result;
14526 bool temp2 = false ;
14527 bool temp3 = false ;
14528 PyObject * obj0 = 0 ;
14529 PyObject * obj1 = 0 ;
14530 PyObject * obj2 = 0 ;
14531 char *kwnames[] = {
14532 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14533 };
14534
14535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14537 if (SWIG_arg_fail(1)) SWIG_fail;
14538 {
14539 arg2 = wxString_in_helper(obj1);
14540 if (arg2 == NULL) SWIG_fail;
14541 temp2 = true;
14542 }
14543 if (obj2) {
14544 {
14545 arg3 = wxString_in_helper(obj2);
14546 if (arg3 == NULL) SWIG_fail;
14547 temp3 = true;
14548 }
14549 }
14550 {
14551 PyThreadState* __tstate = wxPyBeginAllowThreads();
14552 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14553
14554 wxPyEndAllowThreads(__tstate);
14555 if (PyErr_Occurred()) SWIG_fail;
14556 }
14557 resultobj = result;
14558 {
14559 if (temp2)
14560 delete arg2;
14561 }
14562 {
14563 if (temp3)
14564 delete arg3;
14565 }
14566 return resultobj;
14567 fail:
14568 {
14569 if (temp2)
14570 delete arg2;
14571 }
14572 {
14573 if (temp3)
14574 delete arg3;
14575 }
14576 return NULL;
14577 }
14578
14579
14580 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14581 PyObject *resultobj;
14582 wxFileType *arg1 = (wxFileType *) 0 ;
14583 wxString *arg2 = 0 ;
14584 wxString const &arg3_defvalue = wxPyEmptyString ;
14585 wxString *arg3 = (wxString *) &arg3_defvalue ;
14586 PyObject *result;
14587 bool temp2 = false ;
14588 bool temp3 = false ;
14589 PyObject * obj0 = 0 ;
14590 PyObject * obj1 = 0 ;
14591 PyObject * obj2 = 0 ;
14592 char *kwnames[] = {
14593 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14594 };
14595
14596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14598 if (SWIG_arg_fail(1)) SWIG_fail;
14599 {
14600 arg2 = wxString_in_helper(obj1);
14601 if (arg2 == NULL) SWIG_fail;
14602 temp2 = true;
14603 }
14604 if (obj2) {
14605 {
14606 arg3 = wxString_in_helper(obj2);
14607 if (arg3 == NULL) SWIG_fail;
14608 temp3 = true;
14609 }
14610 }
14611 {
14612 PyThreadState* __tstate = wxPyBeginAllowThreads();
14613 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14614
14615 wxPyEndAllowThreads(__tstate);
14616 if (PyErr_Occurred()) SWIG_fail;
14617 }
14618 resultobj = result;
14619 {
14620 if (temp2)
14621 delete arg2;
14622 }
14623 {
14624 if (temp3)
14625 delete arg3;
14626 }
14627 return resultobj;
14628 fail:
14629 {
14630 if (temp2)
14631 delete arg2;
14632 }
14633 {
14634 if (temp3)
14635 delete arg3;
14636 }
14637 return NULL;
14638 }
14639
14640
14641 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14642 PyObject *resultobj;
14643 wxFileType *arg1 = (wxFileType *) 0 ;
14644 wxString *arg2 = 0 ;
14645 wxString const &arg3_defvalue = wxPyEmptyString ;
14646 wxString *arg3 = (wxString *) &arg3_defvalue ;
14647 PyObject *result;
14648 bool temp2 = false ;
14649 bool temp3 = false ;
14650 PyObject * obj0 = 0 ;
14651 PyObject * obj1 = 0 ;
14652 PyObject * obj2 = 0 ;
14653 char *kwnames[] = {
14654 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14655 };
14656
14657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14659 if (SWIG_arg_fail(1)) SWIG_fail;
14660 {
14661 arg2 = wxString_in_helper(obj1);
14662 if (arg2 == NULL) SWIG_fail;
14663 temp2 = true;
14664 }
14665 if (obj2) {
14666 {
14667 arg3 = wxString_in_helper(obj2);
14668 if (arg3 == NULL) SWIG_fail;
14669 temp3 = true;
14670 }
14671 }
14672 {
14673 PyThreadState* __tstate = wxPyBeginAllowThreads();
14674 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14675
14676 wxPyEndAllowThreads(__tstate);
14677 if (PyErr_Occurred()) SWIG_fail;
14678 }
14679 resultobj = result;
14680 {
14681 if (temp2)
14682 delete arg2;
14683 }
14684 {
14685 if (temp3)
14686 delete arg3;
14687 }
14688 return resultobj;
14689 fail:
14690 {
14691 if (temp2)
14692 delete arg2;
14693 }
14694 {
14695 if (temp3)
14696 delete arg3;
14697 }
14698 return NULL;
14699 }
14700
14701
14702 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14703 PyObject *resultobj;
14704 wxFileType *arg1 = (wxFileType *) 0 ;
14705 wxString *arg2 = 0 ;
14706 wxString *arg3 = 0 ;
14707 bool arg4 = (bool) true ;
14708 bool result;
14709 bool temp2 = false ;
14710 bool temp3 = false ;
14711 PyObject * obj0 = 0 ;
14712 PyObject * obj1 = 0 ;
14713 PyObject * obj2 = 0 ;
14714 PyObject * obj3 = 0 ;
14715 char *kwnames[] = {
14716 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14717 };
14718
14719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14721 if (SWIG_arg_fail(1)) SWIG_fail;
14722 {
14723 arg2 = wxString_in_helper(obj1);
14724 if (arg2 == NULL) SWIG_fail;
14725 temp2 = true;
14726 }
14727 {
14728 arg3 = wxString_in_helper(obj2);
14729 if (arg3 == NULL) SWIG_fail;
14730 temp3 = true;
14731 }
14732 if (obj3) {
14733 {
14734 arg4 = (bool)(SWIG_As_bool(obj3));
14735 if (SWIG_arg_fail(4)) SWIG_fail;
14736 }
14737 }
14738 {
14739 PyThreadState* __tstate = wxPyBeginAllowThreads();
14740 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14741
14742 wxPyEndAllowThreads(__tstate);
14743 if (PyErr_Occurred()) SWIG_fail;
14744 }
14745 {
14746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14747 }
14748 {
14749 if (temp2)
14750 delete arg2;
14751 }
14752 {
14753 if (temp3)
14754 delete arg3;
14755 }
14756 return resultobj;
14757 fail:
14758 {
14759 if (temp2)
14760 delete arg2;
14761 }
14762 {
14763 if (temp3)
14764 delete arg3;
14765 }
14766 return NULL;
14767 }
14768
14769
14770 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14771 PyObject *resultobj;
14772 wxFileType *arg1 = (wxFileType *) 0 ;
14773 wxString const &arg2_defvalue = wxPyEmptyString ;
14774 wxString *arg2 = (wxString *) &arg2_defvalue ;
14775 int arg3 = (int) 0 ;
14776 bool result;
14777 bool temp2 = false ;
14778 PyObject * obj0 = 0 ;
14779 PyObject * obj1 = 0 ;
14780 PyObject * obj2 = 0 ;
14781 char *kwnames[] = {
14782 (char *) "self",(char *) "cmd",(char *) "index", NULL
14783 };
14784
14785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14787 if (SWIG_arg_fail(1)) SWIG_fail;
14788 if (obj1) {
14789 {
14790 arg2 = wxString_in_helper(obj1);
14791 if (arg2 == NULL) SWIG_fail;
14792 temp2 = true;
14793 }
14794 }
14795 if (obj2) {
14796 {
14797 arg3 = (int)(SWIG_As_int(obj2));
14798 if (SWIG_arg_fail(3)) SWIG_fail;
14799 }
14800 }
14801 {
14802 PyThreadState* __tstate = wxPyBeginAllowThreads();
14803 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14804
14805 wxPyEndAllowThreads(__tstate);
14806 if (PyErr_Occurred()) SWIG_fail;
14807 }
14808 {
14809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14810 }
14811 {
14812 if (temp2)
14813 delete arg2;
14814 }
14815 return resultobj;
14816 fail:
14817 {
14818 if (temp2)
14819 delete arg2;
14820 }
14821 return NULL;
14822 }
14823
14824
14825 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14826 PyObject *resultobj;
14827 wxFileType *arg1 = (wxFileType *) 0 ;
14828 bool result;
14829 PyObject * obj0 = 0 ;
14830 char *kwnames[] = {
14831 (char *) "self", NULL
14832 };
14833
14834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14836 if (SWIG_arg_fail(1)) SWIG_fail;
14837 {
14838 PyThreadState* __tstate = wxPyBeginAllowThreads();
14839 result = (bool)(arg1)->Unassociate();
14840
14841 wxPyEndAllowThreads(__tstate);
14842 if (PyErr_Occurred()) SWIG_fail;
14843 }
14844 {
14845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14846 }
14847 return resultobj;
14848 fail:
14849 return NULL;
14850 }
14851
14852
14853 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14854 PyObject *resultobj;
14855 wxString *arg1 = 0 ;
14856 wxString *arg2 = 0 ;
14857 wxString const &arg3_defvalue = wxPyEmptyString ;
14858 wxString *arg3 = (wxString *) &arg3_defvalue ;
14859 wxString result;
14860 bool temp1 = false ;
14861 bool temp2 = false ;
14862 bool temp3 = false ;
14863 PyObject * obj0 = 0 ;
14864 PyObject * obj1 = 0 ;
14865 PyObject * obj2 = 0 ;
14866 char *kwnames[] = {
14867 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14868 };
14869
14870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14871 {
14872 arg1 = wxString_in_helper(obj0);
14873 if (arg1 == NULL) SWIG_fail;
14874 temp1 = true;
14875 }
14876 {
14877 arg2 = wxString_in_helper(obj1);
14878 if (arg2 == NULL) SWIG_fail;
14879 temp2 = true;
14880 }
14881 if (obj2) {
14882 {
14883 arg3 = wxString_in_helper(obj2);
14884 if (arg3 == NULL) SWIG_fail;
14885 temp3 = true;
14886 }
14887 }
14888 {
14889 PyThreadState* __tstate = wxPyBeginAllowThreads();
14890 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14891
14892 wxPyEndAllowThreads(__tstate);
14893 if (PyErr_Occurred()) SWIG_fail;
14894 }
14895 {
14896 #if wxUSE_UNICODE
14897 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14898 #else
14899 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14900 #endif
14901 }
14902 {
14903 if (temp1)
14904 delete arg1;
14905 }
14906 {
14907 if (temp2)
14908 delete arg2;
14909 }
14910 {
14911 if (temp3)
14912 delete arg3;
14913 }
14914 return resultobj;
14915 fail:
14916 {
14917 if (temp1)
14918 delete arg1;
14919 }
14920 {
14921 if (temp2)
14922 delete arg2;
14923 }
14924 {
14925 if (temp3)
14926 delete arg3;
14927 }
14928 return NULL;
14929 }
14930
14931
14932 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14933 PyObject *obj;
14934 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14935 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14936 Py_INCREF(obj);
14937 return Py_BuildValue((char *)"");
14938 }
14939 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14940 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14941 return 1;
14942 }
14943
14944
14945 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14946 PyObject *pyobj;
14947
14948 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14949 return pyobj;
14950 }
14951
14952
14953 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14954 PyObject *resultobj;
14955 wxString *arg1 = 0 ;
14956 wxString *arg2 = 0 ;
14957 bool result;
14958 bool temp1 = false ;
14959 bool temp2 = false ;
14960 PyObject * obj0 = 0 ;
14961 PyObject * obj1 = 0 ;
14962 char *kwnames[] = {
14963 (char *) "mimeType",(char *) "wildcard", NULL
14964 };
14965
14966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14967 {
14968 arg1 = wxString_in_helper(obj0);
14969 if (arg1 == NULL) SWIG_fail;
14970 temp1 = true;
14971 }
14972 {
14973 arg2 = wxString_in_helper(obj1);
14974 if (arg2 == NULL) SWIG_fail;
14975 temp2 = true;
14976 }
14977 {
14978 PyThreadState* __tstate = wxPyBeginAllowThreads();
14979 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14980
14981 wxPyEndAllowThreads(__tstate);
14982 if (PyErr_Occurred()) SWIG_fail;
14983 }
14984 {
14985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14986 }
14987 {
14988 if (temp1)
14989 delete arg1;
14990 }
14991 {
14992 if (temp2)
14993 delete arg2;
14994 }
14995 return resultobj;
14996 fail:
14997 {
14998 if (temp1)
14999 delete arg1;
15000 }
15001 {
15002 if (temp2)
15003 delete arg2;
15004 }
15005 return NULL;
15006 }
15007
15008
15009 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15010 PyObject *resultobj;
15011 wxMimeTypesManager *result;
15012 char *kwnames[] = {
15013 NULL
15014 };
15015
15016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15017 {
15018 PyThreadState* __tstate = wxPyBeginAllowThreads();
15019 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15020
15021 wxPyEndAllowThreads(__tstate);
15022 if (PyErr_Occurred()) SWIG_fail;
15023 }
15024 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15025 return resultobj;
15026 fail:
15027 return NULL;
15028 }
15029
15030
15031 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15032 PyObject *resultobj;
15033 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15034 int arg2 = (int) wxMAILCAP_ALL ;
15035 wxString const &arg3_defvalue = wxPyEmptyString ;
15036 wxString *arg3 = (wxString *) &arg3_defvalue ;
15037 bool temp3 = false ;
15038 PyObject * obj0 = 0 ;
15039 PyObject * obj1 = 0 ;
15040 PyObject * obj2 = 0 ;
15041 char *kwnames[] = {
15042 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15043 };
15044
15045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15047 if (SWIG_arg_fail(1)) SWIG_fail;
15048 if (obj1) {
15049 {
15050 arg2 = (int)(SWIG_As_int(obj1));
15051 if (SWIG_arg_fail(2)) SWIG_fail;
15052 }
15053 }
15054 if (obj2) {
15055 {
15056 arg3 = wxString_in_helper(obj2);
15057 if (arg3 == NULL) SWIG_fail;
15058 temp3 = true;
15059 }
15060 }
15061 {
15062 PyThreadState* __tstate = wxPyBeginAllowThreads();
15063 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15064
15065 wxPyEndAllowThreads(__tstate);
15066 if (PyErr_Occurred()) SWIG_fail;
15067 }
15068 Py_INCREF(Py_None); resultobj = Py_None;
15069 {
15070 if (temp3)
15071 delete arg3;
15072 }
15073 return resultobj;
15074 fail:
15075 {
15076 if (temp3)
15077 delete arg3;
15078 }
15079 return NULL;
15080 }
15081
15082
15083 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15084 PyObject *resultobj;
15085 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15086 PyObject * obj0 = 0 ;
15087 char *kwnames[] = {
15088 (char *) "self", NULL
15089 };
15090
15091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15093 if (SWIG_arg_fail(1)) SWIG_fail;
15094 {
15095 PyThreadState* __tstate = wxPyBeginAllowThreads();
15096 (arg1)->ClearData();
15097
15098 wxPyEndAllowThreads(__tstate);
15099 if (PyErr_Occurred()) SWIG_fail;
15100 }
15101 Py_INCREF(Py_None); resultobj = Py_None;
15102 return resultobj;
15103 fail:
15104 return NULL;
15105 }
15106
15107
15108 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15109 PyObject *resultobj;
15110 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15111 wxString *arg2 = 0 ;
15112 wxFileType *result;
15113 bool temp2 = false ;
15114 PyObject * obj0 = 0 ;
15115 PyObject * obj1 = 0 ;
15116 char *kwnames[] = {
15117 (char *) "self",(char *) "ext", NULL
15118 };
15119
15120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15122 if (SWIG_arg_fail(1)) SWIG_fail;
15123 {
15124 arg2 = wxString_in_helper(obj1);
15125 if (arg2 == NULL) SWIG_fail;
15126 temp2 = true;
15127 }
15128 {
15129 PyThreadState* __tstate = wxPyBeginAllowThreads();
15130 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15131
15132 wxPyEndAllowThreads(__tstate);
15133 if (PyErr_Occurred()) SWIG_fail;
15134 }
15135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15136 {
15137 if (temp2)
15138 delete arg2;
15139 }
15140 return resultobj;
15141 fail:
15142 {
15143 if (temp2)
15144 delete arg2;
15145 }
15146 return NULL;
15147 }
15148
15149
15150 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15151 PyObject *resultobj;
15152 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15153 wxString *arg2 = 0 ;
15154 wxFileType *result;
15155 bool temp2 = false ;
15156 PyObject * obj0 = 0 ;
15157 PyObject * obj1 = 0 ;
15158 char *kwnames[] = {
15159 (char *) "self",(char *) "mimeType", NULL
15160 };
15161
15162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15164 if (SWIG_arg_fail(1)) SWIG_fail;
15165 {
15166 arg2 = wxString_in_helper(obj1);
15167 if (arg2 == NULL) SWIG_fail;
15168 temp2 = true;
15169 }
15170 {
15171 PyThreadState* __tstate = wxPyBeginAllowThreads();
15172 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15173
15174 wxPyEndAllowThreads(__tstate);
15175 if (PyErr_Occurred()) SWIG_fail;
15176 }
15177 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15178 {
15179 if (temp2)
15180 delete arg2;
15181 }
15182 return resultobj;
15183 fail:
15184 {
15185 if (temp2)
15186 delete arg2;
15187 }
15188 return NULL;
15189 }
15190
15191
15192 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15193 PyObject *resultobj;
15194 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15195 wxString *arg2 = 0 ;
15196 bool arg3 = (bool) false ;
15197 bool result;
15198 bool temp2 = false ;
15199 PyObject * obj0 = 0 ;
15200 PyObject * obj1 = 0 ;
15201 PyObject * obj2 = 0 ;
15202 char *kwnames[] = {
15203 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15204 };
15205
15206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15208 if (SWIG_arg_fail(1)) SWIG_fail;
15209 {
15210 arg2 = wxString_in_helper(obj1);
15211 if (arg2 == NULL) SWIG_fail;
15212 temp2 = true;
15213 }
15214 if (obj2) {
15215 {
15216 arg3 = (bool)(SWIG_As_bool(obj2));
15217 if (SWIG_arg_fail(3)) SWIG_fail;
15218 }
15219 }
15220 {
15221 PyThreadState* __tstate = wxPyBeginAllowThreads();
15222 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15223
15224 wxPyEndAllowThreads(__tstate);
15225 if (PyErr_Occurred()) SWIG_fail;
15226 }
15227 {
15228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15229 }
15230 {
15231 if (temp2)
15232 delete arg2;
15233 }
15234 return resultobj;
15235 fail:
15236 {
15237 if (temp2)
15238 delete arg2;
15239 }
15240 return NULL;
15241 }
15242
15243
15244 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15245 PyObject *resultobj;
15246 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15247 wxString *arg2 = 0 ;
15248 bool result;
15249 bool temp2 = false ;
15250 PyObject * obj0 = 0 ;
15251 PyObject * obj1 = 0 ;
15252 char *kwnames[] = {
15253 (char *) "self",(char *) "filename", NULL
15254 };
15255
15256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15258 if (SWIG_arg_fail(1)) SWIG_fail;
15259 {
15260 arg2 = wxString_in_helper(obj1);
15261 if (arg2 == NULL) SWIG_fail;
15262 temp2 = true;
15263 }
15264 {
15265 PyThreadState* __tstate = wxPyBeginAllowThreads();
15266 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15267
15268 wxPyEndAllowThreads(__tstate);
15269 if (PyErr_Occurred()) SWIG_fail;
15270 }
15271 {
15272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15273 }
15274 {
15275 if (temp2)
15276 delete arg2;
15277 }
15278 return resultobj;
15279 fail:
15280 {
15281 if (temp2)
15282 delete arg2;
15283 }
15284 return NULL;
15285 }
15286
15287
15288 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15289 PyObject *resultobj;
15290 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15291 PyObject *result;
15292 PyObject * obj0 = 0 ;
15293 char *kwnames[] = {
15294 (char *) "self", NULL
15295 };
15296
15297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15299 if (SWIG_arg_fail(1)) SWIG_fail;
15300 {
15301 PyThreadState* __tstate = wxPyBeginAllowThreads();
15302 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15303
15304 wxPyEndAllowThreads(__tstate);
15305 if (PyErr_Occurred()) SWIG_fail;
15306 }
15307 resultobj = result;
15308 return resultobj;
15309 fail:
15310 return NULL;
15311 }
15312
15313
15314 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15315 PyObject *resultobj;
15316 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15317 wxFileTypeInfo *arg2 = 0 ;
15318 PyObject * obj0 = 0 ;
15319 PyObject * obj1 = 0 ;
15320 char *kwnames[] = {
15321 (char *) "self",(char *) "ft", NULL
15322 };
15323
15324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15326 if (SWIG_arg_fail(1)) SWIG_fail;
15327 {
15328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15329 if (SWIG_arg_fail(2)) SWIG_fail;
15330 if (arg2 == NULL) {
15331 SWIG_null_ref("wxFileTypeInfo");
15332 }
15333 if (SWIG_arg_fail(2)) SWIG_fail;
15334 }
15335 {
15336 PyThreadState* __tstate = wxPyBeginAllowThreads();
15337 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15338
15339 wxPyEndAllowThreads(__tstate);
15340 if (PyErr_Occurred()) SWIG_fail;
15341 }
15342 Py_INCREF(Py_None); resultobj = Py_None;
15343 return resultobj;
15344 fail:
15345 return NULL;
15346 }
15347
15348
15349 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15350 PyObject *resultobj;
15351 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15352 wxFileTypeInfo *arg2 = 0 ;
15353 wxFileType *result;
15354 PyObject * obj0 = 0 ;
15355 PyObject * obj1 = 0 ;
15356 char *kwnames[] = {
15357 (char *) "self",(char *) "ftInfo", NULL
15358 };
15359
15360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15362 if (SWIG_arg_fail(1)) SWIG_fail;
15363 {
15364 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15365 if (SWIG_arg_fail(2)) SWIG_fail;
15366 if (arg2 == NULL) {
15367 SWIG_null_ref("wxFileTypeInfo");
15368 }
15369 if (SWIG_arg_fail(2)) SWIG_fail;
15370 }
15371 {
15372 PyThreadState* __tstate = wxPyBeginAllowThreads();
15373 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15374
15375 wxPyEndAllowThreads(__tstate);
15376 if (PyErr_Occurred()) SWIG_fail;
15377 }
15378 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15379 return resultobj;
15380 fail:
15381 return NULL;
15382 }
15383
15384
15385 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15386 PyObject *resultobj;
15387 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15388 wxFileType *arg2 = (wxFileType *) 0 ;
15389 bool result;
15390 PyObject * obj0 = 0 ;
15391 PyObject * obj1 = 0 ;
15392 char *kwnames[] = {
15393 (char *) "self",(char *) "ft", NULL
15394 };
15395
15396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15398 if (SWIG_arg_fail(1)) SWIG_fail;
15399 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15400 if (SWIG_arg_fail(2)) SWIG_fail;
15401 {
15402 PyThreadState* __tstate = wxPyBeginAllowThreads();
15403 result = (bool)(arg1)->Unassociate(arg2);
15404
15405 wxPyEndAllowThreads(__tstate);
15406 if (PyErr_Occurred()) SWIG_fail;
15407 }
15408 {
15409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15410 }
15411 return resultobj;
15412 fail:
15413 return NULL;
15414 }
15415
15416
15417 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15418 PyObject *resultobj;
15419 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15420 PyObject * obj0 = 0 ;
15421 char *kwnames[] = {
15422 (char *) "self", NULL
15423 };
15424
15425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15427 if (SWIG_arg_fail(1)) SWIG_fail;
15428 {
15429 PyThreadState* __tstate = wxPyBeginAllowThreads();
15430 delete arg1;
15431
15432 wxPyEndAllowThreads(__tstate);
15433 if (PyErr_Occurred()) SWIG_fail;
15434 }
15435 Py_INCREF(Py_None); resultobj = Py_None;
15436 return resultobj;
15437 fail:
15438 return NULL;
15439 }
15440
15441
15442 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15443 PyObject *obj;
15444 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15445 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15446 Py_INCREF(obj);
15447 return Py_BuildValue((char *)"");
15448 }
15449 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15450 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15451 return 1;
15452 }
15453
15454
15455 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15456 PyObject *pyobj;
15457
15458 {
15459 #if wxUSE_UNICODE
15460 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15461 #else
15462 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15463 #endif
15464 }
15465 return pyobj;
15466 }
15467
15468
15469 static int _wrap_ART_MENU_set(PyObject *) {
15470 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15471 return 1;
15472 }
15473
15474
15475 static PyObject *_wrap_ART_MENU_get(void) {
15476 PyObject *pyobj;
15477
15478 {
15479 #if wxUSE_UNICODE
15480 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15481 #else
15482 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15483 #endif
15484 }
15485 return pyobj;
15486 }
15487
15488
15489 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15490 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15491 return 1;
15492 }
15493
15494
15495 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15496 PyObject *pyobj;
15497
15498 {
15499 #if wxUSE_UNICODE
15500 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15501 #else
15502 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15503 #endif
15504 }
15505 return pyobj;
15506 }
15507
15508
15509 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15510 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15511 return 1;
15512 }
15513
15514
15515 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15516 PyObject *pyobj;
15517
15518 {
15519 #if wxUSE_UNICODE
15520 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15521 #else
15522 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15523 #endif
15524 }
15525 return pyobj;
15526 }
15527
15528
15529 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15530 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15531 return 1;
15532 }
15533
15534
15535 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15536 PyObject *pyobj;
15537
15538 {
15539 #if wxUSE_UNICODE
15540 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15541 #else
15542 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15543 #endif
15544 }
15545 return pyobj;
15546 }
15547
15548
15549 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15550 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15551 return 1;
15552 }
15553
15554
15555 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15556 PyObject *pyobj;
15557
15558 {
15559 #if wxUSE_UNICODE
15560 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15561 #else
15562 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15563 #endif
15564 }
15565 return pyobj;
15566 }
15567
15568
15569 static int _wrap_ART_BUTTON_set(PyObject *) {
15570 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15571 return 1;
15572 }
15573
15574
15575 static PyObject *_wrap_ART_BUTTON_get(void) {
15576 PyObject *pyobj;
15577
15578 {
15579 #if wxUSE_UNICODE
15580 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15581 #else
15582 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15583 #endif
15584 }
15585 return pyobj;
15586 }
15587
15588
15589 static int _wrap_ART_OTHER_set(PyObject *) {
15590 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15591 return 1;
15592 }
15593
15594
15595 static PyObject *_wrap_ART_OTHER_get(void) {
15596 PyObject *pyobj;
15597
15598 {
15599 #if wxUSE_UNICODE
15600 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15601 #else
15602 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15603 #endif
15604 }
15605 return pyobj;
15606 }
15607
15608
15609 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15610 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15611 return 1;
15612 }
15613
15614
15615 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15616 PyObject *pyobj;
15617
15618 {
15619 #if wxUSE_UNICODE
15620 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15621 #else
15622 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15623 #endif
15624 }
15625 return pyobj;
15626 }
15627
15628
15629 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15630 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15631 return 1;
15632 }
15633
15634
15635 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15636 PyObject *pyobj;
15637
15638 {
15639 #if wxUSE_UNICODE
15640 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15641 #else
15642 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15643 #endif
15644 }
15645 return pyobj;
15646 }
15647
15648
15649 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15650 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15651 return 1;
15652 }
15653
15654
15655 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15656 PyObject *pyobj;
15657
15658 {
15659 #if wxUSE_UNICODE
15660 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15661 #else
15662 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15663 #endif
15664 }
15665 return pyobj;
15666 }
15667
15668
15669 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15670 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15671 return 1;
15672 }
15673
15674
15675 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15676 PyObject *pyobj;
15677
15678 {
15679 #if wxUSE_UNICODE
15680 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15681 #else
15682 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15683 #endif
15684 }
15685 return pyobj;
15686 }
15687
15688
15689 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15690 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15691 return 1;
15692 }
15693
15694
15695 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15696 PyObject *pyobj;
15697
15698 {
15699 #if wxUSE_UNICODE
15700 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15701 #else
15702 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15703 #endif
15704 }
15705 return pyobj;
15706 }
15707
15708
15709 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15710 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15711 return 1;
15712 }
15713
15714
15715 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15716 PyObject *pyobj;
15717
15718 {
15719 #if wxUSE_UNICODE
15720 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15721 #else
15722 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15723 #endif
15724 }
15725 return pyobj;
15726 }
15727
15728
15729 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15730 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15731 return 1;
15732 }
15733
15734
15735 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15736 PyObject *pyobj;
15737
15738 {
15739 #if wxUSE_UNICODE
15740 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15741 #else
15742 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15743 #endif
15744 }
15745 return pyobj;
15746 }
15747
15748
15749 static int _wrap_ART_GO_BACK_set(PyObject *) {
15750 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15751 return 1;
15752 }
15753
15754
15755 static PyObject *_wrap_ART_GO_BACK_get(void) {
15756 PyObject *pyobj;
15757
15758 {
15759 #if wxUSE_UNICODE
15760 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15761 #else
15762 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15763 #endif
15764 }
15765 return pyobj;
15766 }
15767
15768
15769 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15770 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15771 return 1;
15772 }
15773
15774
15775 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15776 PyObject *pyobj;
15777
15778 {
15779 #if wxUSE_UNICODE
15780 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15781 #else
15782 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15783 #endif
15784 }
15785 return pyobj;
15786 }
15787
15788
15789 static int _wrap_ART_GO_UP_set(PyObject *) {
15790 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15791 return 1;
15792 }
15793
15794
15795 static PyObject *_wrap_ART_GO_UP_get(void) {
15796 PyObject *pyobj;
15797
15798 {
15799 #if wxUSE_UNICODE
15800 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15801 #else
15802 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15803 #endif
15804 }
15805 return pyobj;
15806 }
15807
15808
15809 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15810 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15811 return 1;
15812 }
15813
15814
15815 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15816 PyObject *pyobj;
15817
15818 {
15819 #if wxUSE_UNICODE
15820 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15821 #else
15822 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15823 #endif
15824 }
15825 return pyobj;
15826 }
15827
15828
15829 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15830 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15831 return 1;
15832 }
15833
15834
15835 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15836 PyObject *pyobj;
15837
15838 {
15839 #if wxUSE_UNICODE
15840 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15841 #else
15842 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15843 #endif
15844 }
15845 return pyobj;
15846 }
15847
15848
15849 static int _wrap_ART_GO_HOME_set(PyObject *) {
15850 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15851 return 1;
15852 }
15853
15854
15855 static PyObject *_wrap_ART_GO_HOME_get(void) {
15856 PyObject *pyobj;
15857
15858 {
15859 #if wxUSE_UNICODE
15860 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15861 #else
15862 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15863 #endif
15864 }
15865 return pyobj;
15866 }
15867
15868
15869 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15870 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15871 return 1;
15872 }
15873
15874
15875 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15876 PyObject *pyobj;
15877
15878 {
15879 #if wxUSE_UNICODE
15880 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15881 #else
15882 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15883 #endif
15884 }
15885 return pyobj;
15886 }
15887
15888
15889 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15890 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15891 return 1;
15892 }
15893
15894
15895 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15896 PyObject *pyobj;
15897
15898 {
15899 #if wxUSE_UNICODE
15900 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15901 #else
15902 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15903 #endif
15904 }
15905 return pyobj;
15906 }
15907
15908
15909 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15910 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15911 return 1;
15912 }
15913
15914
15915 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15916 PyObject *pyobj;
15917
15918 {
15919 #if wxUSE_UNICODE
15920 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15921 #else
15922 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15923 #endif
15924 }
15925 return pyobj;
15926 }
15927
15928
15929 static int _wrap_ART_PRINT_set(PyObject *) {
15930 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15931 return 1;
15932 }
15933
15934
15935 static PyObject *_wrap_ART_PRINT_get(void) {
15936 PyObject *pyobj;
15937
15938 {
15939 #if wxUSE_UNICODE
15940 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15941 #else
15942 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15943 #endif
15944 }
15945 return pyobj;
15946 }
15947
15948
15949 static int _wrap_ART_HELP_set(PyObject *) {
15950 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15951 return 1;
15952 }
15953
15954
15955 static PyObject *_wrap_ART_HELP_get(void) {
15956 PyObject *pyobj;
15957
15958 {
15959 #if wxUSE_UNICODE
15960 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15961 #else
15962 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15963 #endif
15964 }
15965 return pyobj;
15966 }
15967
15968
15969 static int _wrap_ART_TIP_set(PyObject *) {
15970 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15971 return 1;
15972 }
15973
15974
15975 static PyObject *_wrap_ART_TIP_get(void) {
15976 PyObject *pyobj;
15977
15978 {
15979 #if wxUSE_UNICODE
15980 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15981 #else
15982 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15983 #endif
15984 }
15985 return pyobj;
15986 }
15987
15988
15989 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15990 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15991 return 1;
15992 }
15993
15994
15995 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15996 PyObject *pyobj;
15997
15998 {
15999 #if wxUSE_UNICODE
16000 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16001 #else
16002 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16003 #endif
16004 }
16005 return pyobj;
16006 }
16007
16008
16009 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16010 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16011 return 1;
16012 }
16013
16014
16015 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16016 PyObject *pyobj;
16017
16018 {
16019 #if wxUSE_UNICODE
16020 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16021 #else
16022 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16023 #endif
16024 }
16025 return pyobj;
16026 }
16027
16028
16029 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16030 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16031 return 1;
16032 }
16033
16034
16035 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16036 PyObject *pyobj;
16037
16038 {
16039 #if wxUSE_UNICODE
16040 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16041 #else
16042 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16043 #endif
16044 }
16045 return pyobj;
16046 }
16047
16048
16049 static int _wrap_ART_HARDDISK_set(PyObject *) {
16050 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16051 return 1;
16052 }
16053
16054
16055 static PyObject *_wrap_ART_HARDDISK_get(void) {
16056 PyObject *pyobj;
16057
16058 {
16059 #if wxUSE_UNICODE
16060 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16061 #else
16062 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16063 #endif
16064 }
16065 return pyobj;
16066 }
16067
16068
16069 static int _wrap_ART_FLOPPY_set(PyObject *) {
16070 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16071 return 1;
16072 }
16073
16074
16075 static PyObject *_wrap_ART_FLOPPY_get(void) {
16076 PyObject *pyobj;
16077
16078 {
16079 #if wxUSE_UNICODE
16080 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16081 #else
16082 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16083 #endif
16084 }
16085 return pyobj;
16086 }
16087
16088
16089 static int _wrap_ART_CDROM_set(PyObject *) {
16090 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16091 return 1;
16092 }
16093
16094
16095 static PyObject *_wrap_ART_CDROM_get(void) {
16096 PyObject *pyobj;
16097
16098 {
16099 #if wxUSE_UNICODE
16100 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16101 #else
16102 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16103 #endif
16104 }
16105 return pyobj;
16106 }
16107
16108
16109 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16110 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16111 return 1;
16112 }
16113
16114
16115 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16116 PyObject *pyobj;
16117
16118 {
16119 #if wxUSE_UNICODE
16120 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16121 #else
16122 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16123 #endif
16124 }
16125 return pyobj;
16126 }
16127
16128
16129 static int _wrap_ART_FOLDER_set(PyObject *) {
16130 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16131 return 1;
16132 }
16133
16134
16135 static PyObject *_wrap_ART_FOLDER_get(void) {
16136 PyObject *pyobj;
16137
16138 {
16139 #if wxUSE_UNICODE
16140 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16141 #else
16142 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16143 #endif
16144 }
16145 return pyobj;
16146 }
16147
16148
16149 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16150 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16151 return 1;
16152 }
16153
16154
16155 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16156 PyObject *pyobj;
16157
16158 {
16159 #if wxUSE_UNICODE
16160 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16161 #else
16162 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16163 #endif
16164 }
16165 return pyobj;
16166 }
16167
16168
16169 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16170 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16171 return 1;
16172 }
16173
16174
16175 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16176 PyObject *pyobj;
16177
16178 {
16179 #if wxUSE_UNICODE
16180 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16181 #else
16182 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16183 #endif
16184 }
16185 return pyobj;
16186 }
16187
16188
16189 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16190 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16191 return 1;
16192 }
16193
16194
16195 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16196 PyObject *pyobj;
16197
16198 {
16199 #if wxUSE_UNICODE
16200 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16201 #else
16202 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16203 #endif
16204 }
16205 return pyobj;
16206 }
16207
16208
16209 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16210 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16211 return 1;
16212 }
16213
16214
16215 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16216 PyObject *pyobj;
16217
16218 {
16219 #if wxUSE_UNICODE
16220 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16221 #else
16222 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16223 #endif
16224 }
16225 return pyobj;
16226 }
16227
16228
16229 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16230 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16231 return 1;
16232 }
16233
16234
16235 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16236 PyObject *pyobj;
16237
16238 {
16239 #if wxUSE_UNICODE
16240 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16241 #else
16242 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16243 #endif
16244 }
16245 return pyobj;
16246 }
16247
16248
16249 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16250 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16251 return 1;
16252 }
16253
16254
16255 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16256 PyObject *pyobj;
16257
16258 {
16259 #if wxUSE_UNICODE
16260 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16261 #else
16262 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16263 #endif
16264 }
16265 return pyobj;
16266 }
16267
16268
16269 static int _wrap_ART_ERROR_set(PyObject *) {
16270 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16271 return 1;
16272 }
16273
16274
16275 static PyObject *_wrap_ART_ERROR_get(void) {
16276 PyObject *pyobj;
16277
16278 {
16279 #if wxUSE_UNICODE
16280 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16281 #else
16282 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16283 #endif
16284 }
16285 return pyobj;
16286 }
16287
16288
16289 static int _wrap_ART_QUESTION_set(PyObject *) {
16290 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16291 return 1;
16292 }
16293
16294
16295 static PyObject *_wrap_ART_QUESTION_get(void) {
16296 PyObject *pyobj;
16297
16298 {
16299 #if wxUSE_UNICODE
16300 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16301 #else
16302 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16303 #endif
16304 }
16305 return pyobj;
16306 }
16307
16308
16309 static int _wrap_ART_WARNING_set(PyObject *) {
16310 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16311 return 1;
16312 }
16313
16314
16315 static PyObject *_wrap_ART_WARNING_get(void) {
16316 PyObject *pyobj;
16317
16318 {
16319 #if wxUSE_UNICODE
16320 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16321 #else
16322 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16323 #endif
16324 }
16325 return pyobj;
16326 }
16327
16328
16329 static int _wrap_ART_INFORMATION_set(PyObject *) {
16330 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16331 return 1;
16332 }
16333
16334
16335 static PyObject *_wrap_ART_INFORMATION_get(void) {
16336 PyObject *pyobj;
16337
16338 {
16339 #if wxUSE_UNICODE
16340 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16341 #else
16342 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16343 #endif
16344 }
16345 return pyobj;
16346 }
16347
16348
16349 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16350 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16351 return 1;
16352 }
16353
16354
16355 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16356 PyObject *pyobj;
16357
16358 {
16359 #if wxUSE_UNICODE
16360 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16361 #else
16362 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16363 #endif
16364 }
16365 return pyobj;
16366 }
16367
16368
16369 static int _wrap_ART_COPY_set(PyObject *) {
16370 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16371 return 1;
16372 }
16373
16374
16375 static PyObject *_wrap_ART_COPY_get(void) {
16376 PyObject *pyobj;
16377
16378 {
16379 #if wxUSE_UNICODE
16380 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16381 #else
16382 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16383 #endif
16384 }
16385 return pyobj;
16386 }
16387
16388
16389 static int _wrap_ART_CUT_set(PyObject *) {
16390 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16391 return 1;
16392 }
16393
16394
16395 static PyObject *_wrap_ART_CUT_get(void) {
16396 PyObject *pyobj;
16397
16398 {
16399 #if wxUSE_UNICODE
16400 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16401 #else
16402 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16403 #endif
16404 }
16405 return pyobj;
16406 }
16407
16408
16409 static int _wrap_ART_PASTE_set(PyObject *) {
16410 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16411 return 1;
16412 }
16413
16414
16415 static PyObject *_wrap_ART_PASTE_get(void) {
16416 PyObject *pyobj;
16417
16418 {
16419 #if wxUSE_UNICODE
16420 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16421 #else
16422 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16423 #endif
16424 }
16425 return pyobj;
16426 }
16427
16428
16429 static int _wrap_ART_DELETE_set(PyObject *) {
16430 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16431 return 1;
16432 }
16433
16434
16435 static PyObject *_wrap_ART_DELETE_get(void) {
16436 PyObject *pyobj;
16437
16438 {
16439 #if wxUSE_UNICODE
16440 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16441 #else
16442 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16443 #endif
16444 }
16445 return pyobj;
16446 }
16447
16448
16449 static int _wrap_ART_UNDO_set(PyObject *) {
16450 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16451 return 1;
16452 }
16453
16454
16455 static PyObject *_wrap_ART_UNDO_get(void) {
16456 PyObject *pyobj;
16457
16458 {
16459 #if wxUSE_UNICODE
16460 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16461 #else
16462 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16463 #endif
16464 }
16465 return pyobj;
16466 }
16467
16468
16469 static int _wrap_ART_REDO_set(PyObject *) {
16470 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16471 return 1;
16472 }
16473
16474
16475 static PyObject *_wrap_ART_REDO_get(void) {
16476 PyObject *pyobj;
16477
16478 {
16479 #if wxUSE_UNICODE
16480 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16481 #else
16482 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16483 #endif
16484 }
16485 return pyobj;
16486 }
16487
16488
16489 static int _wrap_ART_QUIT_set(PyObject *) {
16490 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16491 return 1;
16492 }
16493
16494
16495 static PyObject *_wrap_ART_QUIT_get(void) {
16496 PyObject *pyobj;
16497
16498 {
16499 #if wxUSE_UNICODE
16500 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16501 #else
16502 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16503 #endif
16504 }
16505 return pyobj;
16506 }
16507
16508
16509 static int _wrap_ART_FIND_set(PyObject *) {
16510 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16511 return 1;
16512 }
16513
16514
16515 static PyObject *_wrap_ART_FIND_get(void) {
16516 PyObject *pyobj;
16517
16518 {
16519 #if wxUSE_UNICODE
16520 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16521 #else
16522 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16523 #endif
16524 }
16525 return pyobj;
16526 }
16527
16528
16529 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16530 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16531 return 1;
16532 }
16533
16534
16535 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16536 PyObject *pyobj;
16537
16538 {
16539 #if wxUSE_UNICODE
16540 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16541 #else
16542 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16543 #endif
16544 }
16545 return pyobj;
16546 }
16547
16548
16549 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16550 PyObject *resultobj;
16551 wxPyArtProvider *result;
16552 char *kwnames[] = {
16553 NULL
16554 };
16555
16556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16557 {
16558 if (!wxPyCheckForApp()) SWIG_fail;
16559 PyThreadState* __tstate = wxPyBeginAllowThreads();
16560 result = (wxPyArtProvider *)new wxPyArtProvider();
16561
16562 wxPyEndAllowThreads(__tstate);
16563 if (PyErr_Occurred()) SWIG_fail;
16564 }
16565 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16566 return resultobj;
16567 fail:
16568 return NULL;
16569 }
16570
16571
16572 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16573 PyObject *resultobj;
16574 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16575 PyObject *arg2 = (PyObject *) 0 ;
16576 PyObject *arg3 = (PyObject *) 0 ;
16577 PyObject * obj0 = 0 ;
16578 PyObject * obj1 = 0 ;
16579 PyObject * obj2 = 0 ;
16580 char *kwnames[] = {
16581 (char *) "self",(char *) "self",(char *) "_class", NULL
16582 };
16583
16584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16586 if (SWIG_arg_fail(1)) SWIG_fail;
16587 arg2 = obj1;
16588 arg3 = obj2;
16589 {
16590 PyThreadState* __tstate = wxPyBeginAllowThreads();
16591 (arg1)->_setCallbackInfo(arg2,arg3);
16592
16593 wxPyEndAllowThreads(__tstate);
16594 if (PyErr_Occurred()) SWIG_fail;
16595 }
16596 Py_INCREF(Py_None); resultobj = Py_None;
16597 return resultobj;
16598 fail:
16599 return NULL;
16600 }
16601
16602
16603 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16604 PyObject *resultobj;
16605 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16606 PyObject * obj0 = 0 ;
16607 char *kwnames[] = {
16608 (char *) "provider", NULL
16609 };
16610
16611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16613 if (SWIG_arg_fail(1)) SWIG_fail;
16614 {
16615 PyThreadState* __tstate = wxPyBeginAllowThreads();
16616 wxPyArtProvider::PushProvider(arg1);
16617
16618 wxPyEndAllowThreads(__tstate);
16619 if (PyErr_Occurred()) SWIG_fail;
16620 }
16621 Py_INCREF(Py_None); resultobj = Py_None;
16622 return resultobj;
16623 fail:
16624 return NULL;
16625 }
16626
16627
16628 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16629 PyObject *resultobj;
16630 bool result;
16631 char *kwnames[] = {
16632 NULL
16633 };
16634
16635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16636 {
16637 PyThreadState* __tstate = wxPyBeginAllowThreads();
16638 result = (bool)wxPyArtProvider::PopProvider();
16639
16640 wxPyEndAllowThreads(__tstate);
16641 if (PyErr_Occurred()) SWIG_fail;
16642 }
16643 {
16644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16645 }
16646 return resultobj;
16647 fail:
16648 return NULL;
16649 }
16650
16651
16652 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16653 PyObject *resultobj;
16654 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16655 bool result;
16656 PyObject * obj0 = 0 ;
16657 char *kwnames[] = {
16658 (char *) "provider", NULL
16659 };
16660
16661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16663 if (SWIG_arg_fail(1)) SWIG_fail;
16664 {
16665 PyThreadState* __tstate = wxPyBeginAllowThreads();
16666 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16667
16668 wxPyEndAllowThreads(__tstate);
16669 if (PyErr_Occurred()) SWIG_fail;
16670 }
16671 {
16672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16673 }
16674 return resultobj;
16675 fail:
16676 return NULL;
16677 }
16678
16679
16680 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16681 PyObject *resultobj;
16682 wxString *arg1 = 0 ;
16683 wxString const &arg2_defvalue = wxPyART_OTHER ;
16684 wxString *arg2 = (wxString *) &arg2_defvalue ;
16685 wxSize const &arg3_defvalue = wxDefaultSize ;
16686 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16687 wxBitmap result;
16688 bool temp1 = false ;
16689 bool temp2 = false ;
16690 wxSize temp3 ;
16691 PyObject * obj0 = 0 ;
16692 PyObject * obj1 = 0 ;
16693 PyObject * obj2 = 0 ;
16694 char *kwnames[] = {
16695 (char *) "id",(char *) "client",(char *) "size", NULL
16696 };
16697
16698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16699 {
16700 arg1 = wxString_in_helper(obj0);
16701 if (arg1 == NULL) SWIG_fail;
16702 temp1 = true;
16703 }
16704 if (obj1) {
16705 {
16706 arg2 = wxString_in_helper(obj1);
16707 if (arg2 == NULL) SWIG_fail;
16708 temp2 = true;
16709 }
16710 }
16711 if (obj2) {
16712 {
16713 arg3 = &temp3;
16714 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16715 }
16716 }
16717 {
16718 if (!wxPyCheckForApp()) SWIG_fail;
16719 PyThreadState* __tstate = wxPyBeginAllowThreads();
16720 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16721
16722 wxPyEndAllowThreads(__tstate);
16723 if (PyErr_Occurred()) SWIG_fail;
16724 }
16725 {
16726 wxBitmap * resultptr;
16727 resultptr = new wxBitmap((wxBitmap &)(result));
16728 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16729 }
16730 {
16731 if (temp1)
16732 delete arg1;
16733 }
16734 {
16735 if (temp2)
16736 delete arg2;
16737 }
16738 return resultobj;
16739 fail:
16740 {
16741 if (temp1)
16742 delete arg1;
16743 }
16744 {
16745 if (temp2)
16746 delete arg2;
16747 }
16748 return NULL;
16749 }
16750
16751
16752 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16753 PyObject *resultobj;
16754 wxString *arg1 = 0 ;
16755 wxString const &arg2_defvalue = wxPyART_OTHER ;
16756 wxString *arg2 = (wxString *) &arg2_defvalue ;
16757 wxSize const &arg3_defvalue = wxDefaultSize ;
16758 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16759 wxIcon result;
16760 bool temp1 = false ;
16761 bool temp2 = false ;
16762 wxSize temp3 ;
16763 PyObject * obj0 = 0 ;
16764 PyObject * obj1 = 0 ;
16765 PyObject * obj2 = 0 ;
16766 char *kwnames[] = {
16767 (char *) "id",(char *) "client",(char *) "size", NULL
16768 };
16769
16770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16771 {
16772 arg1 = wxString_in_helper(obj0);
16773 if (arg1 == NULL) SWIG_fail;
16774 temp1 = true;
16775 }
16776 if (obj1) {
16777 {
16778 arg2 = wxString_in_helper(obj1);
16779 if (arg2 == NULL) SWIG_fail;
16780 temp2 = true;
16781 }
16782 }
16783 if (obj2) {
16784 {
16785 arg3 = &temp3;
16786 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16787 }
16788 }
16789 {
16790 if (!wxPyCheckForApp()) SWIG_fail;
16791 PyThreadState* __tstate = wxPyBeginAllowThreads();
16792 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16793
16794 wxPyEndAllowThreads(__tstate);
16795 if (PyErr_Occurred()) SWIG_fail;
16796 }
16797 {
16798 wxIcon * resultptr;
16799 resultptr = new wxIcon((wxIcon &)(result));
16800 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16801 }
16802 {
16803 if (temp1)
16804 delete arg1;
16805 }
16806 {
16807 if (temp2)
16808 delete arg2;
16809 }
16810 return resultobj;
16811 fail:
16812 {
16813 if (temp1)
16814 delete arg1;
16815 }
16816 {
16817 if (temp2)
16818 delete arg2;
16819 }
16820 return NULL;
16821 }
16822
16823
16824 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16825 PyObject *resultobj;
16826 wxString *arg1 = 0 ;
16827 bool arg2 = (bool) false ;
16828 wxSize result;
16829 bool temp1 = false ;
16830 PyObject * obj0 = 0 ;
16831 PyObject * obj1 = 0 ;
16832 char *kwnames[] = {
16833 (char *) "client",(char *) "platform_dependent", NULL
16834 };
16835
16836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16837 {
16838 arg1 = wxString_in_helper(obj0);
16839 if (arg1 == NULL) SWIG_fail;
16840 temp1 = true;
16841 }
16842 if (obj1) {
16843 {
16844 arg2 = (bool)(SWIG_As_bool(obj1));
16845 if (SWIG_arg_fail(2)) SWIG_fail;
16846 }
16847 }
16848 {
16849 PyThreadState* __tstate = wxPyBeginAllowThreads();
16850 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16851
16852 wxPyEndAllowThreads(__tstate);
16853 if (PyErr_Occurred()) SWIG_fail;
16854 }
16855 {
16856 wxSize * resultptr;
16857 resultptr = new wxSize((wxSize &)(result));
16858 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16859 }
16860 {
16861 if (temp1)
16862 delete arg1;
16863 }
16864 return resultobj;
16865 fail:
16866 {
16867 if (temp1)
16868 delete arg1;
16869 }
16870 return NULL;
16871 }
16872
16873
16874 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16875 PyObject *resultobj;
16876 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16877 PyObject * obj0 = 0 ;
16878 char *kwnames[] = {
16879 (char *) "self", NULL
16880 };
16881
16882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16884 if (SWIG_arg_fail(1)) SWIG_fail;
16885 {
16886 PyThreadState* __tstate = wxPyBeginAllowThreads();
16887 wxPyArtProvider_Destroy(arg1);
16888
16889 wxPyEndAllowThreads(__tstate);
16890 if (PyErr_Occurred()) SWIG_fail;
16891 }
16892 Py_INCREF(Py_None); resultobj = Py_None;
16893 return resultobj;
16894 fail:
16895 return NULL;
16896 }
16897
16898
16899 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16900 PyObject *obj;
16901 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16902 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16903 Py_INCREF(obj);
16904 return Py_BuildValue((char *)"");
16905 }
16906 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16907 PyObject *resultobj;
16908 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16909 PyObject * obj0 = 0 ;
16910 char *kwnames[] = {
16911 (char *) "self", NULL
16912 };
16913
16914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16916 if (SWIG_arg_fail(1)) SWIG_fail;
16917 {
16918 PyThreadState* __tstate = wxPyBeginAllowThreads();
16919 delete arg1;
16920
16921 wxPyEndAllowThreads(__tstate);
16922 if (PyErr_Occurred()) SWIG_fail;
16923 }
16924 Py_INCREF(Py_None); resultobj = Py_None;
16925 return resultobj;
16926 fail:
16927 return NULL;
16928 }
16929
16930
16931 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16932 PyObject *resultobj;
16933 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16934 wxConfigBase *result;
16935 PyObject * obj0 = 0 ;
16936 char *kwnames[] = {
16937 (char *) "config", NULL
16938 };
16939
16940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
16942 if (SWIG_arg_fail(1)) SWIG_fail;
16943 {
16944 PyThreadState* __tstate = wxPyBeginAllowThreads();
16945 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16946
16947 wxPyEndAllowThreads(__tstate);
16948 if (PyErr_Occurred()) SWIG_fail;
16949 }
16950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16951 return resultobj;
16952 fail:
16953 return NULL;
16954 }
16955
16956
16957 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16958 PyObject *resultobj;
16959 bool arg1 = (bool) true ;
16960 wxConfigBase *result;
16961 PyObject * obj0 = 0 ;
16962 char *kwnames[] = {
16963 (char *) "createOnDemand", NULL
16964 };
16965
16966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16967 if (obj0) {
16968 {
16969 arg1 = (bool)(SWIG_As_bool(obj0));
16970 if (SWIG_arg_fail(1)) SWIG_fail;
16971 }
16972 }
16973 {
16974 PyThreadState* __tstate = wxPyBeginAllowThreads();
16975 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16976
16977 wxPyEndAllowThreads(__tstate);
16978 if (PyErr_Occurred()) SWIG_fail;
16979 }
16980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16981 return resultobj;
16982 fail:
16983 return NULL;
16984 }
16985
16986
16987 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16988 PyObject *resultobj;
16989 wxConfigBase *result;
16990 char *kwnames[] = {
16991 NULL
16992 };
16993
16994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16995 {
16996 PyThreadState* __tstate = wxPyBeginAllowThreads();
16997 result = (wxConfigBase *)wxConfigBase::Create();
16998
16999 wxPyEndAllowThreads(__tstate);
17000 if (PyErr_Occurred()) SWIG_fail;
17001 }
17002 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17003 return resultobj;
17004 fail:
17005 return NULL;
17006 }
17007
17008
17009 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17010 PyObject *resultobj;
17011 char *kwnames[] = {
17012 NULL
17013 };
17014
17015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17016 {
17017 PyThreadState* __tstate = wxPyBeginAllowThreads();
17018 wxConfigBase::DontCreateOnDemand();
17019
17020 wxPyEndAllowThreads(__tstate);
17021 if (PyErr_Occurred()) SWIG_fail;
17022 }
17023 Py_INCREF(Py_None); resultobj = Py_None;
17024 return resultobj;
17025 fail:
17026 return NULL;
17027 }
17028
17029
17030 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17031 PyObject *resultobj;
17032 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17033 wxString *arg2 = 0 ;
17034 bool temp2 = false ;
17035 PyObject * obj0 = 0 ;
17036 PyObject * obj1 = 0 ;
17037 char *kwnames[] = {
17038 (char *) "self",(char *) "path", NULL
17039 };
17040
17041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17043 if (SWIG_arg_fail(1)) SWIG_fail;
17044 {
17045 arg2 = wxString_in_helper(obj1);
17046 if (arg2 == NULL) SWIG_fail;
17047 temp2 = true;
17048 }
17049 {
17050 PyThreadState* __tstate = wxPyBeginAllowThreads();
17051 (arg1)->SetPath((wxString const &)*arg2);
17052
17053 wxPyEndAllowThreads(__tstate);
17054 if (PyErr_Occurred()) SWIG_fail;
17055 }
17056 Py_INCREF(Py_None); resultobj = Py_None;
17057 {
17058 if (temp2)
17059 delete arg2;
17060 }
17061 return resultobj;
17062 fail:
17063 {
17064 if (temp2)
17065 delete arg2;
17066 }
17067 return NULL;
17068 }
17069
17070
17071 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17072 PyObject *resultobj;
17073 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17074 wxString *result;
17075 PyObject * obj0 = 0 ;
17076 char *kwnames[] = {
17077 (char *) "self", NULL
17078 };
17079
17080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17082 if (SWIG_arg_fail(1)) SWIG_fail;
17083 {
17084 PyThreadState* __tstate = wxPyBeginAllowThreads();
17085 {
17086 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17087 result = (wxString *) &_result_ref;
17088 }
17089
17090 wxPyEndAllowThreads(__tstate);
17091 if (PyErr_Occurred()) SWIG_fail;
17092 }
17093 {
17094 #if wxUSE_UNICODE
17095 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17096 #else
17097 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17098 #endif
17099 }
17100 return resultobj;
17101 fail:
17102 return NULL;
17103 }
17104
17105
17106 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17107 PyObject *resultobj;
17108 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17109 PyObject *result;
17110 PyObject * obj0 = 0 ;
17111 char *kwnames[] = {
17112 (char *) "self", NULL
17113 };
17114
17115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17117 if (SWIG_arg_fail(1)) SWIG_fail;
17118 {
17119 PyThreadState* __tstate = wxPyBeginAllowThreads();
17120 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17121
17122 wxPyEndAllowThreads(__tstate);
17123 if (PyErr_Occurred()) SWIG_fail;
17124 }
17125 resultobj = result;
17126 return resultobj;
17127 fail:
17128 return NULL;
17129 }
17130
17131
17132 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17133 PyObject *resultobj;
17134 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17135 long arg2 ;
17136 PyObject *result;
17137 PyObject * obj0 = 0 ;
17138 PyObject * obj1 = 0 ;
17139 char *kwnames[] = {
17140 (char *) "self",(char *) "index", NULL
17141 };
17142
17143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17145 if (SWIG_arg_fail(1)) SWIG_fail;
17146 {
17147 arg2 = (long)(SWIG_As_long(obj1));
17148 if (SWIG_arg_fail(2)) SWIG_fail;
17149 }
17150 {
17151 PyThreadState* __tstate = wxPyBeginAllowThreads();
17152 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17153
17154 wxPyEndAllowThreads(__tstate);
17155 if (PyErr_Occurred()) SWIG_fail;
17156 }
17157 resultobj = result;
17158 return resultobj;
17159 fail:
17160 return NULL;
17161 }
17162
17163
17164 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17165 PyObject *resultobj;
17166 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17167 PyObject *result;
17168 PyObject * obj0 = 0 ;
17169 char *kwnames[] = {
17170 (char *) "self", NULL
17171 };
17172
17173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17175 if (SWIG_arg_fail(1)) SWIG_fail;
17176 {
17177 PyThreadState* __tstate = wxPyBeginAllowThreads();
17178 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17179
17180 wxPyEndAllowThreads(__tstate);
17181 if (PyErr_Occurred()) SWIG_fail;
17182 }
17183 resultobj = result;
17184 return resultobj;
17185 fail:
17186 return NULL;
17187 }
17188
17189
17190 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17191 PyObject *resultobj;
17192 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17193 long arg2 ;
17194 PyObject *result;
17195 PyObject * obj0 = 0 ;
17196 PyObject * obj1 = 0 ;
17197 char *kwnames[] = {
17198 (char *) "self",(char *) "index", NULL
17199 };
17200
17201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17203 if (SWIG_arg_fail(1)) SWIG_fail;
17204 {
17205 arg2 = (long)(SWIG_As_long(obj1));
17206 if (SWIG_arg_fail(2)) SWIG_fail;
17207 }
17208 {
17209 PyThreadState* __tstate = wxPyBeginAllowThreads();
17210 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17211
17212 wxPyEndAllowThreads(__tstate);
17213 if (PyErr_Occurred()) SWIG_fail;
17214 }
17215 resultobj = result;
17216 return resultobj;
17217 fail:
17218 return NULL;
17219 }
17220
17221
17222 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17223 PyObject *resultobj;
17224 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17225 bool arg2 = (bool) false ;
17226 size_t result;
17227 PyObject * obj0 = 0 ;
17228 PyObject * obj1 = 0 ;
17229 char *kwnames[] = {
17230 (char *) "self",(char *) "recursive", NULL
17231 };
17232
17233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17235 if (SWIG_arg_fail(1)) SWIG_fail;
17236 if (obj1) {
17237 {
17238 arg2 = (bool)(SWIG_As_bool(obj1));
17239 if (SWIG_arg_fail(2)) SWIG_fail;
17240 }
17241 }
17242 {
17243 PyThreadState* __tstate = wxPyBeginAllowThreads();
17244 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17245
17246 wxPyEndAllowThreads(__tstate);
17247 if (PyErr_Occurred()) SWIG_fail;
17248 }
17249 {
17250 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17251 }
17252 return resultobj;
17253 fail:
17254 return NULL;
17255 }
17256
17257
17258 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17259 PyObject *resultobj;
17260 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17261 bool arg2 = (bool) false ;
17262 size_t result;
17263 PyObject * obj0 = 0 ;
17264 PyObject * obj1 = 0 ;
17265 char *kwnames[] = {
17266 (char *) "self",(char *) "recursive", NULL
17267 };
17268
17269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",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 if (obj1) {
17273 {
17274 arg2 = (bool)(SWIG_As_bool(obj1));
17275 if (SWIG_arg_fail(2)) SWIG_fail;
17276 }
17277 }
17278 {
17279 PyThreadState* __tstate = wxPyBeginAllowThreads();
17280 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17281
17282 wxPyEndAllowThreads(__tstate);
17283 if (PyErr_Occurred()) SWIG_fail;
17284 }
17285 {
17286 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17287 }
17288 return resultobj;
17289 fail:
17290 return NULL;
17291 }
17292
17293
17294 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17295 PyObject *resultobj;
17296 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17297 wxString *arg2 = 0 ;
17298 bool result;
17299 bool temp2 = false ;
17300 PyObject * obj0 = 0 ;
17301 PyObject * obj1 = 0 ;
17302 char *kwnames[] = {
17303 (char *) "self",(char *) "name", NULL
17304 };
17305
17306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17308 if (SWIG_arg_fail(1)) SWIG_fail;
17309 {
17310 arg2 = wxString_in_helper(obj1);
17311 if (arg2 == NULL) SWIG_fail;
17312 temp2 = true;
17313 }
17314 {
17315 PyThreadState* __tstate = wxPyBeginAllowThreads();
17316 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17317
17318 wxPyEndAllowThreads(__tstate);
17319 if (PyErr_Occurred()) SWIG_fail;
17320 }
17321 {
17322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17323 }
17324 {
17325 if (temp2)
17326 delete arg2;
17327 }
17328 return resultobj;
17329 fail:
17330 {
17331 if (temp2)
17332 delete arg2;
17333 }
17334 return NULL;
17335 }
17336
17337
17338 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17339 PyObject *resultobj;
17340 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17341 wxString *arg2 = 0 ;
17342 bool result;
17343 bool temp2 = false ;
17344 PyObject * obj0 = 0 ;
17345 PyObject * obj1 = 0 ;
17346 char *kwnames[] = {
17347 (char *) "self",(char *) "name", NULL
17348 };
17349
17350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17352 if (SWIG_arg_fail(1)) SWIG_fail;
17353 {
17354 arg2 = wxString_in_helper(obj1);
17355 if (arg2 == NULL) SWIG_fail;
17356 temp2 = true;
17357 }
17358 {
17359 PyThreadState* __tstate = wxPyBeginAllowThreads();
17360 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17361
17362 wxPyEndAllowThreads(__tstate);
17363 if (PyErr_Occurred()) SWIG_fail;
17364 }
17365 {
17366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17367 }
17368 {
17369 if (temp2)
17370 delete arg2;
17371 }
17372 return resultobj;
17373 fail:
17374 {
17375 if (temp2)
17376 delete arg2;
17377 }
17378 return NULL;
17379 }
17380
17381
17382 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17383 PyObject *resultobj;
17384 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17385 wxString *arg2 = 0 ;
17386 bool result;
17387 bool temp2 = false ;
17388 PyObject * obj0 = 0 ;
17389 PyObject * obj1 = 0 ;
17390 char *kwnames[] = {
17391 (char *) "self",(char *) "name", NULL
17392 };
17393
17394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17396 if (SWIG_arg_fail(1)) SWIG_fail;
17397 {
17398 arg2 = wxString_in_helper(obj1);
17399 if (arg2 == NULL) SWIG_fail;
17400 temp2 = true;
17401 }
17402 {
17403 PyThreadState* __tstate = wxPyBeginAllowThreads();
17404 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17405
17406 wxPyEndAllowThreads(__tstate);
17407 if (PyErr_Occurred()) SWIG_fail;
17408 }
17409 {
17410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17411 }
17412 {
17413 if (temp2)
17414 delete arg2;
17415 }
17416 return resultobj;
17417 fail:
17418 {
17419 if (temp2)
17420 delete arg2;
17421 }
17422 return NULL;
17423 }
17424
17425
17426 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17427 PyObject *resultobj;
17428 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17429 wxString *arg2 = 0 ;
17430 wxConfigBase::EntryType result;
17431 bool temp2 = false ;
17432 PyObject * obj0 = 0 ;
17433 PyObject * obj1 = 0 ;
17434 char *kwnames[] = {
17435 (char *) "self",(char *) "name", NULL
17436 };
17437
17438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17440 if (SWIG_arg_fail(1)) SWIG_fail;
17441 {
17442 arg2 = wxString_in_helper(obj1);
17443 if (arg2 == NULL) SWIG_fail;
17444 temp2 = true;
17445 }
17446 {
17447 PyThreadState* __tstate = wxPyBeginAllowThreads();
17448 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17449
17450 wxPyEndAllowThreads(__tstate);
17451 if (PyErr_Occurred()) SWIG_fail;
17452 }
17453 resultobj = SWIG_From_int((result));
17454 {
17455 if (temp2)
17456 delete arg2;
17457 }
17458 return resultobj;
17459 fail:
17460 {
17461 if (temp2)
17462 delete arg2;
17463 }
17464 return NULL;
17465 }
17466
17467
17468 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17469 PyObject *resultobj;
17470 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17471 wxString *arg2 = 0 ;
17472 wxString const &arg3_defvalue = wxPyEmptyString ;
17473 wxString *arg3 = (wxString *) &arg3_defvalue ;
17474 wxString result;
17475 bool temp2 = false ;
17476 bool temp3 = false ;
17477 PyObject * obj0 = 0 ;
17478 PyObject * obj1 = 0 ;
17479 PyObject * obj2 = 0 ;
17480 char *kwnames[] = {
17481 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17482 };
17483
17484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17486 if (SWIG_arg_fail(1)) SWIG_fail;
17487 {
17488 arg2 = wxString_in_helper(obj1);
17489 if (arg2 == NULL) SWIG_fail;
17490 temp2 = true;
17491 }
17492 if (obj2) {
17493 {
17494 arg3 = wxString_in_helper(obj2);
17495 if (arg3 == NULL) SWIG_fail;
17496 temp3 = true;
17497 }
17498 }
17499 {
17500 PyThreadState* __tstate = wxPyBeginAllowThreads();
17501 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17502
17503 wxPyEndAllowThreads(__tstate);
17504 if (PyErr_Occurred()) SWIG_fail;
17505 }
17506 {
17507 #if wxUSE_UNICODE
17508 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17509 #else
17510 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17511 #endif
17512 }
17513 {
17514 if (temp2)
17515 delete arg2;
17516 }
17517 {
17518 if (temp3)
17519 delete arg3;
17520 }
17521 return resultobj;
17522 fail:
17523 {
17524 if (temp2)
17525 delete arg2;
17526 }
17527 {
17528 if (temp3)
17529 delete arg3;
17530 }
17531 return NULL;
17532 }
17533
17534
17535 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17536 PyObject *resultobj;
17537 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17538 wxString *arg2 = 0 ;
17539 long arg3 = (long) 0 ;
17540 long result;
17541 bool temp2 = false ;
17542 PyObject * obj0 = 0 ;
17543 PyObject * obj1 = 0 ;
17544 PyObject * obj2 = 0 ;
17545 char *kwnames[] = {
17546 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17547 };
17548
17549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17551 if (SWIG_arg_fail(1)) SWIG_fail;
17552 {
17553 arg2 = wxString_in_helper(obj1);
17554 if (arg2 == NULL) SWIG_fail;
17555 temp2 = true;
17556 }
17557 if (obj2) {
17558 {
17559 arg3 = (long)(SWIG_As_long(obj2));
17560 if (SWIG_arg_fail(3)) SWIG_fail;
17561 }
17562 }
17563 {
17564 PyThreadState* __tstate = wxPyBeginAllowThreads();
17565 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17566
17567 wxPyEndAllowThreads(__tstate);
17568 if (PyErr_Occurred()) SWIG_fail;
17569 }
17570 {
17571 resultobj = SWIG_From_long((long)(result));
17572 }
17573 {
17574 if (temp2)
17575 delete arg2;
17576 }
17577 return resultobj;
17578 fail:
17579 {
17580 if (temp2)
17581 delete arg2;
17582 }
17583 return NULL;
17584 }
17585
17586
17587 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17588 PyObject *resultobj;
17589 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17590 wxString *arg2 = 0 ;
17591 double arg3 = (double) 0.0 ;
17592 double result;
17593 bool temp2 = false ;
17594 PyObject * obj0 = 0 ;
17595 PyObject * obj1 = 0 ;
17596 PyObject * obj2 = 0 ;
17597 char *kwnames[] = {
17598 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17599 };
17600
17601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17603 if (SWIG_arg_fail(1)) SWIG_fail;
17604 {
17605 arg2 = wxString_in_helper(obj1);
17606 if (arg2 == NULL) SWIG_fail;
17607 temp2 = true;
17608 }
17609 if (obj2) {
17610 {
17611 arg3 = (double)(SWIG_As_double(obj2));
17612 if (SWIG_arg_fail(3)) SWIG_fail;
17613 }
17614 }
17615 {
17616 PyThreadState* __tstate = wxPyBeginAllowThreads();
17617 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17618
17619 wxPyEndAllowThreads(__tstate);
17620 if (PyErr_Occurred()) SWIG_fail;
17621 }
17622 {
17623 resultobj = SWIG_From_double((double)(result));
17624 }
17625 {
17626 if (temp2)
17627 delete arg2;
17628 }
17629 return resultobj;
17630 fail:
17631 {
17632 if (temp2)
17633 delete arg2;
17634 }
17635 return NULL;
17636 }
17637
17638
17639 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17640 PyObject *resultobj;
17641 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17642 wxString *arg2 = 0 ;
17643 bool arg3 = (bool) false ;
17644 bool result;
17645 bool temp2 = false ;
17646 PyObject * obj0 = 0 ;
17647 PyObject * obj1 = 0 ;
17648 PyObject * obj2 = 0 ;
17649 char *kwnames[] = {
17650 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17651 };
17652
17653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17655 if (SWIG_arg_fail(1)) SWIG_fail;
17656 {
17657 arg2 = wxString_in_helper(obj1);
17658 if (arg2 == NULL) SWIG_fail;
17659 temp2 = true;
17660 }
17661 if (obj2) {
17662 {
17663 arg3 = (bool)(SWIG_As_bool(obj2));
17664 if (SWIG_arg_fail(3)) SWIG_fail;
17665 }
17666 }
17667 {
17668 PyThreadState* __tstate = wxPyBeginAllowThreads();
17669 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17670
17671 wxPyEndAllowThreads(__tstate);
17672 if (PyErr_Occurred()) SWIG_fail;
17673 }
17674 {
17675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17676 }
17677 {
17678 if (temp2)
17679 delete arg2;
17680 }
17681 return resultobj;
17682 fail:
17683 {
17684 if (temp2)
17685 delete arg2;
17686 }
17687 return NULL;
17688 }
17689
17690
17691 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17692 PyObject *resultobj;
17693 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17694 wxString *arg2 = 0 ;
17695 wxString *arg3 = 0 ;
17696 bool result;
17697 bool temp2 = false ;
17698 bool temp3 = false ;
17699 PyObject * obj0 = 0 ;
17700 PyObject * obj1 = 0 ;
17701 PyObject * obj2 = 0 ;
17702 char *kwnames[] = {
17703 (char *) "self",(char *) "key",(char *) "value", NULL
17704 };
17705
17706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17708 if (SWIG_arg_fail(1)) SWIG_fail;
17709 {
17710 arg2 = wxString_in_helper(obj1);
17711 if (arg2 == NULL) SWIG_fail;
17712 temp2 = true;
17713 }
17714 {
17715 arg3 = wxString_in_helper(obj2);
17716 if (arg3 == NULL) SWIG_fail;
17717 temp3 = true;
17718 }
17719 {
17720 PyThreadState* __tstate = wxPyBeginAllowThreads();
17721 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17722
17723 wxPyEndAllowThreads(__tstate);
17724 if (PyErr_Occurred()) SWIG_fail;
17725 }
17726 {
17727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17728 }
17729 {
17730 if (temp2)
17731 delete arg2;
17732 }
17733 {
17734 if (temp3)
17735 delete arg3;
17736 }
17737 return resultobj;
17738 fail:
17739 {
17740 if (temp2)
17741 delete arg2;
17742 }
17743 {
17744 if (temp3)
17745 delete arg3;
17746 }
17747 return NULL;
17748 }
17749
17750
17751 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17752 PyObject *resultobj;
17753 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17754 wxString *arg2 = 0 ;
17755 long arg3 ;
17756 bool result;
17757 bool temp2 = false ;
17758 PyObject * obj0 = 0 ;
17759 PyObject * obj1 = 0 ;
17760 PyObject * obj2 = 0 ;
17761 char *kwnames[] = {
17762 (char *) "self",(char *) "key",(char *) "value", NULL
17763 };
17764
17765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17767 if (SWIG_arg_fail(1)) SWIG_fail;
17768 {
17769 arg2 = wxString_in_helper(obj1);
17770 if (arg2 == NULL) SWIG_fail;
17771 temp2 = true;
17772 }
17773 {
17774 arg3 = (long)(SWIG_As_long(obj2));
17775 if (SWIG_arg_fail(3)) SWIG_fail;
17776 }
17777 {
17778 PyThreadState* __tstate = wxPyBeginAllowThreads();
17779 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17780
17781 wxPyEndAllowThreads(__tstate);
17782 if (PyErr_Occurred()) SWIG_fail;
17783 }
17784 {
17785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17786 }
17787 {
17788 if (temp2)
17789 delete arg2;
17790 }
17791 return resultobj;
17792 fail:
17793 {
17794 if (temp2)
17795 delete arg2;
17796 }
17797 return NULL;
17798 }
17799
17800
17801 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17802 PyObject *resultobj;
17803 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17804 wxString *arg2 = 0 ;
17805 double arg3 ;
17806 bool result;
17807 bool temp2 = false ;
17808 PyObject * obj0 = 0 ;
17809 PyObject * obj1 = 0 ;
17810 PyObject * obj2 = 0 ;
17811 char *kwnames[] = {
17812 (char *) "self",(char *) "key",(char *) "value", NULL
17813 };
17814
17815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17817 if (SWIG_arg_fail(1)) SWIG_fail;
17818 {
17819 arg2 = wxString_in_helper(obj1);
17820 if (arg2 == NULL) SWIG_fail;
17821 temp2 = true;
17822 }
17823 {
17824 arg3 = (double)(SWIG_As_double(obj2));
17825 if (SWIG_arg_fail(3)) SWIG_fail;
17826 }
17827 {
17828 PyThreadState* __tstate = wxPyBeginAllowThreads();
17829 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17830
17831 wxPyEndAllowThreads(__tstate);
17832 if (PyErr_Occurred()) SWIG_fail;
17833 }
17834 {
17835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17836 }
17837 {
17838 if (temp2)
17839 delete arg2;
17840 }
17841 return resultobj;
17842 fail:
17843 {
17844 if (temp2)
17845 delete arg2;
17846 }
17847 return NULL;
17848 }
17849
17850
17851 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17852 PyObject *resultobj;
17853 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17854 wxString *arg2 = 0 ;
17855 bool arg3 ;
17856 bool result;
17857 bool temp2 = false ;
17858 PyObject * obj0 = 0 ;
17859 PyObject * obj1 = 0 ;
17860 PyObject * obj2 = 0 ;
17861 char *kwnames[] = {
17862 (char *) "self",(char *) "key",(char *) "value", NULL
17863 };
17864
17865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17867 if (SWIG_arg_fail(1)) SWIG_fail;
17868 {
17869 arg2 = wxString_in_helper(obj1);
17870 if (arg2 == NULL) SWIG_fail;
17871 temp2 = true;
17872 }
17873 {
17874 arg3 = (bool)(SWIG_As_bool(obj2));
17875 if (SWIG_arg_fail(3)) SWIG_fail;
17876 }
17877 {
17878 PyThreadState* __tstate = wxPyBeginAllowThreads();
17879 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17880
17881 wxPyEndAllowThreads(__tstate);
17882 if (PyErr_Occurred()) SWIG_fail;
17883 }
17884 {
17885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17886 }
17887 {
17888 if (temp2)
17889 delete arg2;
17890 }
17891 return resultobj;
17892 fail:
17893 {
17894 if (temp2)
17895 delete arg2;
17896 }
17897 return NULL;
17898 }
17899
17900
17901 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17902 PyObject *resultobj;
17903 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17904 bool arg2 = (bool) false ;
17905 bool result;
17906 PyObject * obj0 = 0 ;
17907 PyObject * obj1 = 0 ;
17908 char *kwnames[] = {
17909 (char *) "self",(char *) "currentOnly", NULL
17910 };
17911
17912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17914 if (SWIG_arg_fail(1)) SWIG_fail;
17915 if (obj1) {
17916 {
17917 arg2 = (bool)(SWIG_As_bool(obj1));
17918 if (SWIG_arg_fail(2)) SWIG_fail;
17919 }
17920 }
17921 {
17922 PyThreadState* __tstate = wxPyBeginAllowThreads();
17923 result = (bool)(arg1)->Flush(arg2);
17924
17925 wxPyEndAllowThreads(__tstate);
17926 if (PyErr_Occurred()) SWIG_fail;
17927 }
17928 {
17929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17930 }
17931 return resultobj;
17932 fail:
17933 return NULL;
17934 }
17935
17936
17937 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17938 PyObject *resultobj;
17939 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17940 wxString *arg2 = 0 ;
17941 wxString *arg3 = 0 ;
17942 bool result;
17943 bool temp2 = false ;
17944 bool temp3 = false ;
17945 PyObject * obj0 = 0 ;
17946 PyObject * obj1 = 0 ;
17947 PyObject * obj2 = 0 ;
17948 char *kwnames[] = {
17949 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17950 };
17951
17952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17954 if (SWIG_arg_fail(1)) SWIG_fail;
17955 {
17956 arg2 = wxString_in_helper(obj1);
17957 if (arg2 == NULL) SWIG_fail;
17958 temp2 = true;
17959 }
17960 {
17961 arg3 = wxString_in_helper(obj2);
17962 if (arg3 == NULL) SWIG_fail;
17963 temp3 = true;
17964 }
17965 {
17966 PyThreadState* __tstate = wxPyBeginAllowThreads();
17967 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17968
17969 wxPyEndAllowThreads(__tstate);
17970 if (PyErr_Occurred()) SWIG_fail;
17971 }
17972 {
17973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17974 }
17975 {
17976 if (temp2)
17977 delete arg2;
17978 }
17979 {
17980 if (temp3)
17981 delete arg3;
17982 }
17983 return resultobj;
17984 fail:
17985 {
17986 if (temp2)
17987 delete arg2;
17988 }
17989 {
17990 if (temp3)
17991 delete arg3;
17992 }
17993 return NULL;
17994 }
17995
17996
17997 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17998 PyObject *resultobj;
17999 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18000 wxString *arg2 = 0 ;
18001 wxString *arg3 = 0 ;
18002 bool result;
18003 bool temp2 = false ;
18004 bool temp3 = false ;
18005 PyObject * obj0 = 0 ;
18006 PyObject * obj1 = 0 ;
18007 PyObject * obj2 = 0 ;
18008 char *kwnames[] = {
18009 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18010 };
18011
18012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
18013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18014 if (SWIG_arg_fail(1)) SWIG_fail;
18015 {
18016 arg2 = wxString_in_helper(obj1);
18017 if (arg2 == NULL) SWIG_fail;
18018 temp2 = true;
18019 }
18020 {
18021 arg3 = wxString_in_helper(obj2);
18022 if (arg3 == NULL) SWIG_fail;
18023 temp3 = true;
18024 }
18025 {
18026 PyThreadState* __tstate = wxPyBeginAllowThreads();
18027 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18028
18029 wxPyEndAllowThreads(__tstate);
18030 if (PyErr_Occurred()) SWIG_fail;
18031 }
18032 {
18033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18034 }
18035 {
18036 if (temp2)
18037 delete arg2;
18038 }
18039 {
18040 if (temp3)
18041 delete arg3;
18042 }
18043 return resultobj;
18044 fail:
18045 {
18046 if (temp2)
18047 delete arg2;
18048 }
18049 {
18050 if (temp3)
18051 delete arg3;
18052 }
18053 return NULL;
18054 }
18055
18056
18057 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18058 PyObject *resultobj;
18059 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18060 wxString *arg2 = 0 ;
18061 bool arg3 = (bool) true ;
18062 bool result;
18063 bool temp2 = false ;
18064 PyObject * obj0 = 0 ;
18065 PyObject * obj1 = 0 ;
18066 PyObject * obj2 = 0 ;
18067 char *kwnames[] = {
18068 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18069 };
18070
18071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18073 if (SWIG_arg_fail(1)) SWIG_fail;
18074 {
18075 arg2 = wxString_in_helper(obj1);
18076 if (arg2 == NULL) SWIG_fail;
18077 temp2 = true;
18078 }
18079 if (obj2) {
18080 {
18081 arg3 = (bool)(SWIG_As_bool(obj2));
18082 if (SWIG_arg_fail(3)) SWIG_fail;
18083 }
18084 }
18085 {
18086 PyThreadState* __tstate = wxPyBeginAllowThreads();
18087 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18088
18089 wxPyEndAllowThreads(__tstate);
18090 if (PyErr_Occurred()) SWIG_fail;
18091 }
18092 {
18093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18094 }
18095 {
18096 if (temp2)
18097 delete arg2;
18098 }
18099 return resultobj;
18100 fail:
18101 {
18102 if (temp2)
18103 delete arg2;
18104 }
18105 return NULL;
18106 }
18107
18108
18109 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18110 PyObject *resultobj;
18111 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18112 wxString *arg2 = 0 ;
18113 bool result;
18114 bool temp2 = false ;
18115 PyObject * obj0 = 0 ;
18116 PyObject * obj1 = 0 ;
18117 char *kwnames[] = {
18118 (char *) "self",(char *) "key", NULL
18119 };
18120
18121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18123 if (SWIG_arg_fail(1)) SWIG_fail;
18124 {
18125 arg2 = wxString_in_helper(obj1);
18126 if (arg2 == NULL) SWIG_fail;
18127 temp2 = true;
18128 }
18129 {
18130 PyThreadState* __tstate = wxPyBeginAllowThreads();
18131 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18132
18133 wxPyEndAllowThreads(__tstate);
18134 if (PyErr_Occurred()) SWIG_fail;
18135 }
18136 {
18137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18138 }
18139 {
18140 if (temp2)
18141 delete arg2;
18142 }
18143 return resultobj;
18144 fail:
18145 {
18146 if (temp2)
18147 delete arg2;
18148 }
18149 return NULL;
18150 }
18151
18152
18153 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18154 PyObject *resultobj;
18155 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18156 bool result;
18157 PyObject * obj0 = 0 ;
18158 char *kwnames[] = {
18159 (char *) "self", NULL
18160 };
18161
18162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18164 if (SWIG_arg_fail(1)) SWIG_fail;
18165 {
18166 PyThreadState* __tstate = wxPyBeginAllowThreads();
18167 result = (bool)(arg1)->DeleteAll();
18168
18169 wxPyEndAllowThreads(__tstate);
18170 if (PyErr_Occurred()) SWIG_fail;
18171 }
18172 {
18173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18174 }
18175 return resultobj;
18176 fail:
18177 return NULL;
18178 }
18179
18180
18181 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18182 PyObject *resultobj;
18183 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18184 bool arg2 = (bool) true ;
18185 PyObject * obj0 = 0 ;
18186 PyObject * obj1 = 0 ;
18187 char *kwnames[] = {
18188 (char *) "self",(char *) "doIt", NULL
18189 };
18190
18191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18193 if (SWIG_arg_fail(1)) SWIG_fail;
18194 if (obj1) {
18195 {
18196 arg2 = (bool)(SWIG_As_bool(obj1));
18197 if (SWIG_arg_fail(2)) SWIG_fail;
18198 }
18199 }
18200 {
18201 PyThreadState* __tstate = wxPyBeginAllowThreads();
18202 (arg1)->SetExpandEnvVars(arg2);
18203
18204 wxPyEndAllowThreads(__tstate);
18205 if (PyErr_Occurred()) SWIG_fail;
18206 }
18207 Py_INCREF(Py_None); resultobj = Py_None;
18208 return resultobj;
18209 fail:
18210 return NULL;
18211 }
18212
18213
18214 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18215 PyObject *resultobj;
18216 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18217 bool result;
18218 PyObject * obj0 = 0 ;
18219 char *kwnames[] = {
18220 (char *) "self", NULL
18221 };
18222
18223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18225 if (SWIG_arg_fail(1)) SWIG_fail;
18226 {
18227 PyThreadState* __tstate = wxPyBeginAllowThreads();
18228 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18229
18230 wxPyEndAllowThreads(__tstate);
18231 if (PyErr_Occurred()) SWIG_fail;
18232 }
18233 {
18234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18235 }
18236 return resultobj;
18237 fail:
18238 return NULL;
18239 }
18240
18241
18242 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18243 PyObject *resultobj;
18244 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18245 bool arg2 = (bool) true ;
18246 PyObject * obj0 = 0 ;
18247 PyObject * obj1 = 0 ;
18248 char *kwnames[] = {
18249 (char *) "self",(char *) "doIt", NULL
18250 };
18251
18252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18254 if (SWIG_arg_fail(1)) SWIG_fail;
18255 if (obj1) {
18256 {
18257 arg2 = (bool)(SWIG_As_bool(obj1));
18258 if (SWIG_arg_fail(2)) SWIG_fail;
18259 }
18260 }
18261 {
18262 PyThreadState* __tstate = wxPyBeginAllowThreads();
18263 (arg1)->SetRecordDefaults(arg2);
18264
18265 wxPyEndAllowThreads(__tstate);
18266 if (PyErr_Occurred()) SWIG_fail;
18267 }
18268 Py_INCREF(Py_None); resultobj = Py_None;
18269 return resultobj;
18270 fail:
18271 return NULL;
18272 }
18273
18274
18275 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18276 PyObject *resultobj;
18277 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18278 bool result;
18279 PyObject * obj0 = 0 ;
18280 char *kwnames[] = {
18281 (char *) "self", NULL
18282 };
18283
18284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18286 if (SWIG_arg_fail(1)) SWIG_fail;
18287 {
18288 PyThreadState* __tstate = wxPyBeginAllowThreads();
18289 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18290
18291 wxPyEndAllowThreads(__tstate);
18292 if (PyErr_Occurred()) SWIG_fail;
18293 }
18294 {
18295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18296 }
18297 return resultobj;
18298 fail:
18299 return NULL;
18300 }
18301
18302
18303 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18304 PyObject *resultobj;
18305 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18306 wxString *arg2 = 0 ;
18307 wxString result;
18308 bool temp2 = false ;
18309 PyObject * obj0 = 0 ;
18310 PyObject * obj1 = 0 ;
18311 char *kwnames[] = {
18312 (char *) "self",(char *) "str", NULL
18313 };
18314
18315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18317 if (SWIG_arg_fail(1)) SWIG_fail;
18318 {
18319 arg2 = wxString_in_helper(obj1);
18320 if (arg2 == NULL) SWIG_fail;
18321 temp2 = true;
18322 }
18323 {
18324 PyThreadState* __tstate = wxPyBeginAllowThreads();
18325 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18326
18327 wxPyEndAllowThreads(__tstate);
18328 if (PyErr_Occurred()) SWIG_fail;
18329 }
18330 {
18331 #if wxUSE_UNICODE
18332 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18333 #else
18334 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18335 #endif
18336 }
18337 {
18338 if (temp2)
18339 delete arg2;
18340 }
18341 return resultobj;
18342 fail:
18343 {
18344 if (temp2)
18345 delete arg2;
18346 }
18347 return NULL;
18348 }
18349
18350
18351 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18352 PyObject *resultobj;
18353 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18354 wxString result;
18355 PyObject * obj0 = 0 ;
18356 char *kwnames[] = {
18357 (char *) "self", NULL
18358 };
18359
18360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18362 if (SWIG_arg_fail(1)) SWIG_fail;
18363 {
18364 PyThreadState* __tstate = wxPyBeginAllowThreads();
18365 result = ((wxConfigBase const *)arg1)->GetAppName();
18366
18367 wxPyEndAllowThreads(__tstate);
18368 if (PyErr_Occurred()) SWIG_fail;
18369 }
18370 {
18371 #if wxUSE_UNICODE
18372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18373 #else
18374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18375 #endif
18376 }
18377 return resultobj;
18378 fail:
18379 return NULL;
18380 }
18381
18382
18383 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18384 PyObject *resultobj;
18385 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18386 wxString result;
18387 PyObject * obj0 = 0 ;
18388 char *kwnames[] = {
18389 (char *) "self", NULL
18390 };
18391
18392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18394 if (SWIG_arg_fail(1)) SWIG_fail;
18395 {
18396 PyThreadState* __tstate = wxPyBeginAllowThreads();
18397 result = ((wxConfigBase const *)arg1)->GetVendorName();
18398
18399 wxPyEndAllowThreads(__tstate);
18400 if (PyErr_Occurred()) SWIG_fail;
18401 }
18402 {
18403 #if wxUSE_UNICODE
18404 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18405 #else
18406 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18407 #endif
18408 }
18409 return resultobj;
18410 fail:
18411 return NULL;
18412 }
18413
18414
18415 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18416 PyObject *resultobj;
18417 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18418 wxString *arg2 = 0 ;
18419 bool temp2 = false ;
18420 PyObject * obj0 = 0 ;
18421 PyObject * obj1 = 0 ;
18422 char *kwnames[] = {
18423 (char *) "self",(char *) "appName", NULL
18424 };
18425
18426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18428 if (SWIG_arg_fail(1)) SWIG_fail;
18429 {
18430 arg2 = wxString_in_helper(obj1);
18431 if (arg2 == NULL) SWIG_fail;
18432 temp2 = true;
18433 }
18434 {
18435 PyThreadState* __tstate = wxPyBeginAllowThreads();
18436 (arg1)->SetAppName((wxString const &)*arg2);
18437
18438 wxPyEndAllowThreads(__tstate);
18439 if (PyErr_Occurred()) SWIG_fail;
18440 }
18441 Py_INCREF(Py_None); resultobj = Py_None;
18442 {
18443 if (temp2)
18444 delete arg2;
18445 }
18446 return resultobj;
18447 fail:
18448 {
18449 if (temp2)
18450 delete arg2;
18451 }
18452 return NULL;
18453 }
18454
18455
18456 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18457 PyObject *resultobj;
18458 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18459 wxString *arg2 = 0 ;
18460 bool temp2 = false ;
18461 PyObject * obj0 = 0 ;
18462 PyObject * obj1 = 0 ;
18463 char *kwnames[] = {
18464 (char *) "self",(char *) "vendorName", NULL
18465 };
18466
18467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18469 if (SWIG_arg_fail(1)) SWIG_fail;
18470 {
18471 arg2 = wxString_in_helper(obj1);
18472 if (arg2 == NULL) SWIG_fail;
18473 temp2 = true;
18474 }
18475 {
18476 PyThreadState* __tstate = wxPyBeginAllowThreads();
18477 (arg1)->SetVendorName((wxString const &)*arg2);
18478
18479 wxPyEndAllowThreads(__tstate);
18480 if (PyErr_Occurred()) SWIG_fail;
18481 }
18482 Py_INCREF(Py_None); resultobj = Py_None;
18483 {
18484 if (temp2)
18485 delete arg2;
18486 }
18487 return resultobj;
18488 fail:
18489 {
18490 if (temp2)
18491 delete arg2;
18492 }
18493 return NULL;
18494 }
18495
18496
18497 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18498 PyObject *resultobj;
18499 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18500 long arg2 ;
18501 PyObject * obj0 = 0 ;
18502 PyObject * obj1 = 0 ;
18503 char *kwnames[] = {
18504 (char *) "self",(char *) "style", NULL
18505 };
18506
18507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18509 if (SWIG_arg_fail(1)) SWIG_fail;
18510 {
18511 arg2 = (long)(SWIG_As_long(obj1));
18512 if (SWIG_arg_fail(2)) SWIG_fail;
18513 }
18514 {
18515 PyThreadState* __tstate = wxPyBeginAllowThreads();
18516 (arg1)->SetStyle(arg2);
18517
18518 wxPyEndAllowThreads(__tstate);
18519 if (PyErr_Occurred()) SWIG_fail;
18520 }
18521 Py_INCREF(Py_None); resultobj = Py_None;
18522 return resultobj;
18523 fail:
18524 return NULL;
18525 }
18526
18527
18528 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18529 PyObject *resultobj;
18530 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18531 long result;
18532 PyObject * obj0 = 0 ;
18533 char *kwnames[] = {
18534 (char *) "self", NULL
18535 };
18536
18537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18539 if (SWIG_arg_fail(1)) SWIG_fail;
18540 {
18541 PyThreadState* __tstate = wxPyBeginAllowThreads();
18542 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18543
18544 wxPyEndAllowThreads(__tstate);
18545 if (PyErr_Occurred()) SWIG_fail;
18546 }
18547 {
18548 resultobj = SWIG_From_long((long)(result));
18549 }
18550 return resultobj;
18551 fail:
18552 return NULL;
18553 }
18554
18555
18556 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18557 PyObject *obj;
18558 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18559 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18560 Py_INCREF(obj);
18561 return Py_BuildValue((char *)"");
18562 }
18563 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18564 PyObject *resultobj;
18565 wxString const &arg1_defvalue = wxPyEmptyString ;
18566 wxString *arg1 = (wxString *) &arg1_defvalue ;
18567 wxString const &arg2_defvalue = wxPyEmptyString ;
18568 wxString *arg2 = (wxString *) &arg2_defvalue ;
18569 wxString const &arg3_defvalue = wxPyEmptyString ;
18570 wxString *arg3 = (wxString *) &arg3_defvalue ;
18571 wxString const &arg4_defvalue = wxPyEmptyString ;
18572 wxString *arg4 = (wxString *) &arg4_defvalue ;
18573 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18574 wxConfig *result;
18575 bool temp1 = false ;
18576 bool temp2 = false ;
18577 bool temp3 = false ;
18578 bool temp4 = false ;
18579 PyObject * obj0 = 0 ;
18580 PyObject * obj1 = 0 ;
18581 PyObject * obj2 = 0 ;
18582 PyObject * obj3 = 0 ;
18583 PyObject * obj4 = 0 ;
18584 char *kwnames[] = {
18585 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18586 };
18587
18588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18589 if (obj0) {
18590 {
18591 arg1 = wxString_in_helper(obj0);
18592 if (arg1 == NULL) SWIG_fail;
18593 temp1 = true;
18594 }
18595 }
18596 if (obj1) {
18597 {
18598 arg2 = wxString_in_helper(obj1);
18599 if (arg2 == NULL) SWIG_fail;
18600 temp2 = true;
18601 }
18602 }
18603 if (obj2) {
18604 {
18605 arg3 = wxString_in_helper(obj2);
18606 if (arg3 == NULL) SWIG_fail;
18607 temp3 = true;
18608 }
18609 }
18610 if (obj3) {
18611 {
18612 arg4 = wxString_in_helper(obj3);
18613 if (arg4 == NULL) SWIG_fail;
18614 temp4 = true;
18615 }
18616 }
18617 if (obj4) {
18618 {
18619 arg5 = (long)(SWIG_As_long(obj4));
18620 if (SWIG_arg_fail(5)) SWIG_fail;
18621 }
18622 }
18623 {
18624 PyThreadState* __tstate = wxPyBeginAllowThreads();
18625 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18626
18627 wxPyEndAllowThreads(__tstate);
18628 if (PyErr_Occurred()) SWIG_fail;
18629 }
18630 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18631 {
18632 if (temp1)
18633 delete arg1;
18634 }
18635 {
18636 if (temp2)
18637 delete arg2;
18638 }
18639 {
18640 if (temp3)
18641 delete arg3;
18642 }
18643 {
18644 if (temp4)
18645 delete arg4;
18646 }
18647 return resultobj;
18648 fail:
18649 {
18650 if (temp1)
18651 delete arg1;
18652 }
18653 {
18654 if (temp2)
18655 delete arg2;
18656 }
18657 {
18658 if (temp3)
18659 delete arg3;
18660 }
18661 {
18662 if (temp4)
18663 delete arg4;
18664 }
18665 return NULL;
18666 }
18667
18668
18669 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18670 PyObject *resultobj;
18671 wxConfig *arg1 = (wxConfig *) 0 ;
18672 PyObject * obj0 = 0 ;
18673 char *kwnames[] = {
18674 (char *) "self", NULL
18675 };
18676
18677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18679 if (SWIG_arg_fail(1)) SWIG_fail;
18680 {
18681 PyThreadState* __tstate = wxPyBeginAllowThreads();
18682 delete arg1;
18683
18684 wxPyEndAllowThreads(__tstate);
18685 if (PyErr_Occurred()) SWIG_fail;
18686 }
18687 Py_INCREF(Py_None); resultobj = Py_None;
18688 return resultobj;
18689 fail:
18690 return NULL;
18691 }
18692
18693
18694 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18695 PyObject *obj;
18696 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18697 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18698 Py_INCREF(obj);
18699 return Py_BuildValue((char *)"");
18700 }
18701 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18702 PyObject *resultobj;
18703 wxString const &arg1_defvalue = wxPyEmptyString ;
18704 wxString *arg1 = (wxString *) &arg1_defvalue ;
18705 wxString const &arg2_defvalue = wxPyEmptyString ;
18706 wxString *arg2 = (wxString *) &arg2_defvalue ;
18707 wxString const &arg3_defvalue = wxPyEmptyString ;
18708 wxString *arg3 = (wxString *) &arg3_defvalue ;
18709 wxString const &arg4_defvalue = wxPyEmptyString ;
18710 wxString *arg4 = (wxString *) &arg4_defvalue ;
18711 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18712 wxFileConfig *result;
18713 bool temp1 = false ;
18714 bool temp2 = false ;
18715 bool temp3 = false ;
18716 bool temp4 = false ;
18717 PyObject * obj0 = 0 ;
18718 PyObject * obj1 = 0 ;
18719 PyObject * obj2 = 0 ;
18720 PyObject * obj3 = 0 ;
18721 PyObject * obj4 = 0 ;
18722 char *kwnames[] = {
18723 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18724 };
18725
18726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18727 if (obj0) {
18728 {
18729 arg1 = wxString_in_helper(obj0);
18730 if (arg1 == NULL) SWIG_fail;
18731 temp1 = true;
18732 }
18733 }
18734 if (obj1) {
18735 {
18736 arg2 = wxString_in_helper(obj1);
18737 if (arg2 == NULL) SWIG_fail;
18738 temp2 = true;
18739 }
18740 }
18741 if (obj2) {
18742 {
18743 arg3 = wxString_in_helper(obj2);
18744 if (arg3 == NULL) SWIG_fail;
18745 temp3 = true;
18746 }
18747 }
18748 if (obj3) {
18749 {
18750 arg4 = wxString_in_helper(obj3);
18751 if (arg4 == NULL) SWIG_fail;
18752 temp4 = true;
18753 }
18754 }
18755 if (obj4) {
18756 {
18757 arg5 = (long)(SWIG_As_long(obj4));
18758 if (SWIG_arg_fail(5)) SWIG_fail;
18759 }
18760 }
18761 {
18762 PyThreadState* __tstate = wxPyBeginAllowThreads();
18763 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18764
18765 wxPyEndAllowThreads(__tstate);
18766 if (PyErr_Occurred()) SWIG_fail;
18767 }
18768 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18769 {
18770 if (temp1)
18771 delete arg1;
18772 }
18773 {
18774 if (temp2)
18775 delete arg2;
18776 }
18777 {
18778 if (temp3)
18779 delete arg3;
18780 }
18781 {
18782 if (temp4)
18783 delete arg4;
18784 }
18785 return resultobj;
18786 fail:
18787 {
18788 if (temp1)
18789 delete arg1;
18790 }
18791 {
18792 if (temp2)
18793 delete arg2;
18794 }
18795 {
18796 if (temp3)
18797 delete arg3;
18798 }
18799 {
18800 if (temp4)
18801 delete arg4;
18802 }
18803 return NULL;
18804 }
18805
18806
18807 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18808 PyObject *resultobj;
18809 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18810 PyObject * obj0 = 0 ;
18811 char *kwnames[] = {
18812 (char *) "self", NULL
18813 };
18814
18815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18817 if (SWIG_arg_fail(1)) SWIG_fail;
18818 {
18819 PyThreadState* __tstate = wxPyBeginAllowThreads();
18820 delete arg1;
18821
18822 wxPyEndAllowThreads(__tstate);
18823 if (PyErr_Occurred()) SWIG_fail;
18824 }
18825 Py_INCREF(Py_None); resultobj = Py_None;
18826 return resultobj;
18827 fail:
18828 return NULL;
18829 }
18830
18831
18832 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18833 PyObject *obj;
18834 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18835 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18836 Py_INCREF(obj);
18837 return Py_BuildValue((char *)"");
18838 }
18839 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18840 PyObject *resultobj;
18841 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18842 wxString *arg2 = 0 ;
18843 wxConfigPathChanger *result;
18844 bool temp2 = false ;
18845 PyObject * obj0 = 0 ;
18846 PyObject * obj1 = 0 ;
18847 char *kwnames[] = {
18848 (char *) "config",(char *) "entry", NULL
18849 };
18850
18851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18853 if (SWIG_arg_fail(1)) SWIG_fail;
18854 {
18855 arg2 = wxString_in_helper(obj1);
18856 if (arg2 == NULL) SWIG_fail;
18857 temp2 = true;
18858 }
18859 {
18860 PyThreadState* __tstate = wxPyBeginAllowThreads();
18861 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18862
18863 wxPyEndAllowThreads(__tstate);
18864 if (PyErr_Occurred()) SWIG_fail;
18865 }
18866 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18867 {
18868 if (temp2)
18869 delete arg2;
18870 }
18871 return resultobj;
18872 fail:
18873 {
18874 if (temp2)
18875 delete arg2;
18876 }
18877 return NULL;
18878 }
18879
18880
18881 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18882 PyObject *resultobj;
18883 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18884 PyObject * obj0 = 0 ;
18885 char *kwnames[] = {
18886 (char *) "self", NULL
18887 };
18888
18889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18891 if (SWIG_arg_fail(1)) SWIG_fail;
18892 {
18893 PyThreadState* __tstate = wxPyBeginAllowThreads();
18894 delete arg1;
18895
18896 wxPyEndAllowThreads(__tstate);
18897 if (PyErr_Occurred()) SWIG_fail;
18898 }
18899 Py_INCREF(Py_None); resultobj = Py_None;
18900 return resultobj;
18901 fail:
18902 return NULL;
18903 }
18904
18905
18906 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18907 PyObject *resultobj;
18908 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18909 wxString *result;
18910 PyObject * obj0 = 0 ;
18911 char *kwnames[] = {
18912 (char *) "self", NULL
18913 };
18914
18915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18917 if (SWIG_arg_fail(1)) SWIG_fail;
18918 {
18919 PyThreadState* __tstate = wxPyBeginAllowThreads();
18920 {
18921 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18922 result = (wxString *) &_result_ref;
18923 }
18924
18925 wxPyEndAllowThreads(__tstate);
18926 if (PyErr_Occurred()) SWIG_fail;
18927 }
18928 {
18929 #if wxUSE_UNICODE
18930 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18931 #else
18932 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18933 #endif
18934 }
18935 return resultobj;
18936 fail:
18937 return NULL;
18938 }
18939
18940
18941 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18942 PyObject *obj;
18943 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18944 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18945 Py_INCREF(obj);
18946 return Py_BuildValue((char *)"");
18947 }
18948 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18949 PyObject *resultobj;
18950 wxString *arg1 = 0 ;
18951 wxString result;
18952 bool temp1 = false ;
18953 PyObject * obj0 = 0 ;
18954 char *kwnames[] = {
18955 (char *) "sz", NULL
18956 };
18957
18958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18959 {
18960 arg1 = wxString_in_helper(obj0);
18961 if (arg1 == NULL) SWIG_fail;
18962 temp1 = true;
18963 }
18964 {
18965 PyThreadState* __tstate = wxPyBeginAllowThreads();
18966 result = wxExpandEnvVars((wxString const &)*arg1);
18967
18968 wxPyEndAllowThreads(__tstate);
18969 if (PyErr_Occurred()) SWIG_fail;
18970 }
18971 {
18972 #if wxUSE_UNICODE
18973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18974 #else
18975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18976 #endif
18977 }
18978 {
18979 if (temp1)
18980 delete arg1;
18981 }
18982 return resultobj;
18983 fail:
18984 {
18985 if (temp1)
18986 delete arg1;
18987 }
18988 return NULL;
18989 }
18990
18991
18992 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18993 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18994 return 1;
18995 }
18996
18997
18998 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18999 PyObject *pyobj;
19000
19001 {
19002 #if wxUSE_UNICODE
19003 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19004 #else
19005 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19006 #endif
19007 }
19008 return pyobj;
19009 }
19010
19011
19012 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19013 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19014 return 1;
19015 }
19016
19017
19018 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19019 PyObject *pyobj;
19020
19021 {
19022 #if wxUSE_UNICODE
19023 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19024 #else
19025 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19026 #endif
19027 }
19028 return pyobj;
19029 }
19030
19031
19032 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19033 PyObject *resultobj;
19034 wxDateTime::Country arg1 ;
19035 PyObject * obj0 = 0 ;
19036 char *kwnames[] = {
19037 (char *) "country", NULL
19038 };
19039
19040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19041 {
19042 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19043 if (SWIG_arg_fail(1)) SWIG_fail;
19044 }
19045 {
19046 PyThreadState* __tstate = wxPyBeginAllowThreads();
19047 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19048
19049 wxPyEndAllowThreads(__tstate);
19050 if (PyErr_Occurred()) SWIG_fail;
19051 }
19052 Py_INCREF(Py_None); resultobj = Py_None;
19053 return resultobj;
19054 fail:
19055 return NULL;
19056 }
19057
19058
19059 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19060 PyObject *resultobj;
19061 wxDateTime::Country result;
19062 char *kwnames[] = {
19063 NULL
19064 };
19065
19066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19067 {
19068 PyThreadState* __tstate = wxPyBeginAllowThreads();
19069 result = (wxDateTime::Country)wxDateTime::GetCountry();
19070
19071 wxPyEndAllowThreads(__tstate);
19072 if (PyErr_Occurred()) SWIG_fail;
19073 }
19074 resultobj = SWIG_From_int((result));
19075 return resultobj;
19076 fail:
19077 return NULL;
19078 }
19079
19080
19081 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19082 PyObject *resultobj;
19083 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19084 bool result;
19085 PyObject * obj0 = 0 ;
19086 char *kwnames[] = {
19087 (char *) "country", NULL
19088 };
19089
19090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19091 if (obj0) {
19092 {
19093 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19094 if (SWIG_arg_fail(1)) SWIG_fail;
19095 }
19096 }
19097 {
19098 PyThreadState* __tstate = wxPyBeginAllowThreads();
19099 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19100
19101 wxPyEndAllowThreads(__tstate);
19102 if (PyErr_Occurred()) SWIG_fail;
19103 }
19104 {
19105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19106 }
19107 return resultobj;
19108 fail:
19109 return NULL;
19110 }
19111
19112
19113 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19114 PyObject *resultobj;
19115 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19116 int result;
19117 PyObject * obj0 = 0 ;
19118 char *kwnames[] = {
19119 (char *) "cal", NULL
19120 };
19121
19122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19123 if (obj0) {
19124 {
19125 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19126 if (SWIG_arg_fail(1)) SWIG_fail;
19127 }
19128 }
19129 {
19130 PyThreadState* __tstate = wxPyBeginAllowThreads();
19131 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19132
19133 wxPyEndAllowThreads(__tstate);
19134 if (PyErr_Occurred()) SWIG_fail;
19135 }
19136 {
19137 resultobj = SWIG_From_int((int)(result));
19138 }
19139 return resultobj;
19140 fail:
19141 return NULL;
19142 }
19143
19144
19145 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19146 PyObject *resultobj;
19147 int arg1 ;
19148 int result;
19149 PyObject * obj0 = 0 ;
19150 char *kwnames[] = {
19151 (char *) "year", NULL
19152 };
19153
19154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19155 {
19156 arg1 = (int)(SWIG_As_int(obj0));
19157 if (SWIG_arg_fail(1)) SWIG_fail;
19158 }
19159 {
19160 PyThreadState* __tstate = wxPyBeginAllowThreads();
19161 result = (int)wxDateTime::ConvertYearToBC(arg1);
19162
19163 wxPyEndAllowThreads(__tstate);
19164 if (PyErr_Occurred()) SWIG_fail;
19165 }
19166 {
19167 resultobj = SWIG_From_int((int)(result));
19168 }
19169 return resultobj;
19170 fail:
19171 return NULL;
19172 }
19173
19174
19175 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19176 PyObject *resultobj;
19177 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19178 wxDateTime::Month result;
19179 PyObject * obj0 = 0 ;
19180 char *kwnames[] = {
19181 (char *) "cal", NULL
19182 };
19183
19184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19185 if (obj0) {
19186 {
19187 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19188 if (SWIG_arg_fail(1)) SWIG_fail;
19189 }
19190 }
19191 {
19192 PyThreadState* __tstate = wxPyBeginAllowThreads();
19193 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19194
19195 wxPyEndAllowThreads(__tstate);
19196 if (PyErr_Occurred()) SWIG_fail;
19197 }
19198 resultobj = SWIG_From_int((result));
19199 return resultobj;
19200 fail:
19201 return NULL;
19202 }
19203
19204
19205 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19206 PyObject *resultobj;
19207 int arg1 = (int) wxDateTime::Inv_Year ;
19208 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19209 bool result;
19210 PyObject * obj0 = 0 ;
19211 PyObject * obj1 = 0 ;
19212 char *kwnames[] = {
19213 (char *) "year",(char *) "cal", NULL
19214 };
19215
19216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19217 if (obj0) {
19218 {
19219 arg1 = (int)(SWIG_As_int(obj0));
19220 if (SWIG_arg_fail(1)) SWIG_fail;
19221 }
19222 }
19223 if (obj1) {
19224 {
19225 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19226 if (SWIG_arg_fail(2)) SWIG_fail;
19227 }
19228 }
19229 {
19230 PyThreadState* __tstate = wxPyBeginAllowThreads();
19231 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19232
19233 wxPyEndAllowThreads(__tstate);
19234 if (PyErr_Occurred()) SWIG_fail;
19235 }
19236 {
19237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19238 }
19239 return resultobj;
19240 fail:
19241 return NULL;
19242 }
19243
19244
19245 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19246 PyObject *resultobj;
19247 int arg1 = (int) wxDateTime::Inv_Year ;
19248 int result;
19249 PyObject * obj0 = 0 ;
19250 char *kwnames[] = {
19251 (char *) "year", NULL
19252 };
19253
19254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19255 if (obj0) {
19256 {
19257 arg1 = (int)(SWIG_As_int(obj0));
19258 if (SWIG_arg_fail(1)) SWIG_fail;
19259 }
19260 }
19261 {
19262 PyThreadState* __tstate = wxPyBeginAllowThreads();
19263 result = (int)wxDateTime::GetCentury(arg1);
19264
19265 wxPyEndAllowThreads(__tstate);
19266 if (PyErr_Occurred()) SWIG_fail;
19267 }
19268 {
19269 resultobj = SWIG_From_int((int)(result));
19270 }
19271 return resultobj;
19272 fail:
19273 return NULL;
19274 }
19275
19276
19277 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19278 PyObject *resultobj;
19279 int arg1 ;
19280 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19281 int result;
19282 PyObject * obj0 = 0 ;
19283 PyObject * obj1 = 0 ;
19284 char *kwnames[] = {
19285 (char *) "year",(char *) "cal", NULL
19286 };
19287
19288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19289 {
19290 arg1 = (int)(SWIG_As_int(obj0));
19291 if (SWIG_arg_fail(1)) SWIG_fail;
19292 }
19293 if (obj1) {
19294 {
19295 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19296 if (SWIG_arg_fail(2)) SWIG_fail;
19297 }
19298 }
19299 {
19300 PyThreadState* __tstate = wxPyBeginAllowThreads();
19301 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19302
19303 wxPyEndAllowThreads(__tstate);
19304 if (PyErr_Occurred()) SWIG_fail;
19305 }
19306 {
19307 resultobj = SWIG_From_int((int)(result));
19308 }
19309 return resultobj;
19310 fail:
19311 return NULL;
19312 }
19313
19314
19315 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19316 PyObject *resultobj;
19317 wxDateTime::Month arg1 ;
19318 int arg2 = (int) wxDateTime::Inv_Year ;
19319 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19320 int result;
19321 PyObject * obj0 = 0 ;
19322 PyObject * obj1 = 0 ;
19323 PyObject * obj2 = 0 ;
19324 char *kwnames[] = {
19325 (char *) "month",(char *) "year",(char *) "cal", NULL
19326 };
19327
19328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19329 {
19330 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19331 if (SWIG_arg_fail(1)) SWIG_fail;
19332 }
19333 if (obj1) {
19334 {
19335 arg2 = (int)(SWIG_As_int(obj1));
19336 if (SWIG_arg_fail(2)) SWIG_fail;
19337 }
19338 }
19339 if (obj2) {
19340 {
19341 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19342 if (SWIG_arg_fail(3)) SWIG_fail;
19343 }
19344 }
19345 {
19346 PyThreadState* __tstate = wxPyBeginAllowThreads();
19347 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19348
19349 wxPyEndAllowThreads(__tstate);
19350 if (PyErr_Occurred()) SWIG_fail;
19351 }
19352 {
19353 resultobj = SWIG_From_int((int)(result));
19354 }
19355 return resultobj;
19356 fail:
19357 return NULL;
19358 }
19359
19360
19361 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19362 PyObject *resultobj;
19363 wxDateTime::Month arg1 ;
19364 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19365 wxString result;
19366 PyObject * obj0 = 0 ;
19367 PyObject * obj1 = 0 ;
19368 char *kwnames[] = {
19369 (char *) "month",(char *) "flags", NULL
19370 };
19371
19372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19373 {
19374 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19375 if (SWIG_arg_fail(1)) SWIG_fail;
19376 }
19377 if (obj1) {
19378 {
19379 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19380 if (SWIG_arg_fail(2)) SWIG_fail;
19381 }
19382 }
19383 {
19384 PyThreadState* __tstate = wxPyBeginAllowThreads();
19385 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19386
19387 wxPyEndAllowThreads(__tstate);
19388 if (PyErr_Occurred()) SWIG_fail;
19389 }
19390 {
19391 #if wxUSE_UNICODE
19392 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19393 #else
19394 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19395 #endif
19396 }
19397 return resultobj;
19398 fail:
19399 return NULL;
19400 }
19401
19402
19403 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19404 PyObject *resultobj;
19405 wxDateTime::WeekDay arg1 ;
19406 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19407 wxString result;
19408 PyObject * obj0 = 0 ;
19409 PyObject * obj1 = 0 ;
19410 char *kwnames[] = {
19411 (char *) "weekday",(char *) "flags", NULL
19412 };
19413
19414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19415 {
19416 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19417 if (SWIG_arg_fail(1)) SWIG_fail;
19418 }
19419 if (obj1) {
19420 {
19421 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19422 if (SWIG_arg_fail(2)) SWIG_fail;
19423 }
19424 }
19425 {
19426 PyThreadState* __tstate = wxPyBeginAllowThreads();
19427 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19428
19429 wxPyEndAllowThreads(__tstate);
19430 if (PyErr_Occurred()) SWIG_fail;
19431 }
19432 {
19433 #if wxUSE_UNICODE
19434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19435 #else
19436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19437 #endif
19438 }
19439 return resultobj;
19440 fail:
19441 return NULL;
19442 }
19443
19444
19445 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19446 PyObject *resultobj;
19447 PyObject *result;
19448 char *kwnames[] = {
19449 NULL
19450 };
19451
19452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19453 {
19454 PyThreadState* __tstate = wxPyBeginAllowThreads();
19455 result = (PyObject *)DateTime_GetAmPmStrings();
19456
19457 wxPyEndAllowThreads(__tstate);
19458 if (PyErr_Occurred()) SWIG_fail;
19459 }
19460 resultobj = result;
19461 return resultobj;
19462 fail:
19463 return NULL;
19464 }
19465
19466
19467 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19468 PyObject *resultobj;
19469 int arg1 = (int) wxDateTime::Inv_Year ;
19470 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19471 bool result;
19472 PyObject * obj0 = 0 ;
19473 PyObject * obj1 = 0 ;
19474 char *kwnames[] = {
19475 (char *) "year",(char *) "country", NULL
19476 };
19477
19478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19479 if (obj0) {
19480 {
19481 arg1 = (int)(SWIG_As_int(obj0));
19482 if (SWIG_arg_fail(1)) SWIG_fail;
19483 }
19484 }
19485 if (obj1) {
19486 {
19487 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19488 if (SWIG_arg_fail(2)) SWIG_fail;
19489 }
19490 }
19491 {
19492 PyThreadState* __tstate = wxPyBeginAllowThreads();
19493 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19494
19495 wxPyEndAllowThreads(__tstate);
19496 if (PyErr_Occurred()) SWIG_fail;
19497 }
19498 {
19499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19500 }
19501 return resultobj;
19502 fail:
19503 return NULL;
19504 }
19505
19506
19507 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19508 PyObject *resultobj;
19509 int arg1 = (int) wxDateTime::Inv_Year ;
19510 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19511 wxDateTime result;
19512 PyObject * obj0 = 0 ;
19513 PyObject * obj1 = 0 ;
19514 char *kwnames[] = {
19515 (char *) "year",(char *) "country", NULL
19516 };
19517
19518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19519 if (obj0) {
19520 {
19521 arg1 = (int)(SWIG_As_int(obj0));
19522 if (SWIG_arg_fail(1)) SWIG_fail;
19523 }
19524 }
19525 if (obj1) {
19526 {
19527 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19528 if (SWIG_arg_fail(2)) SWIG_fail;
19529 }
19530 }
19531 {
19532 PyThreadState* __tstate = wxPyBeginAllowThreads();
19533 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19534
19535 wxPyEndAllowThreads(__tstate);
19536 if (PyErr_Occurred()) SWIG_fail;
19537 }
19538 {
19539 wxDateTime * resultptr;
19540 resultptr = new wxDateTime((wxDateTime &)(result));
19541 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19542 }
19543 return resultobj;
19544 fail:
19545 return NULL;
19546 }
19547
19548
19549 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19550 PyObject *resultobj;
19551 int arg1 = (int) wxDateTime::Inv_Year ;
19552 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19553 wxDateTime result;
19554 PyObject * obj0 = 0 ;
19555 PyObject * obj1 = 0 ;
19556 char *kwnames[] = {
19557 (char *) "year",(char *) "country", NULL
19558 };
19559
19560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19561 if (obj0) {
19562 {
19563 arg1 = (int)(SWIG_As_int(obj0));
19564 if (SWIG_arg_fail(1)) SWIG_fail;
19565 }
19566 }
19567 if (obj1) {
19568 {
19569 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19570 if (SWIG_arg_fail(2)) SWIG_fail;
19571 }
19572 }
19573 {
19574 PyThreadState* __tstate = wxPyBeginAllowThreads();
19575 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19576
19577 wxPyEndAllowThreads(__tstate);
19578 if (PyErr_Occurred()) SWIG_fail;
19579 }
19580 {
19581 wxDateTime * resultptr;
19582 resultptr = new wxDateTime((wxDateTime &)(result));
19583 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19584 }
19585 return resultobj;
19586 fail:
19587 return NULL;
19588 }
19589
19590
19591 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19592 PyObject *resultobj;
19593 wxDateTime result;
19594 char *kwnames[] = {
19595 NULL
19596 };
19597
19598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19599 {
19600 PyThreadState* __tstate = wxPyBeginAllowThreads();
19601 result = wxDateTime::Now();
19602
19603 wxPyEndAllowThreads(__tstate);
19604 if (PyErr_Occurred()) SWIG_fail;
19605 }
19606 {
19607 wxDateTime * resultptr;
19608 resultptr = new wxDateTime((wxDateTime &)(result));
19609 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19610 }
19611 return resultobj;
19612 fail:
19613 return NULL;
19614 }
19615
19616
19617 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19618 PyObject *resultobj;
19619 wxDateTime result;
19620 char *kwnames[] = {
19621 NULL
19622 };
19623
19624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19625 {
19626 PyThreadState* __tstate = wxPyBeginAllowThreads();
19627 result = wxDateTime::UNow();
19628
19629 wxPyEndAllowThreads(__tstate);
19630 if (PyErr_Occurred()) SWIG_fail;
19631 }
19632 {
19633 wxDateTime * resultptr;
19634 resultptr = new wxDateTime((wxDateTime &)(result));
19635 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19636 }
19637 return resultobj;
19638 fail:
19639 return NULL;
19640 }
19641
19642
19643 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19644 PyObject *resultobj;
19645 wxDateTime result;
19646 char *kwnames[] = {
19647 NULL
19648 };
19649
19650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19651 {
19652 PyThreadState* __tstate = wxPyBeginAllowThreads();
19653 result = wxDateTime::Today();
19654
19655 wxPyEndAllowThreads(__tstate);
19656 if (PyErr_Occurred()) SWIG_fail;
19657 }
19658 {
19659 wxDateTime * resultptr;
19660 resultptr = new wxDateTime((wxDateTime &)(result));
19661 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19662 }
19663 return resultobj;
19664 fail:
19665 return NULL;
19666 }
19667
19668
19669 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19670 PyObject *resultobj;
19671 wxDateTime *result;
19672 char *kwnames[] = {
19673 NULL
19674 };
19675
19676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19677 {
19678 PyThreadState* __tstate = wxPyBeginAllowThreads();
19679 result = (wxDateTime *)new wxDateTime();
19680
19681 wxPyEndAllowThreads(__tstate);
19682 if (PyErr_Occurred()) SWIG_fail;
19683 }
19684 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19685 return resultobj;
19686 fail:
19687 return NULL;
19688 }
19689
19690
19691 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19692 PyObject *resultobj;
19693 time_t arg1 ;
19694 wxDateTime *result;
19695 PyObject * obj0 = 0 ;
19696 char *kwnames[] = {
19697 (char *) "timet", NULL
19698 };
19699
19700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19701 {
19702 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19703 if (SWIG_arg_fail(1)) SWIG_fail;
19704 }
19705 {
19706 PyThreadState* __tstate = wxPyBeginAllowThreads();
19707 result = (wxDateTime *)new wxDateTime(arg1);
19708
19709 wxPyEndAllowThreads(__tstate);
19710 if (PyErr_Occurred()) SWIG_fail;
19711 }
19712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19713 return resultobj;
19714 fail:
19715 return NULL;
19716 }
19717
19718
19719 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19720 PyObject *resultobj;
19721 double arg1 ;
19722 wxDateTime *result;
19723 PyObject * obj0 = 0 ;
19724 char *kwnames[] = {
19725 (char *) "jdn", NULL
19726 };
19727
19728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19729 {
19730 arg1 = (double)(SWIG_As_double(obj0));
19731 if (SWIG_arg_fail(1)) SWIG_fail;
19732 }
19733 {
19734 PyThreadState* __tstate = wxPyBeginAllowThreads();
19735 result = (wxDateTime *)new wxDateTime(arg1);
19736
19737 wxPyEndAllowThreads(__tstate);
19738 if (PyErr_Occurred()) SWIG_fail;
19739 }
19740 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19741 return resultobj;
19742 fail:
19743 return NULL;
19744 }
19745
19746
19747 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19748 PyObject *resultobj;
19749 int arg1 ;
19750 int arg2 = (int) 0 ;
19751 int arg3 = (int) 0 ;
19752 int arg4 = (int) 0 ;
19753 wxDateTime *result;
19754 PyObject * obj0 = 0 ;
19755 PyObject * obj1 = 0 ;
19756 PyObject * obj2 = 0 ;
19757 PyObject * obj3 = 0 ;
19758 char *kwnames[] = {
19759 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19760 };
19761
19762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19763 {
19764 arg1 = (int)(SWIG_As_int(obj0));
19765 if (SWIG_arg_fail(1)) SWIG_fail;
19766 }
19767 if (obj1) {
19768 {
19769 arg2 = (int)(SWIG_As_int(obj1));
19770 if (SWIG_arg_fail(2)) SWIG_fail;
19771 }
19772 }
19773 if (obj2) {
19774 {
19775 arg3 = (int)(SWIG_As_int(obj2));
19776 if (SWIG_arg_fail(3)) SWIG_fail;
19777 }
19778 }
19779 if (obj3) {
19780 {
19781 arg4 = (int)(SWIG_As_int(obj3));
19782 if (SWIG_arg_fail(4)) SWIG_fail;
19783 }
19784 }
19785 {
19786 PyThreadState* __tstate = wxPyBeginAllowThreads();
19787 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19788
19789 wxPyEndAllowThreads(__tstate);
19790 if (PyErr_Occurred()) SWIG_fail;
19791 }
19792 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19793 return resultobj;
19794 fail:
19795 return NULL;
19796 }
19797
19798
19799 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19800 PyObject *resultobj;
19801 int arg1 ;
19802 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19803 int arg3 = (int) wxDateTime::Inv_Year ;
19804 int arg4 = (int) 0 ;
19805 int arg5 = (int) 0 ;
19806 int arg6 = (int) 0 ;
19807 int arg7 = (int) 0 ;
19808 wxDateTime *result;
19809 PyObject * obj0 = 0 ;
19810 PyObject * obj1 = 0 ;
19811 PyObject * obj2 = 0 ;
19812 PyObject * obj3 = 0 ;
19813 PyObject * obj4 = 0 ;
19814 PyObject * obj5 = 0 ;
19815 PyObject * obj6 = 0 ;
19816 char *kwnames[] = {
19817 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19818 };
19819
19820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19821 {
19822 arg1 = (int)(SWIG_As_int(obj0));
19823 if (SWIG_arg_fail(1)) SWIG_fail;
19824 }
19825 if (obj1) {
19826 {
19827 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19828 if (SWIG_arg_fail(2)) SWIG_fail;
19829 }
19830 }
19831 if (obj2) {
19832 {
19833 arg3 = (int)(SWIG_As_int(obj2));
19834 if (SWIG_arg_fail(3)) SWIG_fail;
19835 }
19836 }
19837 if (obj3) {
19838 {
19839 arg4 = (int)(SWIG_As_int(obj3));
19840 if (SWIG_arg_fail(4)) SWIG_fail;
19841 }
19842 }
19843 if (obj4) {
19844 {
19845 arg5 = (int)(SWIG_As_int(obj4));
19846 if (SWIG_arg_fail(5)) SWIG_fail;
19847 }
19848 }
19849 if (obj5) {
19850 {
19851 arg6 = (int)(SWIG_As_int(obj5));
19852 if (SWIG_arg_fail(6)) SWIG_fail;
19853 }
19854 }
19855 if (obj6) {
19856 {
19857 arg7 = (int)(SWIG_As_int(obj6));
19858 if (SWIG_arg_fail(7)) SWIG_fail;
19859 }
19860 }
19861 {
19862 PyThreadState* __tstate = wxPyBeginAllowThreads();
19863 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19864
19865 wxPyEndAllowThreads(__tstate);
19866 if (PyErr_Occurred()) SWIG_fail;
19867 }
19868 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19869 return resultobj;
19870 fail:
19871 return NULL;
19872 }
19873
19874
19875 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19876 PyObject *resultobj;
19877 wxDateTime *arg1 = (wxDateTime *) 0 ;
19878 PyObject * obj0 = 0 ;
19879 char *kwnames[] = {
19880 (char *) "self", NULL
19881 };
19882
19883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19885 if (SWIG_arg_fail(1)) SWIG_fail;
19886 {
19887 PyThreadState* __tstate = wxPyBeginAllowThreads();
19888 delete arg1;
19889
19890 wxPyEndAllowThreads(__tstate);
19891 if (PyErr_Occurred()) SWIG_fail;
19892 }
19893 Py_INCREF(Py_None); resultobj = Py_None;
19894 return resultobj;
19895 fail:
19896 return NULL;
19897 }
19898
19899
19900 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19901 PyObject *resultobj;
19902 wxDateTime *arg1 = (wxDateTime *) 0 ;
19903 wxDateTime *result;
19904 PyObject * obj0 = 0 ;
19905 char *kwnames[] = {
19906 (char *) "self", NULL
19907 };
19908
19909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19911 if (SWIG_arg_fail(1)) SWIG_fail;
19912 {
19913 PyThreadState* __tstate = wxPyBeginAllowThreads();
19914 {
19915 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19916 result = (wxDateTime *) &_result_ref;
19917 }
19918
19919 wxPyEndAllowThreads(__tstate);
19920 if (PyErr_Occurred()) SWIG_fail;
19921 }
19922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19923 return resultobj;
19924 fail:
19925 return NULL;
19926 }
19927
19928
19929 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19930 PyObject *resultobj;
19931 wxDateTime *arg1 = (wxDateTime *) 0 ;
19932 time_t arg2 ;
19933 wxDateTime *result;
19934 PyObject * obj0 = 0 ;
19935 PyObject * obj1 = 0 ;
19936 char *kwnames[] = {
19937 (char *) "self",(char *) "timet", NULL
19938 };
19939
19940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19942 if (SWIG_arg_fail(1)) SWIG_fail;
19943 {
19944 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19945 if (SWIG_arg_fail(2)) SWIG_fail;
19946 }
19947 {
19948 PyThreadState* __tstate = wxPyBeginAllowThreads();
19949 {
19950 wxDateTime &_result_ref = (arg1)->Set(arg2);
19951 result = (wxDateTime *) &_result_ref;
19952 }
19953
19954 wxPyEndAllowThreads(__tstate);
19955 if (PyErr_Occurred()) SWIG_fail;
19956 }
19957 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19958 return resultobj;
19959 fail:
19960 return NULL;
19961 }
19962
19963
19964 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19965 PyObject *resultobj;
19966 wxDateTime *arg1 = (wxDateTime *) 0 ;
19967 double arg2 ;
19968 wxDateTime *result;
19969 PyObject * obj0 = 0 ;
19970 PyObject * obj1 = 0 ;
19971 char *kwnames[] = {
19972 (char *) "self",(char *) "jdn", NULL
19973 };
19974
19975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19977 if (SWIG_arg_fail(1)) SWIG_fail;
19978 {
19979 arg2 = (double)(SWIG_As_double(obj1));
19980 if (SWIG_arg_fail(2)) SWIG_fail;
19981 }
19982 {
19983 PyThreadState* __tstate = wxPyBeginAllowThreads();
19984 {
19985 wxDateTime &_result_ref = (arg1)->Set(arg2);
19986 result = (wxDateTime *) &_result_ref;
19987 }
19988
19989 wxPyEndAllowThreads(__tstate);
19990 if (PyErr_Occurred()) SWIG_fail;
19991 }
19992 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19993 return resultobj;
19994 fail:
19995 return NULL;
19996 }
19997
19998
19999 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20000 PyObject *resultobj;
20001 wxDateTime *arg1 = (wxDateTime *) 0 ;
20002 int arg2 ;
20003 int arg3 = (int) 0 ;
20004 int arg4 = (int) 0 ;
20005 int arg5 = (int) 0 ;
20006 wxDateTime *result;
20007 PyObject * obj0 = 0 ;
20008 PyObject * obj1 = 0 ;
20009 PyObject * obj2 = 0 ;
20010 PyObject * obj3 = 0 ;
20011 PyObject * obj4 = 0 ;
20012 char *kwnames[] = {
20013 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20014 };
20015
20016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20018 if (SWIG_arg_fail(1)) SWIG_fail;
20019 {
20020 arg2 = (int)(SWIG_As_int(obj1));
20021 if (SWIG_arg_fail(2)) SWIG_fail;
20022 }
20023 if (obj2) {
20024 {
20025 arg3 = (int)(SWIG_As_int(obj2));
20026 if (SWIG_arg_fail(3)) SWIG_fail;
20027 }
20028 }
20029 if (obj3) {
20030 {
20031 arg4 = (int)(SWIG_As_int(obj3));
20032 if (SWIG_arg_fail(4)) SWIG_fail;
20033 }
20034 }
20035 if (obj4) {
20036 {
20037 arg5 = (int)(SWIG_As_int(obj4));
20038 if (SWIG_arg_fail(5)) SWIG_fail;
20039 }
20040 }
20041 {
20042 PyThreadState* __tstate = wxPyBeginAllowThreads();
20043 {
20044 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20045 result = (wxDateTime *) &_result_ref;
20046 }
20047
20048 wxPyEndAllowThreads(__tstate);
20049 if (PyErr_Occurred()) SWIG_fail;
20050 }
20051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20052 return resultobj;
20053 fail:
20054 return NULL;
20055 }
20056
20057
20058 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20059 PyObject *resultobj;
20060 wxDateTime *arg1 = (wxDateTime *) 0 ;
20061 int arg2 ;
20062 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20063 int arg4 = (int) wxDateTime::Inv_Year ;
20064 int arg5 = (int) 0 ;
20065 int arg6 = (int) 0 ;
20066 int arg7 = (int) 0 ;
20067 int arg8 = (int) 0 ;
20068 wxDateTime *result;
20069 PyObject * obj0 = 0 ;
20070 PyObject * obj1 = 0 ;
20071 PyObject * obj2 = 0 ;
20072 PyObject * obj3 = 0 ;
20073 PyObject * obj4 = 0 ;
20074 PyObject * obj5 = 0 ;
20075 PyObject * obj6 = 0 ;
20076 PyObject * obj7 = 0 ;
20077 char *kwnames[] = {
20078 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20079 };
20080
20081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20083 if (SWIG_arg_fail(1)) SWIG_fail;
20084 {
20085 arg2 = (int)(SWIG_As_int(obj1));
20086 if (SWIG_arg_fail(2)) SWIG_fail;
20087 }
20088 if (obj2) {
20089 {
20090 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20091 if (SWIG_arg_fail(3)) SWIG_fail;
20092 }
20093 }
20094 if (obj3) {
20095 {
20096 arg4 = (int)(SWIG_As_int(obj3));
20097 if (SWIG_arg_fail(4)) SWIG_fail;
20098 }
20099 }
20100 if (obj4) {
20101 {
20102 arg5 = (int)(SWIG_As_int(obj4));
20103 if (SWIG_arg_fail(5)) SWIG_fail;
20104 }
20105 }
20106 if (obj5) {
20107 {
20108 arg6 = (int)(SWIG_As_int(obj5));
20109 if (SWIG_arg_fail(6)) SWIG_fail;
20110 }
20111 }
20112 if (obj6) {
20113 {
20114 arg7 = (int)(SWIG_As_int(obj6));
20115 if (SWIG_arg_fail(7)) SWIG_fail;
20116 }
20117 }
20118 if (obj7) {
20119 {
20120 arg8 = (int)(SWIG_As_int(obj7));
20121 if (SWIG_arg_fail(8)) SWIG_fail;
20122 }
20123 }
20124 {
20125 PyThreadState* __tstate = wxPyBeginAllowThreads();
20126 {
20127 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20128 result = (wxDateTime *) &_result_ref;
20129 }
20130
20131 wxPyEndAllowThreads(__tstate);
20132 if (PyErr_Occurred()) SWIG_fail;
20133 }
20134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20135 return resultobj;
20136 fail:
20137 return NULL;
20138 }
20139
20140
20141 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20142 PyObject *resultobj;
20143 wxDateTime *arg1 = (wxDateTime *) 0 ;
20144 wxDateTime *result;
20145 PyObject * obj0 = 0 ;
20146 char *kwnames[] = {
20147 (char *) "self", NULL
20148 };
20149
20150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20152 if (SWIG_arg_fail(1)) SWIG_fail;
20153 {
20154 PyThreadState* __tstate = wxPyBeginAllowThreads();
20155 {
20156 wxDateTime &_result_ref = (arg1)->ResetTime();
20157 result = (wxDateTime *) &_result_ref;
20158 }
20159
20160 wxPyEndAllowThreads(__tstate);
20161 if (PyErr_Occurred()) SWIG_fail;
20162 }
20163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20164 return resultobj;
20165 fail:
20166 return NULL;
20167 }
20168
20169
20170 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20171 PyObject *resultobj;
20172 wxDateTime *arg1 = (wxDateTime *) 0 ;
20173 int arg2 ;
20174 wxDateTime *result;
20175 PyObject * obj0 = 0 ;
20176 PyObject * obj1 = 0 ;
20177 char *kwnames[] = {
20178 (char *) "self",(char *) "year", NULL
20179 };
20180
20181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20183 if (SWIG_arg_fail(1)) SWIG_fail;
20184 {
20185 arg2 = (int)(SWIG_As_int(obj1));
20186 if (SWIG_arg_fail(2)) SWIG_fail;
20187 }
20188 {
20189 PyThreadState* __tstate = wxPyBeginAllowThreads();
20190 {
20191 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20192 result = (wxDateTime *) &_result_ref;
20193 }
20194
20195 wxPyEndAllowThreads(__tstate);
20196 if (PyErr_Occurred()) SWIG_fail;
20197 }
20198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20199 return resultobj;
20200 fail:
20201 return NULL;
20202 }
20203
20204
20205 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20206 PyObject *resultobj;
20207 wxDateTime *arg1 = (wxDateTime *) 0 ;
20208 wxDateTime::Month arg2 ;
20209 wxDateTime *result;
20210 PyObject * obj0 = 0 ;
20211 PyObject * obj1 = 0 ;
20212 char *kwnames[] = {
20213 (char *) "self",(char *) "month", NULL
20214 };
20215
20216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20218 if (SWIG_arg_fail(1)) SWIG_fail;
20219 {
20220 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20221 if (SWIG_arg_fail(2)) SWIG_fail;
20222 }
20223 {
20224 PyThreadState* __tstate = wxPyBeginAllowThreads();
20225 {
20226 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20227 result = (wxDateTime *) &_result_ref;
20228 }
20229
20230 wxPyEndAllowThreads(__tstate);
20231 if (PyErr_Occurred()) SWIG_fail;
20232 }
20233 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20234 return resultobj;
20235 fail:
20236 return NULL;
20237 }
20238
20239
20240 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20241 PyObject *resultobj;
20242 wxDateTime *arg1 = (wxDateTime *) 0 ;
20243 int arg2 ;
20244 wxDateTime *result;
20245 PyObject * obj0 = 0 ;
20246 PyObject * obj1 = 0 ;
20247 char *kwnames[] = {
20248 (char *) "self",(char *) "day", NULL
20249 };
20250
20251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20253 if (SWIG_arg_fail(1)) SWIG_fail;
20254 {
20255 arg2 = (int)(SWIG_As_int(obj1));
20256 if (SWIG_arg_fail(2)) SWIG_fail;
20257 }
20258 {
20259 PyThreadState* __tstate = wxPyBeginAllowThreads();
20260 {
20261 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20262 result = (wxDateTime *) &_result_ref;
20263 }
20264
20265 wxPyEndAllowThreads(__tstate);
20266 if (PyErr_Occurred()) SWIG_fail;
20267 }
20268 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20269 return resultobj;
20270 fail:
20271 return NULL;
20272 }
20273
20274
20275 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20276 PyObject *resultobj;
20277 wxDateTime *arg1 = (wxDateTime *) 0 ;
20278 int arg2 ;
20279 wxDateTime *result;
20280 PyObject * obj0 = 0 ;
20281 PyObject * obj1 = 0 ;
20282 char *kwnames[] = {
20283 (char *) "self",(char *) "hour", NULL
20284 };
20285
20286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20288 if (SWIG_arg_fail(1)) SWIG_fail;
20289 {
20290 arg2 = (int)(SWIG_As_int(obj1));
20291 if (SWIG_arg_fail(2)) SWIG_fail;
20292 }
20293 {
20294 PyThreadState* __tstate = wxPyBeginAllowThreads();
20295 {
20296 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20297 result = (wxDateTime *) &_result_ref;
20298 }
20299
20300 wxPyEndAllowThreads(__tstate);
20301 if (PyErr_Occurred()) SWIG_fail;
20302 }
20303 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20304 return resultobj;
20305 fail:
20306 return NULL;
20307 }
20308
20309
20310 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20311 PyObject *resultobj;
20312 wxDateTime *arg1 = (wxDateTime *) 0 ;
20313 int arg2 ;
20314 wxDateTime *result;
20315 PyObject * obj0 = 0 ;
20316 PyObject * obj1 = 0 ;
20317 char *kwnames[] = {
20318 (char *) "self",(char *) "minute", NULL
20319 };
20320
20321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20323 if (SWIG_arg_fail(1)) SWIG_fail;
20324 {
20325 arg2 = (int)(SWIG_As_int(obj1));
20326 if (SWIG_arg_fail(2)) SWIG_fail;
20327 }
20328 {
20329 PyThreadState* __tstate = wxPyBeginAllowThreads();
20330 {
20331 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20332 result = (wxDateTime *) &_result_ref;
20333 }
20334
20335 wxPyEndAllowThreads(__tstate);
20336 if (PyErr_Occurred()) SWIG_fail;
20337 }
20338 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20339 return resultobj;
20340 fail:
20341 return NULL;
20342 }
20343
20344
20345 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20346 PyObject *resultobj;
20347 wxDateTime *arg1 = (wxDateTime *) 0 ;
20348 int arg2 ;
20349 wxDateTime *result;
20350 PyObject * obj0 = 0 ;
20351 PyObject * obj1 = 0 ;
20352 char *kwnames[] = {
20353 (char *) "self",(char *) "second", NULL
20354 };
20355
20356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20358 if (SWIG_arg_fail(1)) SWIG_fail;
20359 {
20360 arg2 = (int)(SWIG_As_int(obj1));
20361 if (SWIG_arg_fail(2)) SWIG_fail;
20362 }
20363 {
20364 PyThreadState* __tstate = wxPyBeginAllowThreads();
20365 {
20366 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20367 result = (wxDateTime *) &_result_ref;
20368 }
20369
20370 wxPyEndAllowThreads(__tstate);
20371 if (PyErr_Occurred()) SWIG_fail;
20372 }
20373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20374 return resultobj;
20375 fail:
20376 return NULL;
20377 }
20378
20379
20380 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20381 PyObject *resultobj;
20382 wxDateTime *arg1 = (wxDateTime *) 0 ;
20383 int arg2 ;
20384 wxDateTime *result;
20385 PyObject * obj0 = 0 ;
20386 PyObject * obj1 = 0 ;
20387 char *kwnames[] = {
20388 (char *) "self",(char *) "millisecond", NULL
20389 };
20390
20391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) 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 = (int)(SWIG_As_int(obj1));
20396 if (SWIG_arg_fail(2)) SWIG_fail;
20397 }
20398 {
20399 PyThreadState* __tstate = wxPyBeginAllowThreads();
20400 {
20401 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20402 result = (wxDateTime *) &_result_ref;
20403 }
20404
20405 wxPyEndAllowThreads(__tstate);
20406 if (PyErr_Occurred()) SWIG_fail;
20407 }
20408 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20409 return resultobj;
20410 fail:
20411 return NULL;
20412 }
20413
20414
20415 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20416 PyObject *resultobj;
20417 wxDateTime *arg1 = (wxDateTime *) 0 ;
20418 wxDateTime::WeekDay arg2 ;
20419 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20420 wxDateTime *result;
20421 PyObject * obj0 = 0 ;
20422 PyObject * obj1 = 0 ;
20423 PyObject * obj2 = 0 ;
20424 char *kwnames[] = {
20425 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20426 };
20427
20428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20430 if (SWIG_arg_fail(1)) SWIG_fail;
20431 {
20432 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20433 if (SWIG_arg_fail(2)) SWIG_fail;
20434 }
20435 if (obj2) {
20436 {
20437 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20438 if (SWIG_arg_fail(3)) SWIG_fail;
20439 }
20440 }
20441 {
20442 PyThreadState* __tstate = wxPyBeginAllowThreads();
20443 {
20444 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20445 result = (wxDateTime *) &_result_ref;
20446 }
20447
20448 wxPyEndAllowThreads(__tstate);
20449 if (PyErr_Occurred()) SWIG_fail;
20450 }
20451 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20452 return resultobj;
20453 fail:
20454 return NULL;
20455 }
20456
20457
20458 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20459 PyObject *resultobj;
20460 wxDateTime *arg1 = (wxDateTime *) 0 ;
20461 wxDateTime::WeekDay arg2 ;
20462 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20463 wxDateTime result;
20464 PyObject * obj0 = 0 ;
20465 PyObject * obj1 = 0 ;
20466 PyObject * obj2 = 0 ;
20467 char *kwnames[] = {
20468 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20469 };
20470
20471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20473 if (SWIG_arg_fail(1)) SWIG_fail;
20474 {
20475 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20476 if (SWIG_arg_fail(2)) SWIG_fail;
20477 }
20478 if (obj2) {
20479 {
20480 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20481 if (SWIG_arg_fail(3)) SWIG_fail;
20482 }
20483 }
20484 {
20485 PyThreadState* __tstate = wxPyBeginAllowThreads();
20486 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20487
20488 wxPyEndAllowThreads(__tstate);
20489 if (PyErr_Occurred()) SWIG_fail;
20490 }
20491 {
20492 wxDateTime * resultptr;
20493 resultptr = new wxDateTime((wxDateTime &)(result));
20494 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20495 }
20496 return resultobj;
20497 fail:
20498 return NULL;
20499 }
20500
20501
20502 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20503 PyObject *resultobj;
20504 wxDateTime *arg1 = (wxDateTime *) 0 ;
20505 wxDateTime::WeekDay arg2 ;
20506 wxDateTime *result;
20507 PyObject * obj0 = 0 ;
20508 PyObject * obj1 = 0 ;
20509 char *kwnames[] = {
20510 (char *) "self",(char *) "weekday", NULL
20511 };
20512
20513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20515 if (SWIG_arg_fail(1)) SWIG_fail;
20516 {
20517 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20518 if (SWIG_arg_fail(2)) SWIG_fail;
20519 }
20520 {
20521 PyThreadState* __tstate = wxPyBeginAllowThreads();
20522 {
20523 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20524 result = (wxDateTime *) &_result_ref;
20525 }
20526
20527 wxPyEndAllowThreads(__tstate);
20528 if (PyErr_Occurred()) SWIG_fail;
20529 }
20530 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20531 return resultobj;
20532 fail:
20533 return NULL;
20534 }
20535
20536
20537 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20538 PyObject *resultobj;
20539 wxDateTime *arg1 = (wxDateTime *) 0 ;
20540 wxDateTime::WeekDay arg2 ;
20541 wxDateTime result;
20542 PyObject * obj0 = 0 ;
20543 PyObject * obj1 = 0 ;
20544 char *kwnames[] = {
20545 (char *) "self",(char *) "weekday", NULL
20546 };
20547
20548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20550 if (SWIG_arg_fail(1)) SWIG_fail;
20551 {
20552 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20553 if (SWIG_arg_fail(2)) SWIG_fail;
20554 }
20555 {
20556 PyThreadState* __tstate = wxPyBeginAllowThreads();
20557 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20558
20559 wxPyEndAllowThreads(__tstate);
20560 if (PyErr_Occurred()) SWIG_fail;
20561 }
20562 {
20563 wxDateTime * resultptr;
20564 resultptr = new wxDateTime((wxDateTime &)(result));
20565 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20566 }
20567 return resultobj;
20568 fail:
20569 return NULL;
20570 }
20571
20572
20573 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20574 PyObject *resultobj;
20575 wxDateTime *arg1 = (wxDateTime *) 0 ;
20576 wxDateTime::WeekDay arg2 ;
20577 wxDateTime *result;
20578 PyObject * obj0 = 0 ;
20579 PyObject * obj1 = 0 ;
20580 char *kwnames[] = {
20581 (char *) "self",(char *) "weekday", NULL
20582 };
20583
20584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20586 if (SWIG_arg_fail(1)) SWIG_fail;
20587 {
20588 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20589 if (SWIG_arg_fail(2)) SWIG_fail;
20590 }
20591 {
20592 PyThreadState* __tstate = wxPyBeginAllowThreads();
20593 {
20594 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20595 result = (wxDateTime *) &_result_ref;
20596 }
20597
20598 wxPyEndAllowThreads(__tstate);
20599 if (PyErr_Occurred()) SWIG_fail;
20600 }
20601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20602 return resultobj;
20603 fail:
20604 return NULL;
20605 }
20606
20607
20608 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20609 PyObject *resultobj;
20610 wxDateTime *arg1 = (wxDateTime *) 0 ;
20611 wxDateTime::WeekDay arg2 ;
20612 wxDateTime result;
20613 PyObject * obj0 = 0 ;
20614 PyObject * obj1 = 0 ;
20615 char *kwnames[] = {
20616 (char *) "self",(char *) "weekday", NULL
20617 };
20618
20619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20621 if (SWIG_arg_fail(1)) SWIG_fail;
20622 {
20623 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20624 if (SWIG_arg_fail(2)) SWIG_fail;
20625 }
20626 {
20627 PyThreadState* __tstate = wxPyBeginAllowThreads();
20628 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20629
20630 wxPyEndAllowThreads(__tstate);
20631 if (PyErr_Occurred()) SWIG_fail;
20632 }
20633 {
20634 wxDateTime * resultptr;
20635 resultptr = new wxDateTime((wxDateTime &)(result));
20636 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20637 }
20638 return resultobj;
20639 fail:
20640 return NULL;
20641 }
20642
20643
20644 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20645 PyObject *resultobj;
20646 wxDateTime *arg1 = (wxDateTime *) 0 ;
20647 wxDateTime::WeekDay arg2 ;
20648 int arg3 = (int) 1 ;
20649 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20650 int arg5 = (int) wxDateTime::Inv_Year ;
20651 bool result;
20652 PyObject * obj0 = 0 ;
20653 PyObject * obj1 = 0 ;
20654 PyObject * obj2 = 0 ;
20655 PyObject * obj3 = 0 ;
20656 PyObject * obj4 = 0 ;
20657 char *kwnames[] = {
20658 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20659 };
20660
20661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20663 if (SWIG_arg_fail(1)) SWIG_fail;
20664 {
20665 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20666 if (SWIG_arg_fail(2)) SWIG_fail;
20667 }
20668 if (obj2) {
20669 {
20670 arg3 = (int)(SWIG_As_int(obj2));
20671 if (SWIG_arg_fail(3)) SWIG_fail;
20672 }
20673 }
20674 if (obj3) {
20675 {
20676 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20677 if (SWIG_arg_fail(4)) SWIG_fail;
20678 }
20679 }
20680 if (obj4) {
20681 {
20682 arg5 = (int)(SWIG_As_int(obj4));
20683 if (SWIG_arg_fail(5)) SWIG_fail;
20684 }
20685 }
20686 {
20687 PyThreadState* __tstate = wxPyBeginAllowThreads();
20688 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20689
20690 wxPyEndAllowThreads(__tstate);
20691 if (PyErr_Occurred()) SWIG_fail;
20692 }
20693 {
20694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20695 }
20696 return resultobj;
20697 fail:
20698 return NULL;
20699 }
20700
20701
20702 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20703 PyObject *resultobj;
20704 wxDateTime *arg1 = (wxDateTime *) 0 ;
20705 wxDateTime::WeekDay arg2 ;
20706 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20707 int arg4 = (int) wxDateTime::Inv_Year ;
20708 bool result;
20709 PyObject * obj0 = 0 ;
20710 PyObject * obj1 = 0 ;
20711 PyObject * obj2 = 0 ;
20712 PyObject * obj3 = 0 ;
20713 char *kwnames[] = {
20714 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20715 };
20716
20717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20719 if (SWIG_arg_fail(1)) SWIG_fail;
20720 {
20721 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20722 if (SWIG_arg_fail(2)) SWIG_fail;
20723 }
20724 if (obj2) {
20725 {
20726 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20727 if (SWIG_arg_fail(3)) SWIG_fail;
20728 }
20729 }
20730 if (obj3) {
20731 {
20732 arg4 = (int)(SWIG_As_int(obj3));
20733 if (SWIG_arg_fail(4)) SWIG_fail;
20734 }
20735 }
20736 {
20737 PyThreadState* __tstate = wxPyBeginAllowThreads();
20738 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20739
20740 wxPyEndAllowThreads(__tstate);
20741 if (PyErr_Occurred()) SWIG_fail;
20742 }
20743 {
20744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20745 }
20746 return resultobj;
20747 fail:
20748 return NULL;
20749 }
20750
20751
20752 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20753 PyObject *resultobj;
20754 wxDateTime *arg1 = (wxDateTime *) 0 ;
20755 wxDateTime::WeekDay arg2 ;
20756 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20757 int arg4 = (int) wxDateTime::Inv_Year ;
20758 wxDateTime result;
20759 PyObject * obj0 = 0 ;
20760 PyObject * obj1 = 0 ;
20761 PyObject * obj2 = 0 ;
20762 PyObject * obj3 = 0 ;
20763 char *kwnames[] = {
20764 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20765 };
20766
20767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20769 if (SWIG_arg_fail(1)) SWIG_fail;
20770 {
20771 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20772 if (SWIG_arg_fail(2)) SWIG_fail;
20773 }
20774 if (obj2) {
20775 {
20776 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20777 if (SWIG_arg_fail(3)) SWIG_fail;
20778 }
20779 }
20780 if (obj3) {
20781 {
20782 arg4 = (int)(SWIG_As_int(obj3));
20783 if (SWIG_arg_fail(4)) SWIG_fail;
20784 }
20785 }
20786 {
20787 PyThreadState* __tstate = wxPyBeginAllowThreads();
20788 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20789
20790 wxPyEndAllowThreads(__tstate);
20791 if (PyErr_Occurred()) SWIG_fail;
20792 }
20793 {
20794 wxDateTime * resultptr;
20795 resultptr = new wxDateTime((wxDateTime &)(result));
20796 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20797 }
20798 return resultobj;
20799 fail:
20800 return NULL;
20801 }
20802
20803
20804 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20805 PyObject *resultobj;
20806 wxDateTime *arg1 = (wxDateTime *) 0 ;
20807 int arg2 ;
20808 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20809 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20810 bool result;
20811 PyObject * obj0 = 0 ;
20812 PyObject * obj1 = 0 ;
20813 PyObject * obj2 = 0 ;
20814 PyObject * obj3 = 0 ;
20815 char *kwnames[] = {
20816 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20817 };
20818
20819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20821 if (SWIG_arg_fail(1)) SWIG_fail;
20822 {
20823 arg2 = (int)(SWIG_As_int(obj1));
20824 if (SWIG_arg_fail(2)) SWIG_fail;
20825 }
20826 if (obj2) {
20827 {
20828 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20829 if (SWIG_arg_fail(3)) SWIG_fail;
20830 }
20831 }
20832 if (obj3) {
20833 {
20834 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20835 if (SWIG_arg_fail(4)) SWIG_fail;
20836 }
20837 }
20838 {
20839 PyThreadState* __tstate = wxPyBeginAllowThreads();
20840 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20841
20842 wxPyEndAllowThreads(__tstate);
20843 if (PyErr_Occurred()) SWIG_fail;
20844 }
20845 {
20846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20847 }
20848 return resultobj;
20849 fail:
20850 return NULL;
20851 }
20852
20853
20854 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20855 PyObject *resultobj;
20856 wxDateTime *arg1 = (wxDateTime *) 0 ;
20857 int arg2 ;
20858 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20859 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20860 wxDateTime result;
20861 PyObject * obj0 = 0 ;
20862 PyObject * obj1 = 0 ;
20863 PyObject * obj2 = 0 ;
20864 PyObject * obj3 = 0 ;
20865 char *kwnames[] = {
20866 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20867 };
20868
20869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20871 if (SWIG_arg_fail(1)) SWIG_fail;
20872 {
20873 arg2 = (int)(SWIG_As_int(obj1));
20874 if (SWIG_arg_fail(2)) SWIG_fail;
20875 }
20876 if (obj2) {
20877 {
20878 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20879 if (SWIG_arg_fail(3)) SWIG_fail;
20880 }
20881 }
20882 if (obj3) {
20883 {
20884 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20885 if (SWIG_arg_fail(4)) SWIG_fail;
20886 }
20887 }
20888 {
20889 PyThreadState* __tstate = wxPyBeginAllowThreads();
20890 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20891
20892 wxPyEndAllowThreads(__tstate);
20893 if (PyErr_Occurred()) SWIG_fail;
20894 }
20895 {
20896 wxDateTime * resultptr;
20897 resultptr = new wxDateTime((wxDateTime &)(result));
20898 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20899 }
20900 return resultobj;
20901 fail:
20902 return NULL;
20903 }
20904
20905
20906 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20907 PyObject *resultobj;
20908 int arg1 ;
20909 int arg2 ;
20910 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20911 wxDateTime result;
20912 PyObject * obj0 = 0 ;
20913 PyObject * obj1 = 0 ;
20914 PyObject * obj2 = 0 ;
20915 char *kwnames[] = {
20916 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20917 };
20918
20919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20920 {
20921 arg1 = (int)(SWIG_As_int(obj0));
20922 if (SWIG_arg_fail(1)) SWIG_fail;
20923 }
20924 {
20925 arg2 = (int)(SWIG_As_int(obj1));
20926 if (SWIG_arg_fail(2)) SWIG_fail;
20927 }
20928 if (obj2) {
20929 {
20930 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20931 if (SWIG_arg_fail(3)) SWIG_fail;
20932 }
20933 }
20934 {
20935 PyThreadState* __tstate = wxPyBeginAllowThreads();
20936 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20937
20938 wxPyEndAllowThreads(__tstate);
20939 if (PyErr_Occurred()) SWIG_fail;
20940 }
20941 {
20942 wxDateTime * resultptr;
20943 resultptr = new wxDateTime((wxDateTime &)(result));
20944 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20945 }
20946 return resultobj;
20947 fail:
20948 return NULL;
20949 }
20950
20951
20952 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20953 PyObject *resultobj;
20954 wxDateTime *arg1 = (wxDateTime *) 0 ;
20955 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20956 int arg3 = (int) wxDateTime::Inv_Year ;
20957 wxDateTime *result;
20958 PyObject * obj0 = 0 ;
20959 PyObject * obj1 = 0 ;
20960 PyObject * obj2 = 0 ;
20961 char *kwnames[] = {
20962 (char *) "self",(char *) "month",(char *) "year", NULL
20963 };
20964
20965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20967 if (SWIG_arg_fail(1)) SWIG_fail;
20968 if (obj1) {
20969 {
20970 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20971 if (SWIG_arg_fail(2)) SWIG_fail;
20972 }
20973 }
20974 if (obj2) {
20975 {
20976 arg3 = (int)(SWIG_As_int(obj2));
20977 if (SWIG_arg_fail(3)) SWIG_fail;
20978 }
20979 }
20980 {
20981 PyThreadState* __tstate = wxPyBeginAllowThreads();
20982 {
20983 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20984 result = (wxDateTime *) &_result_ref;
20985 }
20986
20987 wxPyEndAllowThreads(__tstate);
20988 if (PyErr_Occurred()) SWIG_fail;
20989 }
20990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20991 return resultobj;
20992 fail:
20993 return NULL;
20994 }
20995
20996
20997 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20998 PyObject *resultobj;
20999 wxDateTime *arg1 = (wxDateTime *) 0 ;
21000 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21001 int arg3 = (int) wxDateTime::Inv_Year ;
21002 wxDateTime result;
21003 PyObject * obj0 = 0 ;
21004 PyObject * obj1 = 0 ;
21005 PyObject * obj2 = 0 ;
21006 char *kwnames[] = {
21007 (char *) "self",(char *) "month",(char *) "year", NULL
21008 };
21009
21010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21012 if (SWIG_arg_fail(1)) SWIG_fail;
21013 if (obj1) {
21014 {
21015 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21016 if (SWIG_arg_fail(2)) SWIG_fail;
21017 }
21018 }
21019 if (obj2) {
21020 {
21021 arg3 = (int)(SWIG_As_int(obj2));
21022 if (SWIG_arg_fail(3)) SWIG_fail;
21023 }
21024 }
21025 {
21026 PyThreadState* __tstate = wxPyBeginAllowThreads();
21027 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
21028
21029 wxPyEndAllowThreads(__tstate);
21030 if (PyErr_Occurred()) SWIG_fail;
21031 }
21032 {
21033 wxDateTime * resultptr;
21034 resultptr = new wxDateTime((wxDateTime &)(result));
21035 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21036 }
21037 return resultobj;
21038 fail:
21039 return NULL;
21040 }
21041
21042
21043 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21044 PyObject *resultobj;
21045 wxDateTime *arg1 = (wxDateTime *) 0 ;
21046 int arg2 ;
21047 wxDateTime *result;
21048 PyObject * obj0 = 0 ;
21049 PyObject * obj1 = 0 ;
21050 char *kwnames[] = {
21051 (char *) "self",(char *) "yday", NULL
21052 };
21053
21054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21056 if (SWIG_arg_fail(1)) SWIG_fail;
21057 {
21058 arg2 = (int)(SWIG_As_int(obj1));
21059 if (SWIG_arg_fail(2)) SWIG_fail;
21060 }
21061 {
21062 PyThreadState* __tstate = wxPyBeginAllowThreads();
21063 {
21064 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21065 result = (wxDateTime *) &_result_ref;
21066 }
21067
21068 wxPyEndAllowThreads(__tstate);
21069 if (PyErr_Occurred()) SWIG_fail;
21070 }
21071 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21072 return resultobj;
21073 fail:
21074 return NULL;
21075 }
21076
21077
21078 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21079 PyObject *resultobj;
21080 wxDateTime *arg1 = (wxDateTime *) 0 ;
21081 int arg2 ;
21082 wxDateTime result;
21083 PyObject * obj0 = 0 ;
21084 PyObject * obj1 = 0 ;
21085 char *kwnames[] = {
21086 (char *) "self",(char *) "yday", NULL
21087 };
21088
21089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21091 if (SWIG_arg_fail(1)) SWIG_fail;
21092 {
21093 arg2 = (int)(SWIG_As_int(obj1));
21094 if (SWIG_arg_fail(2)) SWIG_fail;
21095 }
21096 {
21097 PyThreadState* __tstate = wxPyBeginAllowThreads();
21098 result = (arg1)->GetYearDay(arg2);
21099
21100 wxPyEndAllowThreads(__tstate);
21101 if (PyErr_Occurred()) SWIG_fail;
21102 }
21103 {
21104 wxDateTime * resultptr;
21105 resultptr = new wxDateTime((wxDateTime &)(result));
21106 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21107 }
21108 return resultobj;
21109 fail:
21110 return NULL;
21111 }
21112
21113
21114 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21115 PyObject *resultobj;
21116 wxDateTime *arg1 = (wxDateTime *) 0 ;
21117 double result;
21118 PyObject * obj0 = 0 ;
21119 char *kwnames[] = {
21120 (char *) "self", NULL
21121 };
21122
21123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21125 if (SWIG_arg_fail(1)) SWIG_fail;
21126 {
21127 PyThreadState* __tstate = wxPyBeginAllowThreads();
21128 result = (double)(arg1)->GetJulianDayNumber();
21129
21130 wxPyEndAllowThreads(__tstate);
21131 if (PyErr_Occurred()) SWIG_fail;
21132 }
21133 {
21134 resultobj = SWIG_From_double((double)(result));
21135 }
21136 return resultobj;
21137 fail:
21138 return NULL;
21139 }
21140
21141
21142 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21143 PyObject *resultobj;
21144 wxDateTime *arg1 = (wxDateTime *) 0 ;
21145 double result;
21146 PyObject * obj0 = 0 ;
21147 char *kwnames[] = {
21148 (char *) "self", NULL
21149 };
21150
21151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21153 if (SWIG_arg_fail(1)) SWIG_fail;
21154 {
21155 PyThreadState* __tstate = wxPyBeginAllowThreads();
21156 result = (double)(arg1)->GetJDN();
21157
21158 wxPyEndAllowThreads(__tstate);
21159 if (PyErr_Occurred()) SWIG_fail;
21160 }
21161 {
21162 resultobj = SWIG_From_double((double)(result));
21163 }
21164 return resultobj;
21165 fail:
21166 return NULL;
21167 }
21168
21169
21170 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21171 PyObject *resultobj;
21172 wxDateTime *arg1 = (wxDateTime *) 0 ;
21173 double result;
21174 PyObject * obj0 = 0 ;
21175 char *kwnames[] = {
21176 (char *) "self", NULL
21177 };
21178
21179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21181 if (SWIG_arg_fail(1)) SWIG_fail;
21182 {
21183 PyThreadState* __tstate = wxPyBeginAllowThreads();
21184 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21185
21186 wxPyEndAllowThreads(__tstate);
21187 if (PyErr_Occurred()) SWIG_fail;
21188 }
21189 {
21190 resultobj = SWIG_From_double((double)(result));
21191 }
21192 return resultobj;
21193 fail:
21194 return NULL;
21195 }
21196
21197
21198 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21199 PyObject *resultobj;
21200 wxDateTime *arg1 = (wxDateTime *) 0 ;
21201 double result;
21202 PyObject * obj0 = 0 ;
21203 char *kwnames[] = {
21204 (char *) "self", NULL
21205 };
21206
21207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21209 if (SWIG_arg_fail(1)) SWIG_fail;
21210 {
21211 PyThreadState* __tstate = wxPyBeginAllowThreads();
21212 result = (double)(arg1)->GetMJD();
21213
21214 wxPyEndAllowThreads(__tstate);
21215 if (PyErr_Occurred()) SWIG_fail;
21216 }
21217 {
21218 resultobj = SWIG_From_double((double)(result));
21219 }
21220 return resultobj;
21221 fail:
21222 return NULL;
21223 }
21224
21225
21226 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21227 PyObject *resultobj;
21228 wxDateTime *arg1 = (wxDateTime *) 0 ;
21229 double result;
21230 PyObject * obj0 = 0 ;
21231 char *kwnames[] = {
21232 (char *) "self", NULL
21233 };
21234
21235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21237 if (SWIG_arg_fail(1)) SWIG_fail;
21238 {
21239 PyThreadState* __tstate = wxPyBeginAllowThreads();
21240 result = (double)(arg1)->GetRataDie();
21241
21242 wxPyEndAllowThreads(__tstate);
21243 if (PyErr_Occurred()) SWIG_fail;
21244 }
21245 {
21246 resultobj = SWIG_From_double((double)(result));
21247 }
21248 return resultobj;
21249 fail:
21250 return NULL;
21251 }
21252
21253
21254 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21255 PyObject *resultobj;
21256 wxDateTime *arg1 = (wxDateTime *) 0 ;
21257 wxDateTime::TimeZone *arg2 = 0 ;
21258 bool arg3 = (bool) false ;
21259 wxDateTime result;
21260 bool temp2 = false ;
21261 PyObject * obj0 = 0 ;
21262 PyObject * obj1 = 0 ;
21263 PyObject * obj2 = 0 ;
21264 char *kwnames[] = {
21265 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21266 };
21267
21268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21270 if (SWIG_arg_fail(1)) SWIG_fail;
21271 {
21272 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21273 temp2 = true;
21274 }
21275 if (obj2) {
21276 {
21277 arg3 = (bool)(SWIG_As_bool(obj2));
21278 if (SWIG_arg_fail(3)) SWIG_fail;
21279 }
21280 }
21281 {
21282 PyThreadState* __tstate = wxPyBeginAllowThreads();
21283 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21284
21285 wxPyEndAllowThreads(__tstate);
21286 if (PyErr_Occurred()) SWIG_fail;
21287 }
21288 {
21289 wxDateTime * resultptr;
21290 resultptr = new wxDateTime((wxDateTime &)(result));
21291 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21292 }
21293 {
21294 if (temp2) delete arg2;
21295 }
21296 return resultobj;
21297 fail:
21298 {
21299 if (temp2) delete arg2;
21300 }
21301 return NULL;
21302 }
21303
21304
21305 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21306 PyObject *resultobj;
21307 wxDateTime *arg1 = (wxDateTime *) 0 ;
21308 wxDateTime::TimeZone *arg2 = 0 ;
21309 bool arg3 = (bool) false ;
21310 wxDateTime *result;
21311 bool temp2 = false ;
21312 PyObject * obj0 = 0 ;
21313 PyObject * obj1 = 0 ;
21314 PyObject * obj2 = 0 ;
21315 char *kwnames[] = {
21316 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21317 };
21318
21319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21321 if (SWIG_arg_fail(1)) SWIG_fail;
21322 {
21323 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21324 temp2 = true;
21325 }
21326 if (obj2) {
21327 {
21328 arg3 = (bool)(SWIG_As_bool(obj2));
21329 if (SWIG_arg_fail(3)) SWIG_fail;
21330 }
21331 }
21332 {
21333 PyThreadState* __tstate = wxPyBeginAllowThreads();
21334 {
21335 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21336 result = (wxDateTime *) &_result_ref;
21337 }
21338
21339 wxPyEndAllowThreads(__tstate);
21340 if (PyErr_Occurred()) SWIG_fail;
21341 }
21342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21343 {
21344 if (temp2) delete arg2;
21345 }
21346 return resultobj;
21347 fail:
21348 {
21349 if (temp2) delete arg2;
21350 }
21351 return NULL;
21352 }
21353
21354
21355 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21356 PyObject *resultobj;
21357 wxDateTime *arg1 = (wxDateTime *) 0 ;
21358 bool arg2 = (bool) false ;
21359 wxDateTime result;
21360 PyObject * obj0 = 0 ;
21361 PyObject * obj1 = 0 ;
21362 char *kwnames[] = {
21363 (char *) "self",(char *) "noDST", NULL
21364 };
21365
21366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21368 if (SWIG_arg_fail(1)) SWIG_fail;
21369 if (obj1) {
21370 {
21371 arg2 = (bool)(SWIG_As_bool(obj1));
21372 if (SWIG_arg_fail(2)) SWIG_fail;
21373 }
21374 }
21375 {
21376 PyThreadState* __tstate = wxPyBeginAllowThreads();
21377 result = (arg1)->ToGMT(arg2);
21378
21379 wxPyEndAllowThreads(__tstate);
21380 if (PyErr_Occurred()) SWIG_fail;
21381 }
21382 {
21383 wxDateTime * resultptr;
21384 resultptr = new wxDateTime((wxDateTime &)(result));
21385 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21386 }
21387 return resultobj;
21388 fail:
21389 return NULL;
21390 }
21391
21392
21393 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21394 PyObject *resultobj;
21395 wxDateTime *arg1 = (wxDateTime *) 0 ;
21396 bool arg2 = (bool) false ;
21397 wxDateTime *result;
21398 PyObject * obj0 = 0 ;
21399 PyObject * obj1 = 0 ;
21400 char *kwnames[] = {
21401 (char *) "self",(char *) "noDST", NULL
21402 };
21403
21404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",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 = (bool)(SWIG_As_bool(obj1));
21410 if (SWIG_arg_fail(2)) SWIG_fail;
21411 }
21412 }
21413 {
21414 PyThreadState* __tstate = wxPyBeginAllowThreads();
21415 {
21416 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21417 result = (wxDateTime *) &_result_ref;
21418 }
21419
21420 wxPyEndAllowThreads(__tstate);
21421 if (PyErr_Occurred()) SWIG_fail;
21422 }
21423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21424 return resultobj;
21425 fail:
21426 return NULL;
21427 }
21428
21429
21430 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21431 PyObject *resultobj;
21432 wxDateTime *arg1 = (wxDateTime *) 0 ;
21433 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21434 int result;
21435 PyObject * obj0 = 0 ;
21436 PyObject * obj1 = 0 ;
21437 char *kwnames[] = {
21438 (char *) "self",(char *) "country", NULL
21439 };
21440
21441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21443 if (SWIG_arg_fail(1)) SWIG_fail;
21444 if (obj1) {
21445 {
21446 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21447 if (SWIG_arg_fail(2)) SWIG_fail;
21448 }
21449 }
21450 {
21451 PyThreadState* __tstate = wxPyBeginAllowThreads();
21452 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21453
21454 wxPyEndAllowThreads(__tstate);
21455 if (PyErr_Occurred()) SWIG_fail;
21456 }
21457 {
21458 resultobj = SWIG_From_int((int)(result));
21459 }
21460 return resultobj;
21461 fail:
21462 return NULL;
21463 }
21464
21465
21466 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21467 PyObject *resultobj;
21468 wxDateTime *arg1 = (wxDateTime *) 0 ;
21469 bool result;
21470 PyObject * obj0 = 0 ;
21471 char *kwnames[] = {
21472 (char *) "self", NULL
21473 };
21474
21475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21477 if (SWIG_arg_fail(1)) SWIG_fail;
21478 {
21479 PyThreadState* __tstate = wxPyBeginAllowThreads();
21480 result = (bool)((wxDateTime const *)arg1)->IsValid();
21481
21482 wxPyEndAllowThreads(__tstate);
21483 if (PyErr_Occurred()) SWIG_fail;
21484 }
21485 {
21486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21487 }
21488 return resultobj;
21489 fail:
21490 return NULL;
21491 }
21492
21493
21494 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21495 PyObject *resultobj;
21496 wxDateTime *arg1 = (wxDateTime *) 0 ;
21497 time_t result;
21498 PyObject * obj0 = 0 ;
21499 char *kwnames[] = {
21500 (char *) "self", NULL
21501 };
21502
21503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21505 if (SWIG_arg_fail(1)) SWIG_fail;
21506 {
21507 PyThreadState* __tstate = wxPyBeginAllowThreads();
21508 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21509
21510 wxPyEndAllowThreads(__tstate);
21511 if (PyErr_Occurred()) SWIG_fail;
21512 }
21513 {
21514 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21515 }
21516 return resultobj;
21517 fail:
21518 return NULL;
21519 }
21520
21521
21522 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21523 PyObject *resultobj;
21524 wxDateTime *arg1 = (wxDateTime *) 0 ;
21525 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21526 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21527 int result;
21528 bool temp2 = false ;
21529 PyObject * obj0 = 0 ;
21530 PyObject * obj1 = 0 ;
21531 char *kwnames[] = {
21532 (char *) "self",(char *) "tz", NULL
21533 };
21534
21535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21537 if (SWIG_arg_fail(1)) SWIG_fail;
21538 if (obj1) {
21539 {
21540 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21541 temp2 = true;
21542 }
21543 }
21544 {
21545 PyThreadState* __tstate = wxPyBeginAllowThreads();
21546 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21547
21548 wxPyEndAllowThreads(__tstate);
21549 if (PyErr_Occurred()) SWIG_fail;
21550 }
21551 {
21552 resultobj = SWIG_From_int((int)(result));
21553 }
21554 {
21555 if (temp2) delete arg2;
21556 }
21557 return resultobj;
21558 fail:
21559 {
21560 if (temp2) delete arg2;
21561 }
21562 return NULL;
21563 }
21564
21565
21566 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21567 PyObject *resultobj;
21568 wxDateTime *arg1 = (wxDateTime *) 0 ;
21569 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21570 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21571 wxDateTime::Month result;
21572 bool temp2 = false ;
21573 PyObject * obj0 = 0 ;
21574 PyObject * obj1 = 0 ;
21575 char *kwnames[] = {
21576 (char *) "self",(char *) "tz", NULL
21577 };
21578
21579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21581 if (SWIG_arg_fail(1)) SWIG_fail;
21582 if (obj1) {
21583 {
21584 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21585 temp2 = true;
21586 }
21587 }
21588 {
21589 PyThreadState* __tstate = wxPyBeginAllowThreads();
21590 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21591
21592 wxPyEndAllowThreads(__tstate);
21593 if (PyErr_Occurred()) SWIG_fail;
21594 }
21595 resultobj = SWIG_From_int((result));
21596 {
21597 if (temp2) delete arg2;
21598 }
21599 return resultobj;
21600 fail:
21601 {
21602 if (temp2) delete arg2;
21603 }
21604 return NULL;
21605 }
21606
21607
21608 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21609 PyObject *resultobj;
21610 wxDateTime *arg1 = (wxDateTime *) 0 ;
21611 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21612 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21613 int result;
21614 bool temp2 = false ;
21615 PyObject * obj0 = 0 ;
21616 PyObject * obj1 = 0 ;
21617 char *kwnames[] = {
21618 (char *) "self",(char *) "tz", NULL
21619 };
21620
21621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21623 if (SWIG_arg_fail(1)) SWIG_fail;
21624 if (obj1) {
21625 {
21626 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21627 temp2 = true;
21628 }
21629 }
21630 {
21631 PyThreadState* __tstate = wxPyBeginAllowThreads();
21632 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21633
21634 wxPyEndAllowThreads(__tstate);
21635 if (PyErr_Occurred()) SWIG_fail;
21636 }
21637 {
21638 resultobj = SWIG_From_int((int)(result));
21639 }
21640 {
21641 if (temp2) delete arg2;
21642 }
21643 return resultobj;
21644 fail:
21645 {
21646 if (temp2) delete arg2;
21647 }
21648 return NULL;
21649 }
21650
21651
21652 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21653 PyObject *resultobj;
21654 wxDateTime *arg1 = (wxDateTime *) 0 ;
21655 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21656 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21657 wxDateTime::WeekDay result;
21658 bool temp2 = false ;
21659 PyObject * obj0 = 0 ;
21660 PyObject * obj1 = 0 ;
21661 char *kwnames[] = {
21662 (char *) "self",(char *) "tz", NULL
21663 };
21664
21665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21667 if (SWIG_arg_fail(1)) SWIG_fail;
21668 if (obj1) {
21669 {
21670 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21671 temp2 = true;
21672 }
21673 }
21674 {
21675 PyThreadState* __tstate = wxPyBeginAllowThreads();
21676 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21677
21678 wxPyEndAllowThreads(__tstate);
21679 if (PyErr_Occurred()) SWIG_fail;
21680 }
21681 resultobj = SWIG_From_int((result));
21682 {
21683 if (temp2) delete arg2;
21684 }
21685 return resultobj;
21686 fail:
21687 {
21688 if (temp2) delete arg2;
21689 }
21690 return NULL;
21691 }
21692
21693
21694 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21695 PyObject *resultobj;
21696 wxDateTime *arg1 = (wxDateTime *) 0 ;
21697 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21698 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21699 int result;
21700 bool temp2 = false ;
21701 PyObject * obj0 = 0 ;
21702 PyObject * obj1 = 0 ;
21703 char *kwnames[] = {
21704 (char *) "self",(char *) "tz", NULL
21705 };
21706
21707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21709 if (SWIG_arg_fail(1)) SWIG_fail;
21710 if (obj1) {
21711 {
21712 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21713 temp2 = true;
21714 }
21715 }
21716 {
21717 PyThreadState* __tstate = wxPyBeginAllowThreads();
21718 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21719
21720 wxPyEndAllowThreads(__tstate);
21721 if (PyErr_Occurred()) SWIG_fail;
21722 }
21723 {
21724 resultobj = SWIG_From_int((int)(result));
21725 }
21726 {
21727 if (temp2) delete arg2;
21728 }
21729 return resultobj;
21730 fail:
21731 {
21732 if (temp2) delete arg2;
21733 }
21734 return NULL;
21735 }
21736
21737
21738 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21739 PyObject *resultobj;
21740 wxDateTime *arg1 = (wxDateTime *) 0 ;
21741 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21742 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21743 int result;
21744 bool temp2 = false ;
21745 PyObject * obj0 = 0 ;
21746 PyObject * obj1 = 0 ;
21747 char *kwnames[] = {
21748 (char *) "self",(char *) "tz", NULL
21749 };
21750
21751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21753 if (SWIG_arg_fail(1)) SWIG_fail;
21754 if (obj1) {
21755 {
21756 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21757 temp2 = true;
21758 }
21759 }
21760 {
21761 PyThreadState* __tstate = wxPyBeginAllowThreads();
21762 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21763
21764 wxPyEndAllowThreads(__tstate);
21765 if (PyErr_Occurred()) SWIG_fail;
21766 }
21767 {
21768 resultobj = SWIG_From_int((int)(result));
21769 }
21770 {
21771 if (temp2) delete arg2;
21772 }
21773 return resultobj;
21774 fail:
21775 {
21776 if (temp2) delete arg2;
21777 }
21778 return NULL;
21779 }
21780
21781
21782 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21783 PyObject *resultobj;
21784 wxDateTime *arg1 = (wxDateTime *) 0 ;
21785 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21786 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21787 int result;
21788 bool temp2 = false ;
21789 PyObject * obj0 = 0 ;
21790 PyObject * obj1 = 0 ;
21791 char *kwnames[] = {
21792 (char *) "self",(char *) "tz", NULL
21793 };
21794
21795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21797 if (SWIG_arg_fail(1)) SWIG_fail;
21798 if (obj1) {
21799 {
21800 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21801 temp2 = true;
21802 }
21803 }
21804 {
21805 PyThreadState* __tstate = wxPyBeginAllowThreads();
21806 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21807
21808 wxPyEndAllowThreads(__tstate);
21809 if (PyErr_Occurred()) SWIG_fail;
21810 }
21811 {
21812 resultobj = SWIG_From_int((int)(result));
21813 }
21814 {
21815 if (temp2) delete arg2;
21816 }
21817 return resultobj;
21818 fail:
21819 {
21820 if (temp2) delete arg2;
21821 }
21822 return NULL;
21823 }
21824
21825
21826 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21827 PyObject *resultobj;
21828 wxDateTime *arg1 = (wxDateTime *) 0 ;
21829 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21830 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21831 int result;
21832 bool temp2 = false ;
21833 PyObject * obj0 = 0 ;
21834 PyObject * obj1 = 0 ;
21835 char *kwnames[] = {
21836 (char *) "self",(char *) "tz", NULL
21837 };
21838
21839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21841 if (SWIG_arg_fail(1)) SWIG_fail;
21842 if (obj1) {
21843 {
21844 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21845 temp2 = true;
21846 }
21847 }
21848 {
21849 PyThreadState* __tstate = wxPyBeginAllowThreads();
21850 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21851
21852 wxPyEndAllowThreads(__tstate);
21853 if (PyErr_Occurred()) SWIG_fail;
21854 }
21855 {
21856 resultobj = SWIG_From_int((int)(result));
21857 }
21858 {
21859 if (temp2) delete arg2;
21860 }
21861 return resultobj;
21862 fail:
21863 {
21864 if (temp2) delete arg2;
21865 }
21866 return NULL;
21867 }
21868
21869
21870 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21871 PyObject *resultobj;
21872 wxDateTime *arg1 = (wxDateTime *) 0 ;
21873 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21874 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21875 int result;
21876 bool temp2 = false ;
21877 PyObject * obj0 = 0 ;
21878 PyObject * obj1 = 0 ;
21879 char *kwnames[] = {
21880 (char *) "self",(char *) "tz", NULL
21881 };
21882
21883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21885 if (SWIG_arg_fail(1)) SWIG_fail;
21886 if (obj1) {
21887 {
21888 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21889 temp2 = true;
21890 }
21891 }
21892 {
21893 PyThreadState* __tstate = wxPyBeginAllowThreads();
21894 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21895
21896 wxPyEndAllowThreads(__tstate);
21897 if (PyErr_Occurred()) SWIG_fail;
21898 }
21899 {
21900 resultobj = SWIG_From_int((int)(result));
21901 }
21902 {
21903 if (temp2) delete arg2;
21904 }
21905 return resultobj;
21906 fail:
21907 {
21908 if (temp2) delete arg2;
21909 }
21910 return NULL;
21911 }
21912
21913
21914 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21915 PyObject *resultobj;
21916 wxDateTime *arg1 = (wxDateTime *) 0 ;
21917 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21918 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21919 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21920 int result;
21921 bool temp3 = false ;
21922 PyObject * obj0 = 0 ;
21923 PyObject * obj1 = 0 ;
21924 PyObject * obj2 = 0 ;
21925 char *kwnames[] = {
21926 (char *) "self",(char *) "flags",(char *) "tz", NULL
21927 };
21928
21929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21931 if (SWIG_arg_fail(1)) SWIG_fail;
21932 if (obj1) {
21933 {
21934 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21935 if (SWIG_arg_fail(2)) SWIG_fail;
21936 }
21937 }
21938 if (obj2) {
21939 {
21940 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21941 temp3 = true;
21942 }
21943 }
21944 {
21945 PyThreadState* __tstate = wxPyBeginAllowThreads();
21946 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21947
21948 wxPyEndAllowThreads(__tstate);
21949 if (PyErr_Occurred()) SWIG_fail;
21950 }
21951 {
21952 resultobj = SWIG_From_int((int)(result));
21953 }
21954 {
21955 if (temp3) delete arg3;
21956 }
21957 return resultobj;
21958 fail:
21959 {
21960 if (temp3) delete arg3;
21961 }
21962 return NULL;
21963 }
21964
21965
21966 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21967 PyObject *resultobj;
21968 wxDateTime *arg1 = (wxDateTime *) 0 ;
21969 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21970 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21971 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21972 int result;
21973 bool temp3 = false ;
21974 PyObject * obj0 = 0 ;
21975 PyObject * obj1 = 0 ;
21976 PyObject * obj2 = 0 ;
21977 char *kwnames[] = {
21978 (char *) "self",(char *) "flags",(char *) "tz", NULL
21979 };
21980
21981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21983 if (SWIG_arg_fail(1)) SWIG_fail;
21984 if (obj1) {
21985 {
21986 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21987 if (SWIG_arg_fail(2)) SWIG_fail;
21988 }
21989 }
21990 if (obj2) {
21991 {
21992 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21993 temp3 = true;
21994 }
21995 }
21996 {
21997 PyThreadState* __tstate = wxPyBeginAllowThreads();
21998 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21999
22000 wxPyEndAllowThreads(__tstate);
22001 if (PyErr_Occurred()) SWIG_fail;
22002 }
22003 {
22004 resultobj = SWIG_From_int((int)(result));
22005 }
22006 {
22007 if (temp3) delete arg3;
22008 }
22009 return resultobj;
22010 fail:
22011 {
22012 if (temp3) delete arg3;
22013 }
22014 return NULL;
22015 }
22016
22017
22018 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
22019 PyObject *resultobj;
22020 wxDateTime *arg1 = (wxDateTime *) 0 ;
22021 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22022 bool result;
22023 PyObject * obj0 = 0 ;
22024 PyObject * obj1 = 0 ;
22025 char *kwnames[] = {
22026 (char *) "self",(char *) "country", NULL
22027 };
22028
22029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22031 if (SWIG_arg_fail(1)) SWIG_fail;
22032 if (obj1) {
22033 {
22034 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22035 if (SWIG_arg_fail(2)) SWIG_fail;
22036 }
22037 }
22038 {
22039 PyThreadState* __tstate = wxPyBeginAllowThreads();
22040 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22041
22042 wxPyEndAllowThreads(__tstate);
22043 if (PyErr_Occurred()) SWIG_fail;
22044 }
22045 {
22046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22047 }
22048 return resultobj;
22049 fail:
22050 return NULL;
22051 }
22052
22053
22054 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22055 PyObject *resultobj;
22056 wxDateTime *arg1 = (wxDateTime *) 0 ;
22057 wxDateTime *arg2 = 0 ;
22058 bool result;
22059 PyObject * obj0 = 0 ;
22060 PyObject * obj1 = 0 ;
22061 char *kwnames[] = {
22062 (char *) "self",(char *) "datetime", NULL
22063 };
22064
22065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22067 if (SWIG_arg_fail(1)) SWIG_fail;
22068 {
22069 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22070 if (SWIG_arg_fail(2)) SWIG_fail;
22071 if (arg2 == NULL) {
22072 SWIG_null_ref("wxDateTime");
22073 }
22074 if (SWIG_arg_fail(2)) SWIG_fail;
22075 }
22076 {
22077 PyThreadState* __tstate = wxPyBeginAllowThreads();
22078 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22079
22080 wxPyEndAllowThreads(__tstate);
22081 if (PyErr_Occurred()) SWIG_fail;
22082 }
22083 {
22084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22085 }
22086 return resultobj;
22087 fail:
22088 return NULL;
22089 }
22090
22091
22092 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22093 PyObject *resultobj;
22094 wxDateTime *arg1 = (wxDateTime *) 0 ;
22095 wxDateTime *arg2 = 0 ;
22096 bool result;
22097 PyObject * obj0 = 0 ;
22098 PyObject * obj1 = 0 ;
22099 char *kwnames[] = {
22100 (char *) "self",(char *) "datetime", NULL
22101 };
22102
22103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22105 if (SWIG_arg_fail(1)) SWIG_fail;
22106 {
22107 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22108 if (SWIG_arg_fail(2)) SWIG_fail;
22109 if (arg2 == NULL) {
22110 SWIG_null_ref("wxDateTime");
22111 }
22112 if (SWIG_arg_fail(2)) SWIG_fail;
22113 }
22114 {
22115 PyThreadState* __tstate = wxPyBeginAllowThreads();
22116 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22117
22118 wxPyEndAllowThreads(__tstate);
22119 if (PyErr_Occurred()) SWIG_fail;
22120 }
22121 {
22122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22123 }
22124 return resultobj;
22125 fail:
22126 return NULL;
22127 }
22128
22129
22130 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22131 PyObject *resultobj;
22132 wxDateTime *arg1 = (wxDateTime *) 0 ;
22133 wxDateTime *arg2 = 0 ;
22134 bool result;
22135 PyObject * obj0 = 0 ;
22136 PyObject * obj1 = 0 ;
22137 char *kwnames[] = {
22138 (char *) "self",(char *) "datetime", NULL
22139 };
22140
22141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22143 if (SWIG_arg_fail(1)) SWIG_fail;
22144 {
22145 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22146 if (SWIG_arg_fail(2)) SWIG_fail;
22147 if (arg2 == NULL) {
22148 SWIG_null_ref("wxDateTime");
22149 }
22150 if (SWIG_arg_fail(2)) SWIG_fail;
22151 }
22152 {
22153 PyThreadState* __tstate = wxPyBeginAllowThreads();
22154 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22155
22156 wxPyEndAllowThreads(__tstate);
22157 if (PyErr_Occurred()) SWIG_fail;
22158 }
22159 {
22160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22161 }
22162 return resultobj;
22163 fail:
22164 return NULL;
22165 }
22166
22167
22168 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22169 PyObject *resultobj;
22170 wxDateTime *arg1 = (wxDateTime *) 0 ;
22171 wxDateTime *arg2 = 0 ;
22172 wxDateTime *arg3 = 0 ;
22173 bool result;
22174 PyObject * obj0 = 0 ;
22175 PyObject * obj1 = 0 ;
22176 PyObject * obj2 = 0 ;
22177 char *kwnames[] = {
22178 (char *) "self",(char *) "t1",(char *) "t2", NULL
22179 };
22180
22181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22183 if (SWIG_arg_fail(1)) SWIG_fail;
22184 {
22185 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22186 if (SWIG_arg_fail(2)) SWIG_fail;
22187 if (arg2 == NULL) {
22188 SWIG_null_ref("wxDateTime");
22189 }
22190 if (SWIG_arg_fail(2)) SWIG_fail;
22191 }
22192 {
22193 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22194 if (SWIG_arg_fail(3)) SWIG_fail;
22195 if (arg3 == NULL) {
22196 SWIG_null_ref("wxDateTime");
22197 }
22198 if (SWIG_arg_fail(3)) SWIG_fail;
22199 }
22200 {
22201 PyThreadState* __tstate = wxPyBeginAllowThreads();
22202 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22203
22204 wxPyEndAllowThreads(__tstate);
22205 if (PyErr_Occurred()) SWIG_fail;
22206 }
22207 {
22208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22209 }
22210 return resultobj;
22211 fail:
22212 return NULL;
22213 }
22214
22215
22216 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22217 PyObject *resultobj;
22218 wxDateTime *arg1 = (wxDateTime *) 0 ;
22219 wxDateTime *arg2 = 0 ;
22220 wxDateTime *arg3 = 0 ;
22221 bool result;
22222 PyObject * obj0 = 0 ;
22223 PyObject * obj1 = 0 ;
22224 PyObject * obj2 = 0 ;
22225 char *kwnames[] = {
22226 (char *) "self",(char *) "t1",(char *) "t2", NULL
22227 };
22228
22229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22231 if (SWIG_arg_fail(1)) SWIG_fail;
22232 {
22233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22234 if (SWIG_arg_fail(2)) SWIG_fail;
22235 if (arg2 == NULL) {
22236 SWIG_null_ref("wxDateTime");
22237 }
22238 if (SWIG_arg_fail(2)) SWIG_fail;
22239 }
22240 {
22241 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22242 if (SWIG_arg_fail(3)) SWIG_fail;
22243 if (arg3 == NULL) {
22244 SWIG_null_ref("wxDateTime");
22245 }
22246 if (SWIG_arg_fail(3)) SWIG_fail;
22247 }
22248 {
22249 PyThreadState* __tstate = wxPyBeginAllowThreads();
22250 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22251
22252 wxPyEndAllowThreads(__tstate);
22253 if (PyErr_Occurred()) SWIG_fail;
22254 }
22255 {
22256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22257 }
22258 return resultobj;
22259 fail:
22260 return NULL;
22261 }
22262
22263
22264 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22265 PyObject *resultobj;
22266 wxDateTime *arg1 = (wxDateTime *) 0 ;
22267 wxDateTime *arg2 = 0 ;
22268 bool result;
22269 PyObject * obj0 = 0 ;
22270 PyObject * obj1 = 0 ;
22271 char *kwnames[] = {
22272 (char *) "self",(char *) "dt", NULL
22273 };
22274
22275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22277 if (SWIG_arg_fail(1)) SWIG_fail;
22278 {
22279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22280 if (SWIG_arg_fail(2)) SWIG_fail;
22281 if (arg2 == NULL) {
22282 SWIG_null_ref("wxDateTime");
22283 }
22284 if (SWIG_arg_fail(2)) SWIG_fail;
22285 }
22286 {
22287 PyThreadState* __tstate = wxPyBeginAllowThreads();
22288 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22289
22290 wxPyEndAllowThreads(__tstate);
22291 if (PyErr_Occurred()) SWIG_fail;
22292 }
22293 {
22294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22295 }
22296 return resultobj;
22297 fail:
22298 return NULL;
22299 }
22300
22301
22302 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22303 PyObject *resultobj;
22304 wxDateTime *arg1 = (wxDateTime *) 0 ;
22305 wxDateTime *arg2 = 0 ;
22306 bool result;
22307 PyObject * obj0 = 0 ;
22308 PyObject * obj1 = 0 ;
22309 char *kwnames[] = {
22310 (char *) "self",(char *) "dt", NULL
22311 };
22312
22313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22315 if (SWIG_arg_fail(1)) SWIG_fail;
22316 {
22317 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22318 if (SWIG_arg_fail(2)) SWIG_fail;
22319 if (arg2 == NULL) {
22320 SWIG_null_ref("wxDateTime");
22321 }
22322 if (SWIG_arg_fail(2)) SWIG_fail;
22323 }
22324 {
22325 PyThreadState* __tstate = wxPyBeginAllowThreads();
22326 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22327
22328 wxPyEndAllowThreads(__tstate);
22329 if (PyErr_Occurred()) SWIG_fail;
22330 }
22331 {
22332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22333 }
22334 return resultobj;
22335 fail:
22336 return NULL;
22337 }
22338
22339
22340 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22341 PyObject *resultobj;
22342 wxDateTime *arg1 = (wxDateTime *) 0 ;
22343 wxDateTime *arg2 = 0 ;
22344 wxTimeSpan *arg3 = 0 ;
22345 bool result;
22346 PyObject * obj0 = 0 ;
22347 PyObject * obj1 = 0 ;
22348 PyObject * obj2 = 0 ;
22349 char *kwnames[] = {
22350 (char *) "self",(char *) "dt",(char *) "ts", NULL
22351 };
22352
22353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22355 if (SWIG_arg_fail(1)) SWIG_fail;
22356 {
22357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22358 if (SWIG_arg_fail(2)) SWIG_fail;
22359 if (arg2 == NULL) {
22360 SWIG_null_ref("wxDateTime");
22361 }
22362 if (SWIG_arg_fail(2)) SWIG_fail;
22363 }
22364 {
22365 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22366 if (SWIG_arg_fail(3)) SWIG_fail;
22367 if (arg3 == NULL) {
22368 SWIG_null_ref("wxTimeSpan");
22369 }
22370 if (SWIG_arg_fail(3)) SWIG_fail;
22371 }
22372 {
22373 PyThreadState* __tstate = wxPyBeginAllowThreads();
22374 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22375
22376 wxPyEndAllowThreads(__tstate);
22377 if (PyErr_Occurred()) SWIG_fail;
22378 }
22379 {
22380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22381 }
22382 return resultobj;
22383 fail:
22384 return NULL;
22385 }
22386
22387
22388 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22389 PyObject *resultobj;
22390 wxDateTime *arg1 = (wxDateTime *) 0 ;
22391 wxTimeSpan *arg2 = 0 ;
22392 wxDateTime *result;
22393 PyObject * obj0 = 0 ;
22394 PyObject * obj1 = 0 ;
22395 char *kwnames[] = {
22396 (char *) "self",(char *) "diff", NULL
22397 };
22398
22399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22401 if (SWIG_arg_fail(1)) SWIG_fail;
22402 {
22403 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22404 if (SWIG_arg_fail(2)) SWIG_fail;
22405 if (arg2 == NULL) {
22406 SWIG_null_ref("wxTimeSpan");
22407 }
22408 if (SWIG_arg_fail(2)) SWIG_fail;
22409 }
22410 {
22411 PyThreadState* __tstate = wxPyBeginAllowThreads();
22412 {
22413 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22414 result = (wxDateTime *) &_result_ref;
22415 }
22416
22417 wxPyEndAllowThreads(__tstate);
22418 if (PyErr_Occurred()) SWIG_fail;
22419 }
22420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22421 return resultobj;
22422 fail:
22423 return NULL;
22424 }
22425
22426
22427 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22428 PyObject *resultobj;
22429 wxDateTime *arg1 = (wxDateTime *) 0 ;
22430 wxDateSpan *arg2 = 0 ;
22431 wxDateTime *result;
22432 PyObject * obj0 = 0 ;
22433 PyObject * obj1 = 0 ;
22434 char *kwnames[] = {
22435 (char *) "self",(char *) "diff", NULL
22436 };
22437
22438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22440 if (SWIG_arg_fail(1)) SWIG_fail;
22441 {
22442 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22443 if (SWIG_arg_fail(2)) SWIG_fail;
22444 if (arg2 == NULL) {
22445 SWIG_null_ref("wxDateSpan");
22446 }
22447 if (SWIG_arg_fail(2)) SWIG_fail;
22448 }
22449 {
22450 PyThreadState* __tstate = wxPyBeginAllowThreads();
22451 {
22452 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22453 result = (wxDateTime *) &_result_ref;
22454 }
22455
22456 wxPyEndAllowThreads(__tstate);
22457 if (PyErr_Occurred()) SWIG_fail;
22458 }
22459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22460 return resultobj;
22461 fail:
22462 return NULL;
22463 }
22464
22465
22466 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22467 PyObject *resultobj;
22468 wxDateTime *arg1 = (wxDateTime *) 0 ;
22469 wxTimeSpan *arg2 = 0 ;
22470 wxDateTime *result;
22471 PyObject * obj0 = 0 ;
22472 PyObject * obj1 = 0 ;
22473 char *kwnames[] = {
22474 (char *) "self",(char *) "diff", NULL
22475 };
22476
22477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22479 if (SWIG_arg_fail(1)) SWIG_fail;
22480 {
22481 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22482 if (SWIG_arg_fail(2)) SWIG_fail;
22483 if (arg2 == NULL) {
22484 SWIG_null_ref("wxTimeSpan");
22485 }
22486 if (SWIG_arg_fail(2)) SWIG_fail;
22487 }
22488 {
22489 PyThreadState* __tstate = wxPyBeginAllowThreads();
22490 {
22491 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22492 result = (wxDateTime *) &_result_ref;
22493 }
22494
22495 wxPyEndAllowThreads(__tstate);
22496 if (PyErr_Occurred()) SWIG_fail;
22497 }
22498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22499 return resultobj;
22500 fail:
22501 return NULL;
22502 }
22503
22504
22505 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22506 PyObject *resultobj;
22507 wxDateTime *arg1 = (wxDateTime *) 0 ;
22508 wxDateSpan *arg2 = 0 ;
22509 wxDateTime *result;
22510 PyObject * obj0 = 0 ;
22511 PyObject * obj1 = 0 ;
22512 char *kwnames[] = {
22513 (char *) "self",(char *) "diff", NULL
22514 };
22515
22516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22518 if (SWIG_arg_fail(1)) SWIG_fail;
22519 {
22520 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22521 if (SWIG_arg_fail(2)) SWIG_fail;
22522 if (arg2 == NULL) {
22523 SWIG_null_ref("wxDateSpan");
22524 }
22525 if (SWIG_arg_fail(2)) SWIG_fail;
22526 }
22527 {
22528 PyThreadState* __tstate = wxPyBeginAllowThreads();
22529 {
22530 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22531 result = (wxDateTime *) &_result_ref;
22532 }
22533
22534 wxPyEndAllowThreads(__tstate);
22535 if (PyErr_Occurred()) SWIG_fail;
22536 }
22537 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22538 return resultobj;
22539 fail:
22540 return NULL;
22541 }
22542
22543
22544 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22545 PyObject *resultobj;
22546 wxDateTime *arg1 = (wxDateTime *) 0 ;
22547 wxDateTime *arg2 = 0 ;
22548 wxTimeSpan result;
22549 PyObject * obj0 = 0 ;
22550 PyObject * obj1 = 0 ;
22551 char *kwnames[] = {
22552 (char *) "self",(char *) "dt", NULL
22553 };
22554
22555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22557 if (SWIG_arg_fail(1)) SWIG_fail;
22558 {
22559 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22560 if (SWIG_arg_fail(2)) SWIG_fail;
22561 if (arg2 == NULL) {
22562 SWIG_null_ref("wxDateTime");
22563 }
22564 if (SWIG_arg_fail(2)) SWIG_fail;
22565 }
22566 {
22567 PyThreadState* __tstate = wxPyBeginAllowThreads();
22568 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22569
22570 wxPyEndAllowThreads(__tstate);
22571 if (PyErr_Occurred()) SWIG_fail;
22572 }
22573 {
22574 wxTimeSpan * resultptr;
22575 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22576 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22577 }
22578 return resultobj;
22579 fail:
22580 return NULL;
22581 }
22582
22583
22584 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22585 PyObject *resultobj;
22586 wxDateTime *arg1 = (wxDateTime *) 0 ;
22587 wxTimeSpan *arg2 = 0 ;
22588 wxDateTime *result;
22589 PyObject * obj0 = 0 ;
22590 PyObject * obj1 = 0 ;
22591
22592 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22594 if (SWIG_arg_fail(1)) SWIG_fail;
22595 {
22596 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22597 if (SWIG_arg_fail(2)) SWIG_fail;
22598 if (arg2 == NULL) {
22599 SWIG_null_ref("wxTimeSpan");
22600 }
22601 if (SWIG_arg_fail(2)) SWIG_fail;
22602 }
22603 {
22604 PyThreadState* __tstate = wxPyBeginAllowThreads();
22605 {
22606 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22607 result = (wxDateTime *) &_result_ref;
22608 }
22609
22610 wxPyEndAllowThreads(__tstate);
22611 if (PyErr_Occurred()) SWIG_fail;
22612 }
22613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22614 return resultobj;
22615 fail:
22616 return NULL;
22617 }
22618
22619
22620 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22621 PyObject *resultobj;
22622 wxDateTime *arg1 = (wxDateTime *) 0 ;
22623 wxDateSpan *arg2 = 0 ;
22624 wxDateTime *result;
22625 PyObject * obj0 = 0 ;
22626 PyObject * obj1 = 0 ;
22627
22628 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22630 if (SWIG_arg_fail(1)) SWIG_fail;
22631 {
22632 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22633 if (SWIG_arg_fail(2)) SWIG_fail;
22634 if (arg2 == NULL) {
22635 SWIG_null_ref("wxDateSpan");
22636 }
22637 if (SWIG_arg_fail(2)) SWIG_fail;
22638 }
22639 {
22640 PyThreadState* __tstate = wxPyBeginAllowThreads();
22641 {
22642 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22643 result = (wxDateTime *) &_result_ref;
22644 }
22645
22646 wxPyEndAllowThreads(__tstate);
22647 if (PyErr_Occurred()) SWIG_fail;
22648 }
22649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22650 return resultobj;
22651 fail:
22652 return NULL;
22653 }
22654
22655
22656 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22657 int argc;
22658 PyObject *argv[3];
22659 int ii;
22660
22661 argc = PyObject_Length(args);
22662 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22663 argv[ii] = PyTuple_GetItem(args,ii);
22664 }
22665 if (argc == 2) {
22666 int _v;
22667 {
22668 void *ptr;
22669 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22670 _v = 0;
22671 PyErr_Clear();
22672 } else {
22673 _v = 1;
22674 }
22675 }
22676 if (_v) {
22677 {
22678 void *ptr = 0;
22679 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22680 _v = 0;
22681 PyErr_Clear();
22682 } else {
22683 _v = (ptr != 0);
22684 }
22685 }
22686 if (_v) {
22687 return _wrap_DateTime___iadd____SWIG_0(self,args);
22688 }
22689 }
22690 }
22691 if (argc == 2) {
22692 int _v;
22693 {
22694 void *ptr;
22695 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22696 _v = 0;
22697 PyErr_Clear();
22698 } else {
22699 _v = 1;
22700 }
22701 }
22702 if (_v) {
22703 {
22704 void *ptr = 0;
22705 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22706 _v = 0;
22707 PyErr_Clear();
22708 } else {
22709 _v = (ptr != 0);
22710 }
22711 }
22712 if (_v) {
22713 return _wrap_DateTime___iadd____SWIG_1(self,args);
22714 }
22715 }
22716 }
22717
22718 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22719 return NULL;
22720 }
22721
22722
22723 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22724 PyObject *resultobj;
22725 wxDateTime *arg1 = (wxDateTime *) 0 ;
22726 wxTimeSpan *arg2 = 0 ;
22727 wxDateTime *result;
22728 PyObject * obj0 = 0 ;
22729 PyObject * obj1 = 0 ;
22730
22731 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22733 if (SWIG_arg_fail(1)) SWIG_fail;
22734 {
22735 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22736 if (SWIG_arg_fail(2)) SWIG_fail;
22737 if (arg2 == NULL) {
22738 SWIG_null_ref("wxTimeSpan");
22739 }
22740 if (SWIG_arg_fail(2)) SWIG_fail;
22741 }
22742 {
22743 PyThreadState* __tstate = wxPyBeginAllowThreads();
22744 {
22745 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22746 result = (wxDateTime *) &_result_ref;
22747 }
22748
22749 wxPyEndAllowThreads(__tstate);
22750 if (PyErr_Occurred()) SWIG_fail;
22751 }
22752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22753 return resultobj;
22754 fail:
22755 return NULL;
22756 }
22757
22758
22759 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22760 PyObject *resultobj;
22761 wxDateTime *arg1 = (wxDateTime *) 0 ;
22762 wxDateSpan *arg2 = 0 ;
22763 wxDateTime *result;
22764 PyObject * obj0 = 0 ;
22765 PyObject * obj1 = 0 ;
22766
22767 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22769 if (SWIG_arg_fail(1)) SWIG_fail;
22770 {
22771 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22772 if (SWIG_arg_fail(2)) SWIG_fail;
22773 if (arg2 == NULL) {
22774 SWIG_null_ref("wxDateSpan");
22775 }
22776 if (SWIG_arg_fail(2)) SWIG_fail;
22777 }
22778 {
22779 PyThreadState* __tstate = wxPyBeginAllowThreads();
22780 {
22781 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22782 result = (wxDateTime *) &_result_ref;
22783 }
22784
22785 wxPyEndAllowThreads(__tstate);
22786 if (PyErr_Occurred()) SWIG_fail;
22787 }
22788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22789 return resultobj;
22790 fail:
22791 return NULL;
22792 }
22793
22794
22795 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22796 int argc;
22797 PyObject *argv[3];
22798 int ii;
22799
22800 argc = PyObject_Length(args);
22801 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22802 argv[ii] = PyTuple_GetItem(args,ii);
22803 }
22804 if (argc == 2) {
22805 int _v;
22806 {
22807 void *ptr;
22808 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22809 _v = 0;
22810 PyErr_Clear();
22811 } else {
22812 _v = 1;
22813 }
22814 }
22815 if (_v) {
22816 {
22817 void *ptr = 0;
22818 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22819 _v = 0;
22820 PyErr_Clear();
22821 } else {
22822 _v = (ptr != 0);
22823 }
22824 }
22825 if (_v) {
22826 return _wrap_DateTime___isub____SWIG_0(self,args);
22827 }
22828 }
22829 }
22830 if (argc == 2) {
22831 int _v;
22832 {
22833 void *ptr;
22834 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22835 _v = 0;
22836 PyErr_Clear();
22837 } else {
22838 _v = 1;
22839 }
22840 }
22841 if (_v) {
22842 {
22843 void *ptr = 0;
22844 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22845 _v = 0;
22846 PyErr_Clear();
22847 } else {
22848 _v = (ptr != 0);
22849 }
22850 }
22851 if (_v) {
22852 return _wrap_DateTime___isub____SWIG_1(self,args);
22853 }
22854 }
22855 }
22856
22857 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22858 return NULL;
22859 }
22860
22861
22862 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22863 PyObject *resultobj;
22864 wxDateTime *arg1 = (wxDateTime *) 0 ;
22865 wxTimeSpan *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_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22875 if (SWIG_arg_fail(2)) SWIG_fail;
22876 if (arg2 == NULL) {
22877 SWIG_null_ref("wxTimeSpan");
22878 }
22879 if (SWIG_arg_fail(2)) SWIG_fail;
22880 }
22881 {
22882 PyThreadState* __tstate = wxPyBeginAllowThreads();
22883 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan 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____SWIG_1(PyObject *, PyObject *args) {
22900 PyObject *resultobj;
22901 wxDateTime *arg1 = (wxDateTime *) 0 ;
22902 wxDateSpan *arg2 = 0 ;
22903 wxDateTime result;
22904 PyObject * obj0 = 0 ;
22905 PyObject * obj1 = 0 ;
22906
22907 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22909 if (SWIG_arg_fail(1)) SWIG_fail;
22910 {
22911 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22912 if (SWIG_arg_fail(2)) SWIG_fail;
22913 if (arg2 == NULL) {
22914 SWIG_null_ref("wxDateSpan");
22915 }
22916 if (SWIG_arg_fail(2)) SWIG_fail;
22917 }
22918 {
22919 PyThreadState* __tstate = wxPyBeginAllowThreads();
22920 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22921
22922 wxPyEndAllowThreads(__tstate);
22923 if (PyErr_Occurred()) SWIG_fail;
22924 }
22925 {
22926 wxDateTime * resultptr;
22927 resultptr = new wxDateTime((wxDateTime &)(result));
22928 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22929 }
22930 return resultobj;
22931 fail:
22932 return NULL;
22933 }
22934
22935
22936 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22937 int argc;
22938 PyObject *argv[3];
22939 int ii;
22940
22941 argc = PyObject_Length(args);
22942 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22943 argv[ii] = PyTuple_GetItem(args,ii);
22944 }
22945 if (argc == 2) {
22946 int _v;
22947 {
22948 void *ptr;
22949 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22950 _v = 0;
22951 PyErr_Clear();
22952 } else {
22953 _v = 1;
22954 }
22955 }
22956 if (_v) {
22957 {
22958 void *ptr = 0;
22959 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22960 _v = 0;
22961 PyErr_Clear();
22962 } else {
22963 _v = (ptr != 0);
22964 }
22965 }
22966 if (_v) {
22967 return _wrap_DateTime___add____SWIG_0(self,args);
22968 }
22969 }
22970 }
22971 if (argc == 2) {
22972 int _v;
22973 {
22974 void *ptr;
22975 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22976 _v = 0;
22977 PyErr_Clear();
22978 } else {
22979 _v = 1;
22980 }
22981 }
22982 if (_v) {
22983 {
22984 void *ptr = 0;
22985 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22986 _v = 0;
22987 PyErr_Clear();
22988 } else {
22989 _v = (ptr != 0);
22990 }
22991 }
22992 if (_v) {
22993 return _wrap_DateTime___add____SWIG_1(self,args);
22994 }
22995 }
22996 }
22997
22998 Py_INCREF(Py_NotImplemented);
22999 return Py_NotImplemented;
23000 }
23001
23002
23003 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
23004 PyObject *resultobj;
23005 wxDateTime *arg1 = (wxDateTime *) 0 ;
23006 wxDateTime *arg2 = 0 ;
23007 wxTimeSpan 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_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23016 if (SWIG_arg_fail(2)) SWIG_fail;
23017 if (arg2 == NULL) {
23018 SWIG_null_ref("wxDateTime");
23019 }
23020 if (SWIG_arg_fail(2)) SWIG_fail;
23021 }
23022 {
23023 PyThreadState* __tstate = wxPyBeginAllowThreads();
23024 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
23025
23026 wxPyEndAllowThreads(__tstate);
23027 if (PyErr_Occurred()) SWIG_fail;
23028 }
23029 {
23030 wxTimeSpan * resultptr;
23031 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23032 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23033 }
23034 return resultobj;
23035 fail:
23036 return NULL;
23037 }
23038
23039
23040 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23041 PyObject *resultobj;
23042 wxDateTime *arg1 = (wxDateTime *) 0 ;
23043 wxTimeSpan *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_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23053 if (SWIG_arg_fail(2)) SWIG_fail;
23054 if (arg2 == NULL) {
23055 SWIG_null_ref("wxTimeSpan");
23056 }
23057 if (SWIG_arg_fail(2)) SWIG_fail;
23058 }
23059 {
23060 PyThreadState* __tstate = wxPyBeginAllowThreads();
23061 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan 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____SWIG_2(PyObject *, PyObject *args) {
23078 PyObject *resultobj;
23079 wxDateTime *arg1 = (wxDateTime *) 0 ;
23080 wxDateSpan *arg2 = 0 ;
23081 wxDateTime result;
23082 PyObject * obj0 = 0 ;
23083 PyObject * obj1 = 0 ;
23084
23085 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23087 if (SWIG_arg_fail(1)) SWIG_fail;
23088 {
23089 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23090 if (SWIG_arg_fail(2)) SWIG_fail;
23091 if (arg2 == NULL) {
23092 SWIG_null_ref("wxDateSpan");
23093 }
23094 if (SWIG_arg_fail(2)) SWIG_fail;
23095 }
23096 {
23097 PyThreadState* __tstate = wxPyBeginAllowThreads();
23098 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23099
23100 wxPyEndAllowThreads(__tstate);
23101 if (PyErr_Occurred()) SWIG_fail;
23102 }
23103 {
23104 wxDateTime * resultptr;
23105 resultptr = new wxDateTime((wxDateTime &)(result));
23106 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23107 }
23108 return resultobj;
23109 fail:
23110 return NULL;
23111 }
23112
23113
23114 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23115 int argc;
23116 PyObject *argv[3];
23117 int ii;
23118
23119 argc = PyObject_Length(args);
23120 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23121 argv[ii] = PyTuple_GetItem(args,ii);
23122 }
23123 if (argc == 2) {
23124 int _v;
23125 {
23126 void *ptr;
23127 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23128 _v = 0;
23129 PyErr_Clear();
23130 } else {
23131 _v = 1;
23132 }
23133 }
23134 if (_v) {
23135 {
23136 void *ptr = 0;
23137 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23138 _v = 0;
23139 PyErr_Clear();
23140 } else {
23141 _v = (ptr != 0);
23142 }
23143 }
23144 if (_v) {
23145 return _wrap_DateTime___sub____SWIG_0(self,args);
23146 }
23147 }
23148 }
23149 if (argc == 2) {
23150 int _v;
23151 {
23152 void *ptr;
23153 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23154 _v = 0;
23155 PyErr_Clear();
23156 } else {
23157 _v = 1;
23158 }
23159 }
23160 if (_v) {
23161 {
23162 void *ptr = 0;
23163 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23164 _v = 0;
23165 PyErr_Clear();
23166 } else {
23167 _v = (ptr != 0);
23168 }
23169 }
23170 if (_v) {
23171 return _wrap_DateTime___sub____SWIG_1(self,args);
23172 }
23173 }
23174 }
23175 if (argc == 2) {
23176 int _v;
23177 {
23178 void *ptr;
23179 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23180 _v = 0;
23181 PyErr_Clear();
23182 } else {
23183 _v = 1;
23184 }
23185 }
23186 if (_v) {
23187 {
23188 void *ptr = 0;
23189 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23190 _v = 0;
23191 PyErr_Clear();
23192 } else {
23193 _v = (ptr != 0);
23194 }
23195 }
23196 if (_v) {
23197 return _wrap_DateTime___sub____SWIG_2(self,args);
23198 }
23199 }
23200 }
23201
23202 Py_INCREF(Py_NotImplemented);
23203 return Py_NotImplemented;
23204 }
23205
23206
23207 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23208 PyObject *resultobj;
23209 wxDateTime *arg1 = (wxDateTime *) 0 ;
23210 wxDateTime *arg2 = (wxDateTime *) 0 ;
23211 bool result;
23212 PyObject * obj0 = 0 ;
23213 PyObject * obj1 = 0 ;
23214 char *kwnames[] = {
23215 (char *) "self",(char *) "other", NULL
23216 };
23217
23218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23220 if (SWIG_arg_fail(1)) SWIG_fail;
23221 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23222 if (SWIG_arg_fail(2)) SWIG_fail;
23223 {
23224 PyThreadState* __tstate = wxPyBeginAllowThreads();
23225 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23226
23227 wxPyEndAllowThreads(__tstate);
23228 if (PyErr_Occurred()) SWIG_fail;
23229 }
23230 {
23231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23232 }
23233 return resultobj;
23234 fail:
23235 return NULL;
23236 }
23237
23238
23239 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23240 PyObject *resultobj;
23241 wxDateTime *arg1 = (wxDateTime *) 0 ;
23242 wxDateTime *arg2 = (wxDateTime *) 0 ;
23243 bool result;
23244 PyObject * obj0 = 0 ;
23245 PyObject * obj1 = 0 ;
23246 char *kwnames[] = {
23247 (char *) "self",(char *) "other", NULL
23248 };
23249
23250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23252 if (SWIG_arg_fail(1)) SWIG_fail;
23253 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23254 if (SWIG_arg_fail(2)) SWIG_fail;
23255 {
23256 PyThreadState* __tstate = wxPyBeginAllowThreads();
23257 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23258
23259 wxPyEndAllowThreads(__tstate);
23260 if (PyErr_Occurred()) SWIG_fail;
23261 }
23262 {
23263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23264 }
23265 return resultobj;
23266 fail:
23267 return NULL;
23268 }
23269
23270
23271 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23272 PyObject *resultobj;
23273 wxDateTime *arg1 = (wxDateTime *) 0 ;
23274 wxDateTime *arg2 = (wxDateTime *) 0 ;
23275 bool result;
23276 PyObject * obj0 = 0 ;
23277 PyObject * obj1 = 0 ;
23278 char *kwnames[] = {
23279 (char *) "self",(char *) "other", NULL
23280 };
23281
23282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23284 if (SWIG_arg_fail(1)) SWIG_fail;
23285 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23286 if (SWIG_arg_fail(2)) SWIG_fail;
23287 {
23288 PyThreadState* __tstate = wxPyBeginAllowThreads();
23289 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23290
23291 wxPyEndAllowThreads(__tstate);
23292 if (PyErr_Occurred()) SWIG_fail;
23293 }
23294 {
23295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23296 }
23297 return resultobj;
23298 fail:
23299 return NULL;
23300 }
23301
23302
23303 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23304 PyObject *resultobj;
23305 wxDateTime *arg1 = (wxDateTime *) 0 ;
23306 wxDateTime *arg2 = (wxDateTime *) 0 ;
23307 bool result;
23308 PyObject * obj0 = 0 ;
23309 PyObject * obj1 = 0 ;
23310 char *kwnames[] = {
23311 (char *) "self",(char *) "other", NULL
23312 };
23313
23314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23316 if (SWIG_arg_fail(1)) SWIG_fail;
23317 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23318 if (SWIG_arg_fail(2)) SWIG_fail;
23319 {
23320 PyThreadState* __tstate = wxPyBeginAllowThreads();
23321 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23322
23323 wxPyEndAllowThreads(__tstate);
23324 if (PyErr_Occurred()) SWIG_fail;
23325 }
23326 {
23327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23328 }
23329 return resultobj;
23330 fail:
23331 return NULL;
23332 }
23333
23334
23335 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23336 PyObject *resultobj;
23337 wxDateTime *arg1 = (wxDateTime *) 0 ;
23338 wxDateTime *arg2 = (wxDateTime *) 0 ;
23339 bool result;
23340 PyObject * obj0 = 0 ;
23341 PyObject * obj1 = 0 ;
23342 char *kwnames[] = {
23343 (char *) "self",(char *) "other", NULL
23344 };
23345
23346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23348 if (SWIG_arg_fail(1)) SWIG_fail;
23349 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23350 if (SWIG_arg_fail(2)) SWIG_fail;
23351 {
23352 PyThreadState* __tstate = wxPyBeginAllowThreads();
23353 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23354
23355 wxPyEndAllowThreads(__tstate);
23356 if (PyErr_Occurred()) SWIG_fail;
23357 }
23358 {
23359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23360 }
23361 return resultobj;
23362 fail:
23363 return NULL;
23364 }
23365
23366
23367 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23368 PyObject *resultobj;
23369 wxDateTime *arg1 = (wxDateTime *) 0 ;
23370 wxDateTime *arg2 = (wxDateTime *) 0 ;
23371 bool result;
23372 PyObject * obj0 = 0 ;
23373 PyObject * obj1 = 0 ;
23374 char *kwnames[] = {
23375 (char *) "self",(char *) "other", NULL
23376 };
23377
23378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23380 if (SWIG_arg_fail(1)) SWIG_fail;
23381 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23382 if (SWIG_arg_fail(2)) SWIG_fail;
23383 {
23384 PyThreadState* __tstate = wxPyBeginAllowThreads();
23385 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23386
23387 wxPyEndAllowThreads(__tstate);
23388 if (PyErr_Occurred()) SWIG_fail;
23389 }
23390 {
23391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23392 }
23393 return resultobj;
23394 fail:
23395 return NULL;
23396 }
23397
23398
23399 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23400 PyObject *resultobj;
23401 wxDateTime *arg1 = (wxDateTime *) 0 ;
23402 wxString *arg2 = 0 ;
23403 int result;
23404 bool temp2 = false ;
23405 PyObject * obj0 = 0 ;
23406 PyObject * obj1 = 0 ;
23407 char *kwnames[] = {
23408 (char *) "self",(char *) "date", NULL
23409 };
23410
23411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23413 if (SWIG_arg_fail(1)) SWIG_fail;
23414 {
23415 arg2 = wxString_in_helper(obj1);
23416 if (arg2 == NULL) SWIG_fail;
23417 temp2 = true;
23418 }
23419 {
23420 PyThreadState* __tstate = wxPyBeginAllowThreads();
23421 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23422
23423 wxPyEndAllowThreads(__tstate);
23424 if (PyErr_Occurred()) SWIG_fail;
23425 }
23426 {
23427 resultobj = SWIG_From_int((int)(result));
23428 }
23429 {
23430 if (temp2)
23431 delete arg2;
23432 }
23433 return resultobj;
23434 fail:
23435 {
23436 if (temp2)
23437 delete arg2;
23438 }
23439 return NULL;
23440 }
23441
23442
23443 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23444 PyObject *resultobj;
23445 wxDateTime *arg1 = (wxDateTime *) 0 ;
23446 wxString *arg2 = 0 ;
23447 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23448 wxString *arg3 = (wxString *) &arg3_defvalue ;
23449 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23450 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23451 int result;
23452 bool temp2 = false ;
23453 bool temp3 = false ;
23454 PyObject * obj0 = 0 ;
23455 PyObject * obj1 = 0 ;
23456 PyObject * obj2 = 0 ;
23457 PyObject * obj3 = 0 ;
23458 char *kwnames[] = {
23459 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23460 };
23461
23462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23464 if (SWIG_arg_fail(1)) SWIG_fail;
23465 {
23466 arg2 = wxString_in_helper(obj1);
23467 if (arg2 == NULL) SWIG_fail;
23468 temp2 = true;
23469 }
23470 if (obj2) {
23471 {
23472 arg3 = wxString_in_helper(obj2);
23473 if (arg3 == NULL) SWIG_fail;
23474 temp3 = true;
23475 }
23476 }
23477 if (obj3) {
23478 {
23479 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23480 if (SWIG_arg_fail(4)) SWIG_fail;
23481 if (arg4 == NULL) {
23482 SWIG_null_ref("wxDateTime");
23483 }
23484 if (SWIG_arg_fail(4)) SWIG_fail;
23485 }
23486 }
23487 {
23488 PyThreadState* __tstate = wxPyBeginAllowThreads();
23489 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23490
23491 wxPyEndAllowThreads(__tstate);
23492 if (PyErr_Occurred()) SWIG_fail;
23493 }
23494 {
23495 resultobj = SWIG_From_int((int)(result));
23496 }
23497 {
23498 if (temp2)
23499 delete arg2;
23500 }
23501 {
23502 if (temp3)
23503 delete arg3;
23504 }
23505 return resultobj;
23506 fail:
23507 {
23508 if (temp2)
23509 delete arg2;
23510 }
23511 {
23512 if (temp3)
23513 delete arg3;
23514 }
23515 return NULL;
23516 }
23517
23518
23519 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23520 PyObject *resultobj;
23521 wxDateTime *arg1 = (wxDateTime *) 0 ;
23522 wxString *arg2 = 0 ;
23523 int result;
23524 bool temp2 = false ;
23525 PyObject * obj0 = 0 ;
23526 PyObject * obj1 = 0 ;
23527 char *kwnames[] = {
23528 (char *) "self",(char *) "datetime", NULL
23529 };
23530
23531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23533 if (SWIG_arg_fail(1)) SWIG_fail;
23534 {
23535 arg2 = wxString_in_helper(obj1);
23536 if (arg2 == NULL) SWIG_fail;
23537 temp2 = true;
23538 }
23539 {
23540 PyThreadState* __tstate = wxPyBeginAllowThreads();
23541 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23542
23543 wxPyEndAllowThreads(__tstate);
23544 if (PyErr_Occurred()) SWIG_fail;
23545 }
23546 {
23547 resultobj = SWIG_From_int((int)(result));
23548 }
23549 {
23550 if (temp2)
23551 delete arg2;
23552 }
23553 return resultobj;
23554 fail:
23555 {
23556 if (temp2)
23557 delete arg2;
23558 }
23559 return NULL;
23560 }
23561
23562
23563 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23564 PyObject *resultobj;
23565 wxDateTime *arg1 = (wxDateTime *) 0 ;
23566 wxString *arg2 = 0 ;
23567 int result;
23568 bool temp2 = false ;
23569 PyObject * obj0 = 0 ;
23570 PyObject * obj1 = 0 ;
23571 char *kwnames[] = {
23572 (char *) "self",(char *) "date", NULL
23573 };
23574
23575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23577 if (SWIG_arg_fail(1)) SWIG_fail;
23578 {
23579 arg2 = wxString_in_helper(obj1);
23580 if (arg2 == NULL) SWIG_fail;
23581 temp2 = true;
23582 }
23583 {
23584 PyThreadState* __tstate = wxPyBeginAllowThreads();
23585 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23586
23587 wxPyEndAllowThreads(__tstate);
23588 if (PyErr_Occurred()) SWIG_fail;
23589 }
23590 {
23591 resultobj = SWIG_From_int((int)(result));
23592 }
23593 {
23594 if (temp2)
23595 delete arg2;
23596 }
23597 return resultobj;
23598 fail:
23599 {
23600 if (temp2)
23601 delete arg2;
23602 }
23603 return NULL;
23604 }
23605
23606
23607 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23608 PyObject *resultobj;
23609 wxDateTime *arg1 = (wxDateTime *) 0 ;
23610 wxString *arg2 = 0 ;
23611 int result;
23612 bool temp2 = false ;
23613 PyObject * obj0 = 0 ;
23614 PyObject * obj1 = 0 ;
23615 char *kwnames[] = {
23616 (char *) "self",(char *) "time", NULL
23617 };
23618
23619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23621 if (SWIG_arg_fail(1)) SWIG_fail;
23622 {
23623 arg2 = wxString_in_helper(obj1);
23624 if (arg2 == NULL) SWIG_fail;
23625 temp2 = true;
23626 }
23627 {
23628 PyThreadState* __tstate = wxPyBeginAllowThreads();
23629 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23630
23631 wxPyEndAllowThreads(__tstate);
23632 if (PyErr_Occurred()) SWIG_fail;
23633 }
23634 {
23635 resultobj = SWIG_From_int((int)(result));
23636 }
23637 {
23638 if (temp2)
23639 delete arg2;
23640 }
23641 return resultobj;
23642 fail:
23643 {
23644 if (temp2)
23645 delete arg2;
23646 }
23647 return NULL;
23648 }
23649
23650
23651 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23652 PyObject *resultobj;
23653 wxDateTime *arg1 = (wxDateTime *) 0 ;
23654 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23655 wxString *arg2 = (wxString *) &arg2_defvalue ;
23656 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23657 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23658 wxString result;
23659 bool temp2 = false ;
23660 bool temp3 = false ;
23661 PyObject * obj0 = 0 ;
23662 PyObject * obj1 = 0 ;
23663 PyObject * obj2 = 0 ;
23664 char *kwnames[] = {
23665 (char *) "self",(char *) "format",(char *) "tz", NULL
23666 };
23667
23668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23670 if (SWIG_arg_fail(1)) SWIG_fail;
23671 if (obj1) {
23672 {
23673 arg2 = wxString_in_helper(obj1);
23674 if (arg2 == NULL) SWIG_fail;
23675 temp2 = true;
23676 }
23677 }
23678 if (obj2) {
23679 {
23680 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23681 temp3 = true;
23682 }
23683 }
23684 {
23685 PyThreadState* __tstate = wxPyBeginAllowThreads();
23686 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23687
23688 wxPyEndAllowThreads(__tstate);
23689 if (PyErr_Occurred()) SWIG_fail;
23690 }
23691 {
23692 #if wxUSE_UNICODE
23693 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23694 #else
23695 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23696 #endif
23697 }
23698 {
23699 if (temp2)
23700 delete arg2;
23701 }
23702 {
23703 if (temp3) delete arg3;
23704 }
23705 return resultobj;
23706 fail:
23707 {
23708 if (temp2)
23709 delete arg2;
23710 }
23711 {
23712 if (temp3) delete arg3;
23713 }
23714 return NULL;
23715 }
23716
23717
23718 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23719 PyObject *resultobj;
23720 wxDateTime *arg1 = (wxDateTime *) 0 ;
23721 wxString result;
23722 PyObject * obj0 = 0 ;
23723 char *kwnames[] = {
23724 (char *) "self", NULL
23725 };
23726
23727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23729 if (SWIG_arg_fail(1)) SWIG_fail;
23730 {
23731 PyThreadState* __tstate = wxPyBeginAllowThreads();
23732 result = ((wxDateTime const *)arg1)->FormatDate();
23733
23734 wxPyEndAllowThreads(__tstate);
23735 if (PyErr_Occurred()) SWIG_fail;
23736 }
23737 {
23738 #if wxUSE_UNICODE
23739 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23740 #else
23741 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23742 #endif
23743 }
23744 return resultobj;
23745 fail:
23746 return NULL;
23747 }
23748
23749
23750 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23751 PyObject *resultobj;
23752 wxDateTime *arg1 = (wxDateTime *) 0 ;
23753 wxString result;
23754 PyObject * obj0 = 0 ;
23755 char *kwnames[] = {
23756 (char *) "self", NULL
23757 };
23758
23759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23761 if (SWIG_arg_fail(1)) SWIG_fail;
23762 {
23763 PyThreadState* __tstate = wxPyBeginAllowThreads();
23764 result = ((wxDateTime const *)arg1)->FormatTime();
23765
23766 wxPyEndAllowThreads(__tstate);
23767 if (PyErr_Occurred()) SWIG_fail;
23768 }
23769 {
23770 #if wxUSE_UNICODE
23771 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23772 #else
23773 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23774 #endif
23775 }
23776 return resultobj;
23777 fail:
23778 return NULL;
23779 }
23780
23781
23782 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23783 PyObject *resultobj;
23784 wxDateTime *arg1 = (wxDateTime *) 0 ;
23785 wxString result;
23786 PyObject * obj0 = 0 ;
23787 char *kwnames[] = {
23788 (char *) "self", NULL
23789 };
23790
23791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23793 if (SWIG_arg_fail(1)) SWIG_fail;
23794 {
23795 PyThreadState* __tstate = wxPyBeginAllowThreads();
23796 result = ((wxDateTime const *)arg1)->FormatISODate();
23797
23798 wxPyEndAllowThreads(__tstate);
23799 if (PyErr_Occurred()) SWIG_fail;
23800 }
23801 {
23802 #if wxUSE_UNICODE
23803 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23804 #else
23805 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23806 #endif
23807 }
23808 return resultobj;
23809 fail:
23810 return NULL;
23811 }
23812
23813
23814 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23815 PyObject *resultobj;
23816 wxDateTime *arg1 = (wxDateTime *) 0 ;
23817 wxString result;
23818 PyObject * obj0 = 0 ;
23819 char *kwnames[] = {
23820 (char *) "self", NULL
23821 };
23822
23823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23825 if (SWIG_arg_fail(1)) SWIG_fail;
23826 {
23827 PyThreadState* __tstate = wxPyBeginAllowThreads();
23828 result = ((wxDateTime const *)arg1)->FormatISOTime();
23829
23830 wxPyEndAllowThreads(__tstate);
23831 if (PyErr_Occurred()) SWIG_fail;
23832 }
23833 {
23834 #if wxUSE_UNICODE
23835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23836 #else
23837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23838 #endif
23839 }
23840 return resultobj;
23841 fail:
23842 return NULL;
23843 }
23844
23845
23846 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23847 PyObject *obj;
23848 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23849 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23850 Py_INCREF(obj);
23851 return Py_BuildValue((char *)"");
23852 }
23853 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23854 PyObject *resultobj;
23855 long arg1 ;
23856 wxTimeSpan result;
23857 PyObject * obj0 = 0 ;
23858 char *kwnames[] = {
23859 (char *) "sec", NULL
23860 };
23861
23862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23863 {
23864 arg1 = (long)(SWIG_As_long(obj0));
23865 if (SWIG_arg_fail(1)) SWIG_fail;
23866 }
23867 {
23868 PyThreadState* __tstate = wxPyBeginAllowThreads();
23869 result = wxTimeSpan::Seconds(arg1);
23870
23871 wxPyEndAllowThreads(__tstate);
23872 if (PyErr_Occurred()) SWIG_fail;
23873 }
23874 {
23875 wxTimeSpan * resultptr;
23876 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23877 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23878 }
23879 return resultobj;
23880 fail:
23881 return NULL;
23882 }
23883
23884
23885 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23886 PyObject *resultobj;
23887 wxTimeSpan result;
23888 char *kwnames[] = {
23889 NULL
23890 };
23891
23892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23893 {
23894 PyThreadState* __tstate = wxPyBeginAllowThreads();
23895 result = wxTimeSpan::Second();
23896
23897 wxPyEndAllowThreads(__tstate);
23898 if (PyErr_Occurred()) SWIG_fail;
23899 }
23900 {
23901 wxTimeSpan * resultptr;
23902 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23903 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23904 }
23905 return resultobj;
23906 fail:
23907 return NULL;
23908 }
23909
23910
23911 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23912 PyObject *resultobj;
23913 long arg1 ;
23914 wxTimeSpan result;
23915 PyObject * obj0 = 0 ;
23916 char *kwnames[] = {
23917 (char *) "min", NULL
23918 };
23919
23920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23921 {
23922 arg1 = (long)(SWIG_As_long(obj0));
23923 if (SWIG_arg_fail(1)) SWIG_fail;
23924 }
23925 {
23926 PyThreadState* __tstate = wxPyBeginAllowThreads();
23927 result = wxTimeSpan::Minutes(arg1);
23928
23929 wxPyEndAllowThreads(__tstate);
23930 if (PyErr_Occurred()) SWIG_fail;
23931 }
23932 {
23933 wxTimeSpan * resultptr;
23934 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23935 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23936 }
23937 return resultobj;
23938 fail:
23939 return NULL;
23940 }
23941
23942
23943 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23944 PyObject *resultobj;
23945 wxTimeSpan result;
23946 char *kwnames[] = {
23947 NULL
23948 };
23949
23950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23951 {
23952 PyThreadState* __tstate = wxPyBeginAllowThreads();
23953 result = wxTimeSpan::Minute();
23954
23955 wxPyEndAllowThreads(__tstate);
23956 if (PyErr_Occurred()) SWIG_fail;
23957 }
23958 {
23959 wxTimeSpan * resultptr;
23960 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23961 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23962 }
23963 return resultobj;
23964 fail:
23965 return NULL;
23966 }
23967
23968
23969 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23970 PyObject *resultobj;
23971 long arg1 ;
23972 wxTimeSpan result;
23973 PyObject * obj0 = 0 ;
23974 char *kwnames[] = {
23975 (char *) "hours", NULL
23976 };
23977
23978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23979 {
23980 arg1 = (long)(SWIG_As_long(obj0));
23981 if (SWIG_arg_fail(1)) SWIG_fail;
23982 }
23983 {
23984 PyThreadState* __tstate = wxPyBeginAllowThreads();
23985 result = wxTimeSpan::Hours(arg1);
23986
23987 wxPyEndAllowThreads(__tstate);
23988 if (PyErr_Occurred()) SWIG_fail;
23989 }
23990 {
23991 wxTimeSpan * resultptr;
23992 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23993 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23994 }
23995 return resultobj;
23996 fail:
23997 return NULL;
23998 }
23999
24000
24001 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
24002 PyObject *resultobj;
24003 wxTimeSpan result;
24004 char *kwnames[] = {
24005 NULL
24006 };
24007
24008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
24009 {
24010 PyThreadState* __tstate = wxPyBeginAllowThreads();
24011 result = wxTimeSpan::Hour();
24012
24013 wxPyEndAllowThreads(__tstate);
24014 if (PyErr_Occurred()) SWIG_fail;
24015 }
24016 {
24017 wxTimeSpan * resultptr;
24018 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24019 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24020 }
24021 return resultobj;
24022 fail:
24023 return NULL;
24024 }
24025
24026
24027 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24028 PyObject *resultobj;
24029 long arg1 ;
24030 wxTimeSpan result;
24031 PyObject * obj0 = 0 ;
24032 char *kwnames[] = {
24033 (char *) "days", NULL
24034 };
24035
24036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24037 {
24038 arg1 = (long)(SWIG_As_long(obj0));
24039 if (SWIG_arg_fail(1)) SWIG_fail;
24040 }
24041 {
24042 PyThreadState* __tstate = wxPyBeginAllowThreads();
24043 result = wxTimeSpan::Days(arg1);
24044
24045 wxPyEndAllowThreads(__tstate);
24046 if (PyErr_Occurred()) SWIG_fail;
24047 }
24048 {
24049 wxTimeSpan * resultptr;
24050 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24051 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24052 }
24053 return resultobj;
24054 fail:
24055 return NULL;
24056 }
24057
24058
24059 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24060 PyObject *resultobj;
24061 wxTimeSpan result;
24062 char *kwnames[] = {
24063 NULL
24064 };
24065
24066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24067 {
24068 PyThreadState* __tstate = wxPyBeginAllowThreads();
24069 result = wxTimeSpan::Day();
24070
24071 wxPyEndAllowThreads(__tstate);
24072 if (PyErr_Occurred()) SWIG_fail;
24073 }
24074 {
24075 wxTimeSpan * resultptr;
24076 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24077 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24078 }
24079 return resultobj;
24080 fail:
24081 return NULL;
24082 }
24083
24084
24085 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24086 PyObject *resultobj;
24087 long arg1 ;
24088 wxTimeSpan result;
24089 PyObject * obj0 = 0 ;
24090 char *kwnames[] = {
24091 (char *) "days", NULL
24092 };
24093
24094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24095 {
24096 arg1 = (long)(SWIG_As_long(obj0));
24097 if (SWIG_arg_fail(1)) SWIG_fail;
24098 }
24099 {
24100 PyThreadState* __tstate = wxPyBeginAllowThreads();
24101 result = wxTimeSpan::Weeks(arg1);
24102
24103 wxPyEndAllowThreads(__tstate);
24104 if (PyErr_Occurred()) SWIG_fail;
24105 }
24106 {
24107 wxTimeSpan * resultptr;
24108 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24109 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24110 }
24111 return resultobj;
24112 fail:
24113 return NULL;
24114 }
24115
24116
24117 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24118 PyObject *resultobj;
24119 wxTimeSpan result;
24120 char *kwnames[] = {
24121 NULL
24122 };
24123
24124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24125 {
24126 PyThreadState* __tstate = wxPyBeginAllowThreads();
24127 result = wxTimeSpan::Week();
24128
24129 wxPyEndAllowThreads(__tstate);
24130 if (PyErr_Occurred()) SWIG_fail;
24131 }
24132 {
24133 wxTimeSpan * resultptr;
24134 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24135 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24136 }
24137 return resultobj;
24138 fail:
24139 return NULL;
24140 }
24141
24142
24143 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24144 PyObject *resultobj;
24145 long arg1 = (long) 0 ;
24146 long arg2 = (long) 0 ;
24147 long arg3 = (long) 0 ;
24148 long arg4 = (long) 0 ;
24149 wxTimeSpan *result;
24150 PyObject * obj0 = 0 ;
24151 PyObject * obj1 = 0 ;
24152 PyObject * obj2 = 0 ;
24153 PyObject * obj3 = 0 ;
24154 char *kwnames[] = {
24155 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24156 };
24157
24158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24159 if (obj0) {
24160 {
24161 arg1 = (long)(SWIG_As_long(obj0));
24162 if (SWIG_arg_fail(1)) SWIG_fail;
24163 }
24164 }
24165 if (obj1) {
24166 {
24167 arg2 = (long)(SWIG_As_long(obj1));
24168 if (SWIG_arg_fail(2)) SWIG_fail;
24169 }
24170 }
24171 if (obj2) {
24172 {
24173 arg3 = (long)(SWIG_As_long(obj2));
24174 if (SWIG_arg_fail(3)) SWIG_fail;
24175 }
24176 }
24177 if (obj3) {
24178 {
24179 arg4 = (long)(SWIG_As_long(obj3));
24180 if (SWIG_arg_fail(4)) SWIG_fail;
24181 }
24182 }
24183 {
24184 PyThreadState* __tstate = wxPyBeginAllowThreads();
24185 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24186
24187 wxPyEndAllowThreads(__tstate);
24188 if (PyErr_Occurred()) SWIG_fail;
24189 }
24190 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24191 return resultobj;
24192 fail:
24193 return NULL;
24194 }
24195
24196
24197 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24198 PyObject *resultobj;
24199 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24200 PyObject * obj0 = 0 ;
24201 char *kwnames[] = {
24202 (char *) "self", NULL
24203 };
24204
24205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24207 if (SWIG_arg_fail(1)) SWIG_fail;
24208 {
24209 PyThreadState* __tstate = wxPyBeginAllowThreads();
24210 delete arg1;
24211
24212 wxPyEndAllowThreads(__tstate);
24213 if (PyErr_Occurred()) SWIG_fail;
24214 }
24215 Py_INCREF(Py_None); resultobj = Py_None;
24216 return resultobj;
24217 fail:
24218 return NULL;
24219 }
24220
24221
24222 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24223 PyObject *resultobj;
24224 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24225 wxTimeSpan *arg2 = 0 ;
24226 wxTimeSpan *result;
24227 PyObject * obj0 = 0 ;
24228 PyObject * obj1 = 0 ;
24229 char *kwnames[] = {
24230 (char *) "self",(char *) "diff", NULL
24231 };
24232
24233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24235 if (SWIG_arg_fail(1)) SWIG_fail;
24236 {
24237 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24238 if (SWIG_arg_fail(2)) SWIG_fail;
24239 if (arg2 == NULL) {
24240 SWIG_null_ref("wxTimeSpan");
24241 }
24242 if (SWIG_arg_fail(2)) SWIG_fail;
24243 }
24244 {
24245 PyThreadState* __tstate = wxPyBeginAllowThreads();
24246 {
24247 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24248 result = (wxTimeSpan *) &_result_ref;
24249 }
24250
24251 wxPyEndAllowThreads(__tstate);
24252 if (PyErr_Occurred()) SWIG_fail;
24253 }
24254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24255 return resultobj;
24256 fail:
24257 return NULL;
24258 }
24259
24260
24261 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24262 PyObject *resultobj;
24263 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24264 wxTimeSpan *arg2 = 0 ;
24265 wxTimeSpan *result;
24266 PyObject * obj0 = 0 ;
24267 PyObject * obj1 = 0 ;
24268 char *kwnames[] = {
24269 (char *) "self",(char *) "diff", NULL
24270 };
24271
24272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24274 if (SWIG_arg_fail(1)) SWIG_fail;
24275 {
24276 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24277 if (SWIG_arg_fail(2)) SWIG_fail;
24278 if (arg2 == NULL) {
24279 SWIG_null_ref("wxTimeSpan");
24280 }
24281 if (SWIG_arg_fail(2)) SWIG_fail;
24282 }
24283 {
24284 PyThreadState* __tstate = wxPyBeginAllowThreads();
24285 {
24286 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24287 result = (wxTimeSpan *) &_result_ref;
24288 }
24289
24290 wxPyEndAllowThreads(__tstate);
24291 if (PyErr_Occurred()) SWIG_fail;
24292 }
24293 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24294 return resultobj;
24295 fail:
24296 return NULL;
24297 }
24298
24299
24300 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24301 PyObject *resultobj;
24302 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24303 int arg2 ;
24304 wxTimeSpan *result;
24305 PyObject * obj0 = 0 ;
24306 PyObject * obj1 = 0 ;
24307 char *kwnames[] = {
24308 (char *) "self",(char *) "n", NULL
24309 };
24310
24311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24313 if (SWIG_arg_fail(1)) SWIG_fail;
24314 {
24315 arg2 = (int)(SWIG_As_int(obj1));
24316 if (SWIG_arg_fail(2)) SWIG_fail;
24317 }
24318 {
24319 PyThreadState* __tstate = wxPyBeginAllowThreads();
24320 {
24321 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24322 result = (wxTimeSpan *) &_result_ref;
24323 }
24324
24325 wxPyEndAllowThreads(__tstate);
24326 if (PyErr_Occurred()) SWIG_fail;
24327 }
24328 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24336 PyObject *resultobj;
24337 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24338 wxTimeSpan *result;
24339 PyObject * obj0 = 0 ;
24340 char *kwnames[] = {
24341 (char *) "self", NULL
24342 };
24343
24344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24346 if (SWIG_arg_fail(1)) SWIG_fail;
24347 {
24348 PyThreadState* __tstate = wxPyBeginAllowThreads();
24349 {
24350 wxTimeSpan &_result_ref = (arg1)->Neg();
24351 result = (wxTimeSpan *) &_result_ref;
24352 }
24353
24354 wxPyEndAllowThreads(__tstate);
24355 if (PyErr_Occurred()) SWIG_fail;
24356 }
24357 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24358 return resultobj;
24359 fail:
24360 return NULL;
24361 }
24362
24363
24364 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24365 PyObject *resultobj;
24366 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24367 wxTimeSpan result;
24368 PyObject * obj0 = 0 ;
24369 char *kwnames[] = {
24370 (char *) "self", NULL
24371 };
24372
24373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24375 if (SWIG_arg_fail(1)) SWIG_fail;
24376 {
24377 PyThreadState* __tstate = wxPyBeginAllowThreads();
24378 result = ((wxTimeSpan const *)arg1)->Abs();
24379
24380 wxPyEndAllowThreads(__tstate);
24381 if (PyErr_Occurred()) SWIG_fail;
24382 }
24383 {
24384 wxTimeSpan * resultptr;
24385 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24386 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24387 }
24388 return resultobj;
24389 fail:
24390 return NULL;
24391 }
24392
24393
24394 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24395 PyObject *resultobj;
24396 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24397 wxTimeSpan *arg2 = 0 ;
24398 wxTimeSpan *result;
24399 PyObject * obj0 = 0 ;
24400 PyObject * obj1 = 0 ;
24401 char *kwnames[] = {
24402 (char *) "self",(char *) "diff", NULL
24403 };
24404
24405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24407 if (SWIG_arg_fail(1)) SWIG_fail;
24408 {
24409 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24410 if (SWIG_arg_fail(2)) SWIG_fail;
24411 if (arg2 == NULL) {
24412 SWIG_null_ref("wxTimeSpan");
24413 }
24414 if (SWIG_arg_fail(2)) SWIG_fail;
24415 }
24416 {
24417 PyThreadState* __tstate = wxPyBeginAllowThreads();
24418 {
24419 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24420 result = (wxTimeSpan *) &_result_ref;
24421 }
24422
24423 wxPyEndAllowThreads(__tstate);
24424 if (PyErr_Occurred()) SWIG_fail;
24425 }
24426 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24427 return resultobj;
24428 fail:
24429 return NULL;
24430 }
24431
24432
24433 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24434 PyObject *resultobj;
24435 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24436 wxTimeSpan *arg2 = 0 ;
24437 wxTimeSpan *result;
24438 PyObject * obj0 = 0 ;
24439 PyObject * obj1 = 0 ;
24440 char *kwnames[] = {
24441 (char *) "self",(char *) "diff", NULL
24442 };
24443
24444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24446 if (SWIG_arg_fail(1)) SWIG_fail;
24447 {
24448 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24449 if (SWIG_arg_fail(2)) SWIG_fail;
24450 if (arg2 == NULL) {
24451 SWIG_null_ref("wxTimeSpan");
24452 }
24453 if (SWIG_arg_fail(2)) SWIG_fail;
24454 }
24455 {
24456 PyThreadState* __tstate = wxPyBeginAllowThreads();
24457 {
24458 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24459 result = (wxTimeSpan *) &_result_ref;
24460 }
24461
24462 wxPyEndAllowThreads(__tstate);
24463 if (PyErr_Occurred()) SWIG_fail;
24464 }
24465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24466 return resultobj;
24467 fail:
24468 return NULL;
24469 }
24470
24471
24472 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24473 PyObject *resultobj;
24474 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24475 int arg2 ;
24476 wxTimeSpan *result;
24477 PyObject * obj0 = 0 ;
24478 PyObject * obj1 = 0 ;
24479 char *kwnames[] = {
24480 (char *) "self",(char *) "n", NULL
24481 };
24482
24483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24485 if (SWIG_arg_fail(1)) SWIG_fail;
24486 {
24487 arg2 = (int)(SWIG_As_int(obj1));
24488 if (SWIG_arg_fail(2)) SWIG_fail;
24489 }
24490 {
24491 PyThreadState* __tstate = wxPyBeginAllowThreads();
24492 {
24493 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24494 result = (wxTimeSpan *) &_result_ref;
24495 }
24496
24497 wxPyEndAllowThreads(__tstate);
24498 if (PyErr_Occurred()) SWIG_fail;
24499 }
24500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24501 return resultobj;
24502 fail:
24503 return NULL;
24504 }
24505
24506
24507 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24508 PyObject *resultobj;
24509 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24510 wxTimeSpan *result;
24511 PyObject * obj0 = 0 ;
24512 char *kwnames[] = {
24513 (char *) "self", NULL
24514 };
24515
24516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24518 if (SWIG_arg_fail(1)) SWIG_fail;
24519 {
24520 PyThreadState* __tstate = wxPyBeginAllowThreads();
24521 {
24522 wxTimeSpan &_result_ref = (arg1)->operator -();
24523 result = (wxTimeSpan *) &_result_ref;
24524 }
24525
24526 wxPyEndAllowThreads(__tstate);
24527 if (PyErr_Occurred()) SWIG_fail;
24528 }
24529 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24530 return resultobj;
24531 fail:
24532 return NULL;
24533 }
24534
24535
24536 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24537 PyObject *resultobj;
24538 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24539 wxTimeSpan *arg2 = 0 ;
24540 wxTimeSpan result;
24541 PyObject * obj0 = 0 ;
24542 PyObject * obj1 = 0 ;
24543 char *kwnames[] = {
24544 (char *) "self",(char *) "other", NULL
24545 };
24546
24547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24549 if (SWIG_arg_fail(1)) SWIG_fail;
24550 {
24551 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24552 if (SWIG_arg_fail(2)) SWIG_fail;
24553 if (arg2 == NULL) {
24554 SWIG_null_ref("wxTimeSpan");
24555 }
24556 if (SWIG_arg_fail(2)) SWIG_fail;
24557 }
24558 {
24559 PyThreadState* __tstate = wxPyBeginAllowThreads();
24560 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24561
24562 wxPyEndAllowThreads(__tstate);
24563 if (PyErr_Occurred()) SWIG_fail;
24564 }
24565 {
24566 wxTimeSpan * resultptr;
24567 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24568 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24569 }
24570 return resultobj;
24571 fail:
24572 return NULL;
24573 }
24574
24575
24576 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24577 PyObject *resultobj;
24578 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24579 wxTimeSpan *arg2 = 0 ;
24580 wxTimeSpan result;
24581 PyObject * obj0 = 0 ;
24582 PyObject * obj1 = 0 ;
24583 char *kwnames[] = {
24584 (char *) "self",(char *) "other", NULL
24585 };
24586
24587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24589 if (SWIG_arg_fail(1)) SWIG_fail;
24590 {
24591 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24592 if (SWIG_arg_fail(2)) SWIG_fail;
24593 if (arg2 == NULL) {
24594 SWIG_null_ref("wxTimeSpan");
24595 }
24596 if (SWIG_arg_fail(2)) SWIG_fail;
24597 }
24598 {
24599 PyThreadState* __tstate = wxPyBeginAllowThreads();
24600 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24601
24602 wxPyEndAllowThreads(__tstate);
24603 if (PyErr_Occurred()) SWIG_fail;
24604 }
24605 {
24606 wxTimeSpan * resultptr;
24607 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24608 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24609 }
24610 return resultobj;
24611 fail:
24612 return NULL;
24613 }
24614
24615
24616 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24617 PyObject *resultobj;
24618 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24619 int arg2 ;
24620 wxTimeSpan result;
24621 PyObject * obj0 = 0 ;
24622 PyObject * obj1 = 0 ;
24623 char *kwnames[] = {
24624 (char *) "self",(char *) "n", NULL
24625 };
24626
24627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24629 if (SWIG_arg_fail(1)) SWIG_fail;
24630 {
24631 arg2 = (int)(SWIG_As_int(obj1));
24632 if (SWIG_arg_fail(2)) SWIG_fail;
24633 }
24634 {
24635 PyThreadState* __tstate = wxPyBeginAllowThreads();
24636 result = wxTimeSpan___mul__(arg1,arg2);
24637
24638 wxPyEndAllowThreads(__tstate);
24639 if (PyErr_Occurred()) SWIG_fail;
24640 }
24641 {
24642 wxTimeSpan * resultptr;
24643 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24644 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24645 }
24646 return resultobj;
24647 fail:
24648 return NULL;
24649 }
24650
24651
24652 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24653 PyObject *resultobj;
24654 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24655 int arg2 ;
24656 wxTimeSpan result;
24657 PyObject * obj0 = 0 ;
24658 PyObject * obj1 = 0 ;
24659 char *kwnames[] = {
24660 (char *) "self",(char *) "n", NULL
24661 };
24662
24663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24665 if (SWIG_arg_fail(1)) SWIG_fail;
24666 {
24667 arg2 = (int)(SWIG_As_int(obj1));
24668 if (SWIG_arg_fail(2)) SWIG_fail;
24669 }
24670 {
24671 PyThreadState* __tstate = wxPyBeginAllowThreads();
24672 result = wxTimeSpan___rmul__(arg1,arg2);
24673
24674 wxPyEndAllowThreads(__tstate);
24675 if (PyErr_Occurred()) SWIG_fail;
24676 }
24677 {
24678 wxTimeSpan * resultptr;
24679 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24680 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24681 }
24682 return resultobj;
24683 fail:
24684 return NULL;
24685 }
24686
24687
24688 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24689 PyObject *resultobj;
24690 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24691 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24692 bool result;
24693 PyObject * obj0 = 0 ;
24694 PyObject * obj1 = 0 ;
24695 char *kwnames[] = {
24696 (char *) "self",(char *) "other", NULL
24697 };
24698
24699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24701 if (SWIG_arg_fail(1)) SWIG_fail;
24702 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24703 if (SWIG_arg_fail(2)) SWIG_fail;
24704 {
24705 PyThreadState* __tstate = wxPyBeginAllowThreads();
24706 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24707
24708 wxPyEndAllowThreads(__tstate);
24709 if (PyErr_Occurred()) SWIG_fail;
24710 }
24711 {
24712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24713 }
24714 return resultobj;
24715 fail:
24716 return NULL;
24717 }
24718
24719
24720 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24721 PyObject *resultobj;
24722 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24723 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24724 bool result;
24725 PyObject * obj0 = 0 ;
24726 PyObject * obj1 = 0 ;
24727 char *kwnames[] = {
24728 (char *) "self",(char *) "other", NULL
24729 };
24730
24731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24733 if (SWIG_arg_fail(1)) SWIG_fail;
24734 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24735 if (SWIG_arg_fail(2)) SWIG_fail;
24736 {
24737 PyThreadState* __tstate = wxPyBeginAllowThreads();
24738 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24739
24740 wxPyEndAllowThreads(__tstate);
24741 if (PyErr_Occurred()) SWIG_fail;
24742 }
24743 {
24744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24745 }
24746 return resultobj;
24747 fail:
24748 return NULL;
24749 }
24750
24751
24752 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24753 PyObject *resultobj;
24754 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24755 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24756 bool result;
24757 PyObject * obj0 = 0 ;
24758 PyObject * obj1 = 0 ;
24759 char *kwnames[] = {
24760 (char *) "self",(char *) "other", NULL
24761 };
24762
24763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24765 if (SWIG_arg_fail(1)) SWIG_fail;
24766 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24767 if (SWIG_arg_fail(2)) SWIG_fail;
24768 {
24769 PyThreadState* __tstate = wxPyBeginAllowThreads();
24770 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24771
24772 wxPyEndAllowThreads(__tstate);
24773 if (PyErr_Occurred()) SWIG_fail;
24774 }
24775 {
24776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24777 }
24778 return resultobj;
24779 fail:
24780 return NULL;
24781 }
24782
24783
24784 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24785 PyObject *resultobj;
24786 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24787 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24788 bool result;
24789 PyObject * obj0 = 0 ;
24790 PyObject * obj1 = 0 ;
24791 char *kwnames[] = {
24792 (char *) "self",(char *) "other", NULL
24793 };
24794
24795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24797 if (SWIG_arg_fail(1)) SWIG_fail;
24798 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24799 if (SWIG_arg_fail(2)) SWIG_fail;
24800 {
24801 PyThreadState* __tstate = wxPyBeginAllowThreads();
24802 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24803
24804 wxPyEndAllowThreads(__tstate);
24805 if (PyErr_Occurred()) SWIG_fail;
24806 }
24807 {
24808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24809 }
24810 return resultobj;
24811 fail:
24812 return NULL;
24813 }
24814
24815
24816 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24817 PyObject *resultobj;
24818 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24819 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24820 bool result;
24821 PyObject * obj0 = 0 ;
24822 PyObject * obj1 = 0 ;
24823 char *kwnames[] = {
24824 (char *) "self",(char *) "other", NULL
24825 };
24826
24827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24829 if (SWIG_arg_fail(1)) SWIG_fail;
24830 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24831 if (SWIG_arg_fail(2)) SWIG_fail;
24832 {
24833 PyThreadState* __tstate = wxPyBeginAllowThreads();
24834 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24835
24836 wxPyEndAllowThreads(__tstate);
24837 if (PyErr_Occurred()) SWIG_fail;
24838 }
24839 {
24840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24841 }
24842 return resultobj;
24843 fail:
24844 return NULL;
24845 }
24846
24847
24848 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24849 PyObject *resultobj;
24850 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24851 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24852 bool result;
24853 PyObject * obj0 = 0 ;
24854 PyObject * obj1 = 0 ;
24855 char *kwnames[] = {
24856 (char *) "self",(char *) "other", NULL
24857 };
24858
24859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24861 if (SWIG_arg_fail(1)) SWIG_fail;
24862 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24863 if (SWIG_arg_fail(2)) SWIG_fail;
24864 {
24865 PyThreadState* __tstate = wxPyBeginAllowThreads();
24866 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24867
24868 wxPyEndAllowThreads(__tstate);
24869 if (PyErr_Occurred()) SWIG_fail;
24870 }
24871 {
24872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24873 }
24874 return resultobj;
24875 fail:
24876 return NULL;
24877 }
24878
24879
24880 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24881 PyObject *resultobj;
24882 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24883 bool result;
24884 PyObject * obj0 = 0 ;
24885 char *kwnames[] = {
24886 (char *) "self", NULL
24887 };
24888
24889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24891 if (SWIG_arg_fail(1)) SWIG_fail;
24892 {
24893 PyThreadState* __tstate = wxPyBeginAllowThreads();
24894 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24895
24896 wxPyEndAllowThreads(__tstate);
24897 if (PyErr_Occurred()) SWIG_fail;
24898 }
24899 {
24900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24901 }
24902 return resultobj;
24903 fail:
24904 return NULL;
24905 }
24906
24907
24908 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24909 PyObject *resultobj;
24910 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24911 bool result;
24912 PyObject * obj0 = 0 ;
24913 char *kwnames[] = {
24914 (char *) "self", NULL
24915 };
24916
24917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24919 if (SWIG_arg_fail(1)) SWIG_fail;
24920 {
24921 PyThreadState* __tstate = wxPyBeginAllowThreads();
24922 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24923
24924 wxPyEndAllowThreads(__tstate);
24925 if (PyErr_Occurred()) SWIG_fail;
24926 }
24927 {
24928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24929 }
24930 return resultobj;
24931 fail:
24932 return NULL;
24933 }
24934
24935
24936 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24937 PyObject *resultobj;
24938 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24939 bool result;
24940 PyObject * obj0 = 0 ;
24941 char *kwnames[] = {
24942 (char *) "self", NULL
24943 };
24944
24945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24947 if (SWIG_arg_fail(1)) SWIG_fail;
24948 {
24949 PyThreadState* __tstate = wxPyBeginAllowThreads();
24950 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24951
24952 wxPyEndAllowThreads(__tstate);
24953 if (PyErr_Occurred()) SWIG_fail;
24954 }
24955 {
24956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24957 }
24958 return resultobj;
24959 fail:
24960 return NULL;
24961 }
24962
24963
24964 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24965 PyObject *resultobj;
24966 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24967 wxTimeSpan *arg2 = 0 ;
24968 bool result;
24969 PyObject * obj0 = 0 ;
24970 PyObject * obj1 = 0 ;
24971 char *kwnames[] = {
24972 (char *) "self",(char *) "ts", NULL
24973 };
24974
24975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24977 if (SWIG_arg_fail(1)) SWIG_fail;
24978 {
24979 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24980 if (SWIG_arg_fail(2)) SWIG_fail;
24981 if (arg2 == NULL) {
24982 SWIG_null_ref("wxTimeSpan");
24983 }
24984 if (SWIG_arg_fail(2)) SWIG_fail;
24985 }
24986 {
24987 PyThreadState* __tstate = wxPyBeginAllowThreads();
24988 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24989
24990 wxPyEndAllowThreads(__tstate);
24991 if (PyErr_Occurred()) SWIG_fail;
24992 }
24993 {
24994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24995 }
24996 return resultobj;
24997 fail:
24998 return NULL;
24999 }
25000
25001
25002 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
25003 PyObject *resultobj;
25004 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25005 wxTimeSpan *arg2 = 0 ;
25006 bool result;
25007 PyObject * obj0 = 0 ;
25008 PyObject * obj1 = 0 ;
25009 char *kwnames[] = {
25010 (char *) "self",(char *) "ts", NULL
25011 };
25012
25013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
25014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25015 if (SWIG_arg_fail(1)) SWIG_fail;
25016 {
25017 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25018 if (SWIG_arg_fail(2)) SWIG_fail;
25019 if (arg2 == NULL) {
25020 SWIG_null_ref("wxTimeSpan");
25021 }
25022 if (SWIG_arg_fail(2)) SWIG_fail;
25023 }
25024 {
25025 PyThreadState* __tstate = wxPyBeginAllowThreads();
25026 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
25027
25028 wxPyEndAllowThreads(__tstate);
25029 if (PyErr_Occurred()) SWIG_fail;
25030 }
25031 {
25032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25033 }
25034 return resultobj;
25035 fail:
25036 return NULL;
25037 }
25038
25039
25040 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25041 PyObject *resultobj;
25042 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25043 wxTimeSpan *arg2 = 0 ;
25044 bool result;
25045 PyObject * obj0 = 0 ;
25046 PyObject * obj1 = 0 ;
25047 char *kwnames[] = {
25048 (char *) "self",(char *) "t", NULL
25049 };
25050
25051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25053 if (SWIG_arg_fail(1)) SWIG_fail;
25054 {
25055 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25056 if (SWIG_arg_fail(2)) SWIG_fail;
25057 if (arg2 == NULL) {
25058 SWIG_null_ref("wxTimeSpan");
25059 }
25060 if (SWIG_arg_fail(2)) SWIG_fail;
25061 }
25062 {
25063 PyThreadState* __tstate = wxPyBeginAllowThreads();
25064 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25065
25066 wxPyEndAllowThreads(__tstate);
25067 if (PyErr_Occurred()) SWIG_fail;
25068 }
25069 {
25070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25071 }
25072 return resultobj;
25073 fail:
25074 return NULL;
25075 }
25076
25077
25078 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25079 PyObject *resultobj;
25080 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25081 int result;
25082 PyObject * obj0 = 0 ;
25083 char *kwnames[] = {
25084 (char *) "self", NULL
25085 };
25086
25087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25089 if (SWIG_arg_fail(1)) SWIG_fail;
25090 {
25091 PyThreadState* __tstate = wxPyBeginAllowThreads();
25092 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25093
25094 wxPyEndAllowThreads(__tstate);
25095 if (PyErr_Occurred()) SWIG_fail;
25096 }
25097 {
25098 resultobj = SWIG_From_int((int)(result));
25099 }
25100 return resultobj;
25101 fail:
25102 return NULL;
25103 }
25104
25105
25106 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25107 PyObject *resultobj;
25108 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25109 int result;
25110 PyObject * obj0 = 0 ;
25111 char *kwnames[] = {
25112 (char *) "self", NULL
25113 };
25114
25115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25117 if (SWIG_arg_fail(1)) SWIG_fail;
25118 {
25119 PyThreadState* __tstate = wxPyBeginAllowThreads();
25120 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25121
25122 wxPyEndAllowThreads(__tstate);
25123 if (PyErr_Occurred()) SWIG_fail;
25124 }
25125 {
25126 resultobj = SWIG_From_int((int)(result));
25127 }
25128 return resultobj;
25129 fail:
25130 return NULL;
25131 }
25132
25133
25134 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25135 PyObject *resultobj;
25136 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25137 int result;
25138 PyObject * obj0 = 0 ;
25139 char *kwnames[] = {
25140 (char *) "self", NULL
25141 };
25142
25143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25145 if (SWIG_arg_fail(1)) SWIG_fail;
25146 {
25147 PyThreadState* __tstate = wxPyBeginAllowThreads();
25148 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25149
25150 wxPyEndAllowThreads(__tstate);
25151 if (PyErr_Occurred()) SWIG_fail;
25152 }
25153 {
25154 resultobj = SWIG_From_int((int)(result));
25155 }
25156 return resultobj;
25157 fail:
25158 return NULL;
25159 }
25160
25161
25162 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25163 PyObject *resultobj;
25164 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25165 int result;
25166 PyObject * obj0 = 0 ;
25167 char *kwnames[] = {
25168 (char *) "self", NULL
25169 };
25170
25171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25173 if (SWIG_arg_fail(1)) SWIG_fail;
25174 {
25175 PyThreadState* __tstate = wxPyBeginAllowThreads();
25176 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25177
25178 wxPyEndAllowThreads(__tstate);
25179 if (PyErr_Occurred()) SWIG_fail;
25180 }
25181 {
25182 resultobj = SWIG_From_int((int)(result));
25183 }
25184 return resultobj;
25185 fail:
25186 return NULL;
25187 }
25188
25189
25190 static PyObject *_wrap_TimeSpan_GetSeconds(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_GetSeconds",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)->GetSeconds();
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_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25228 PyObject *resultobj;
25229 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25230 wxLongLong result;
25231 PyObject * obj0 = 0 ;
25232 char *kwnames[] = {
25233 (char *) "self", NULL
25234 };
25235
25236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25238 if (SWIG_arg_fail(1)) SWIG_fail;
25239 {
25240 PyThreadState* __tstate = wxPyBeginAllowThreads();
25241 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25242
25243 wxPyEndAllowThreads(__tstate);
25244 if (PyErr_Occurred()) SWIG_fail;
25245 }
25246 {
25247 PyObject *hi, *lo, *shifter, *shifted;
25248 hi = PyLong_FromLong( (&result)->GetHi() );
25249 lo = PyLong_FromLong( (&result)->GetLo() );
25250 shifter = PyLong_FromLong(32);
25251 shifted = PyNumber_Lshift(hi, shifter);
25252 resultobj = PyNumber_Or(shifted, lo);
25253 Py_DECREF(hi);
25254 Py_DECREF(lo);
25255 Py_DECREF(shifter);
25256 Py_DECREF(shifted);
25257 }
25258 return resultobj;
25259 fail:
25260 return NULL;
25261 }
25262
25263
25264 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25265 PyObject *resultobj;
25266 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25267 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25268 wxString *arg2 = (wxString *) &arg2_defvalue ;
25269 wxString result;
25270 bool temp2 = false ;
25271 PyObject * obj0 = 0 ;
25272 PyObject * obj1 = 0 ;
25273 char *kwnames[] = {
25274 (char *) "self",(char *) "format", NULL
25275 };
25276
25277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25279 if (SWIG_arg_fail(1)) SWIG_fail;
25280 if (obj1) {
25281 {
25282 arg2 = wxString_in_helper(obj1);
25283 if (arg2 == NULL) SWIG_fail;
25284 temp2 = true;
25285 }
25286 }
25287 {
25288 PyThreadState* __tstate = wxPyBeginAllowThreads();
25289 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25290
25291 wxPyEndAllowThreads(__tstate);
25292 if (PyErr_Occurred()) SWIG_fail;
25293 }
25294 {
25295 #if wxUSE_UNICODE
25296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25297 #else
25298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25299 #endif
25300 }
25301 {
25302 if (temp2)
25303 delete arg2;
25304 }
25305 return resultobj;
25306 fail:
25307 {
25308 if (temp2)
25309 delete arg2;
25310 }
25311 return NULL;
25312 }
25313
25314
25315 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25316 PyObject *obj;
25317 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25318 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25319 Py_INCREF(obj);
25320 return Py_BuildValue((char *)"");
25321 }
25322 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25323 PyObject *resultobj;
25324 int arg1 = (int) 0 ;
25325 int arg2 = (int) 0 ;
25326 int arg3 = (int) 0 ;
25327 int arg4 = (int) 0 ;
25328 wxDateSpan *result;
25329 PyObject * obj0 = 0 ;
25330 PyObject * obj1 = 0 ;
25331 PyObject * obj2 = 0 ;
25332 PyObject * obj3 = 0 ;
25333 char *kwnames[] = {
25334 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25335 };
25336
25337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25338 if (obj0) {
25339 {
25340 arg1 = (int)(SWIG_As_int(obj0));
25341 if (SWIG_arg_fail(1)) SWIG_fail;
25342 }
25343 }
25344 if (obj1) {
25345 {
25346 arg2 = (int)(SWIG_As_int(obj1));
25347 if (SWIG_arg_fail(2)) SWIG_fail;
25348 }
25349 }
25350 if (obj2) {
25351 {
25352 arg3 = (int)(SWIG_As_int(obj2));
25353 if (SWIG_arg_fail(3)) SWIG_fail;
25354 }
25355 }
25356 if (obj3) {
25357 {
25358 arg4 = (int)(SWIG_As_int(obj3));
25359 if (SWIG_arg_fail(4)) SWIG_fail;
25360 }
25361 }
25362 {
25363 PyThreadState* __tstate = wxPyBeginAllowThreads();
25364 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25365
25366 wxPyEndAllowThreads(__tstate);
25367 if (PyErr_Occurred()) SWIG_fail;
25368 }
25369 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25370 return resultobj;
25371 fail:
25372 return NULL;
25373 }
25374
25375
25376 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25377 PyObject *resultobj;
25378 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25379 PyObject * obj0 = 0 ;
25380 char *kwnames[] = {
25381 (char *) "self", NULL
25382 };
25383
25384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25386 if (SWIG_arg_fail(1)) SWIG_fail;
25387 {
25388 PyThreadState* __tstate = wxPyBeginAllowThreads();
25389 delete arg1;
25390
25391 wxPyEndAllowThreads(__tstate);
25392 if (PyErr_Occurred()) SWIG_fail;
25393 }
25394 Py_INCREF(Py_None); resultobj = Py_None;
25395 return resultobj;
25396 fail:
25397 return NULL;
25398 }
25399
25400
25401 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25402 PyObject *resultobj;
25403 int arg1 ;
25404 wxDateSpan result;
25405 PyObject * obj0 = 0 ;
25406 char *kwnames[] = {
25407 (char *) "days", NULL
25408 };
25409
25410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25411 {
25412 arg1 = (int)(SWIG_As_int(obj0));
25413 if (SWIG_arg_fail(1)) SWIG_fail;
25414 }
25415 {
25416 PyThreadState* __tstate = wxPyBeginAllowThreads();
25417 result = wxDateSpan::Days(arg1);
25418
25419 wxPyEndAllowThreads(__tstate);
25420 if (PyErr_Occurred()) SWIG_fail;
25421 }
25422 {
25423 wxDateSpan * resultptr;
25424 resultptr = new wxDateSpan((wxDateSpan &)(result));
25425 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25426 }
25427 return resultobj;
25428 fail:
25429 return NULL;
25430 }
25431
25432
25433 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25434 PyObject *resultobj;
25435 wxDateSpan result;
25436 char *kwnames[] = {
25437 NULL
25438 };
25439
25440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25441 {
25442 PyThreadState* __tstate = wxPyBeginAllowThreads();
25443 result = wxDateSpan::Day();
25444
25445 wxPyEndAllowThreads(__tstate);
25446 if (PyErr_Occurred()) SWIG_fail;
25447 }
25448 {
25449 wxDateSpan * resultptr;
25450 resultptr = new wxDateSpan((wxDateSpan &)(result));
25451 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25452 }
25453 return resultobj;
25454 fail:
25455 return NULL;
25456 }
25457
25458
25459 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25460 PyObject *resultobj;
25461 int arg1 ;
25462 wxDateSpan result;
25463 PyObject * obj0 = 0 ;
25464 char *kwnames[] = {
25465 (char *) "weeks", NULL
25466 };
25467
25468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25469 {
25470 arg1 = (int)(SWIG_As_int(obj0));
25471 if (SWIG_arg_fail(1)) SWIG_fail;
25472 }
25473 {
25474 PyThreadState* __tstate = wxPyBeginAllowThreads();
25475 result = wxDateSpan::Weeks(arg1);
25476
25477 wxPyEndAllowThreads(__tstate);
25478 if (PyErr_Occurred()) SWIG_fail;
25479 }
25480 {
25481 wxDateSpan * resultptr;
25482 resultptr = new wxDateSpan((wxDateSpan &)(result));
25483 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25484 }
25485 return resultobj;
25486 fail:
25487 return NULL;
25488 }
25489
25490
25491 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25492 PyObject *resultobj;
25493 wxDateSpan result;
25494 char *kwnames[] = {
25495 NULL
25496 };
25497
25498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25499 {
25500 PyThreadState* __tstate = wxPyBeginAllowThreads();
25501 result = wxDateSpan::Week();
25502
25503 wxPyEndAllowThreads(__tstate);
25504 if (PyErr_Occurred()) SWIG_fail;
25505 }
25506 {
25507 wxDateSpan * resultptr;
25508 resultptr = new wxDateSpan((wxDateSpan &)(result));
25509 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25510 }
25511 return resultobj;
25512 fail:
25513 return NULL;
25514 }
25515
25516
25517 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25518 PyObject *resultobj;
25519 int arg1 ;
25520 wxDateSpan result;
25521 PyObject * obj0 = 0 ;
25522 char *kwnames[] = {
25523 (char *) "mon", NULL
25524 };
25525
25526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25527 {
25528 arg1 = (int)(SWIG_As_int(obj0));
25529 if (SWIG_arg_fail(1)) SWIG_fail;
25530 }
25531 {
25532 PyThreadState* __tstate = wxPyBeginAllowThreads();
25533 result = wxDateSpan::Months(arg1);
25534
25535 wxPyEndAllowThreads(__tstate);
25536 if (PyErr_Occurred()) SWIG_fail;
25537 }
25538 {
25539 wxDateSpan * resultptr;
25540 resultptr = new wxDateSpan((wxDateSpan &)(result));
25541 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25542 }
25543 return resultobj;
25544 fail:
25545 return NULL;
25546 }
25547
25548
25549 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25550 PyObject *resultobj;
25551 wxDateSpan result;
25552 char *kwnames[] = {
25553 NULL
25554 };
25555
25556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25557 {
25558 PyThreadState* __tstate = wxPyBeginAllowThreads();
25559 result = wxDateSpan::Month();
25560
25561 wxPyEndAllowThreads(__tstate);
25562 if (PyErr_Occurred()) SWIG_fail;
25563 }
25564 {
25565 wxDateSpan * resultptr;
25566 resultptr = new wxDateSpan((wxDateSpan &)(result));
25567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25568 }
25569 return resultobj;
25570 fail:
25571 return NULL;
25572 }
25573
25574
25575 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25576 PyObject *resultobj;
25577 int arg1 ;
25578 wxDateSpan result;
25579 PyObject * obj0 = 0 ;
25580 char *kwnames[] = {
25581 (char *) "years", NULL
25582 };
25583
25584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25585 {
25586 arg1 = (int)(SWIG_As_int(obj0));
25587 if (SWIG_arg_fail(1)) SWIG_fail;
25588 }
25589 {
25590 PyThreadState* __tstate = wxPyBeginAllowThreads();
25591 result = wxDateSpan::Years(arg1);
25592
25593 wxPyEndAllowThreads(__tstate);
25594 if (PyErr_Occurred()) SWIG_fail;
25595 }
25596 {
25597 wxDateSpan * resultptr;
25598 resultptr = new wxDateSpan((wxDateSpan &)(result));
25599 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25600 }
25601 return resultobj;
25602 fail:
25603 return NULL;
25604 }
25605
25606
25607 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25608 PyObject *resultobj;
25609 wxDateSpan result;
25610 char *kwnames[] = {
25611 NULL
25612 };
25613
25614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25615 {
25616 PyThreadState* __tstate = wxPyBeginAllowThreads();
25617 result = wxDateSpan::Year();
25618
25619 wxPyEndAllowThreads(__tstate);
25620 if (PyErr_Occurred()) SWIG_fail;
25621 }
25622 {
25623 wxDateSpan * resultptr;
25624 resultptr = new wxDateSpan((wxDateSpan &)(result));
25625 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25626 }
25627 return resultobj;
25628 fail:
25629 return NULL;
25630 }
25631
25632
25633 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25634 PyObject *resultobj;
25635 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25636 int arg2 ;
25637 wxDateSpan *result;
25638 PyObject * obj0 = 0 ;
25639 PyObject * obj1 = 0 ;
25640 char *kwnames[] = {
25641 (char *) "self",(char *) "n", NULL
25642 };
25643
25644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25646 if (SWIG_arg_fail(1)) SWIG_fail;
25647 {
25648 arg2 = (int)(SWIG_As_int(obj1));
25649 if (SWIG_arg_fail(2)) SWIG_fail;
25650 }
25651 {
25652 PyThreadState* __tstate = wxPyBeginAllowThreads();
25653 {
25654 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25655 result = (wxDateSpan *) &_result_ref;
25656 }
25657
25658 wxPyEndAllowThreads(__tstate);
25659 if (PyErr_Occurred()) SWIG_fail;
25660 }
25661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25662 return resultobj;
25663 fail:
25664 return NULL;
25665 }
25666
25667
25668 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25669 PyObject *resultobj;
25670 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25671 int arg2 ;
25672 wxDateSpan *result;
25673 PyObject * obj0 = 0 ;
25674 PyObject * obj1 = 0 ;
25675 char *kwnames[] = {
25676 (char *) "self",(char *) "n", NULL
25677 };
25678
25679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25681 if (SWIG_arg_fail(1)) SWIG_fail;
25682 {
25683 arg2 = (int)(SWIG_As_int(obj1));
25684 if (SWIG_arg_fail(2)) SWIG_fail;
25685 }
25686 {
25687 PyThreadState* __tstate = wxPyBeginAllowThreads();
25688 {
25689 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25690 result = (wxDateSpan *) &_result_ref;
25691 }
25692
25693 wxPyEndAllowThreads(__tstate);
25694 if (PyErr_Occurred()) SWIG_fail;
25695 }
25696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25697 return resultobj;
25698 fail:
25699 return NULL;
25700 }
25701
25702
25703 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25704 PyObject *resultobj;
25705 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25706 int arg2 ;
25707 wxDateSpan *result;
25708 PyObject * obj0 = 0 ;
25709 PyObject * obj1 = 0 ;
25710 char *kwnames[] = {
25711 (char *) "self",(char *) "n", NULL
25712 };
25713
25714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25716 if (SWIG_arg_fail(1)) SWIG_fail;
25717 {
25718 arg2 = (int)(SWIG_As_int(obj1));
25719 if (SWIG_arg_fail(2)) SWIG_fail;
25720 }
25721 {
25722 PyThreadState* __tstate = wxPyBeginAllowThreads();
25723 {
25724 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25725 result = (wxDateSpan *) &_result_ref;
25726 }
25727
25728 wxPyEndAllowThreads(__tstate);
25729 if (PyErr_Occurred()) SWIG_fail;
25730 }
25731 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25732 return resultobj;
25733 fail:
25734 return NULL;
25735 }
25736
25737
25738 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25739 PyObject *resultobj;
25740 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25741 int arg2 ;
25742 wxDateSpan *result;
25743 PyObject * obj0 = 0 ;
25744 PyObject * obj1 = 0 ;
25745 char *kwnames[] = {
25746 (char *) "self",(char *) "n", NULL
25747 };
25748
25749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25751 if (SWIG_arg_fail(1)) SWIG_fail;
25752 {
25753 arg2 = (int)(SWIG_As_int(obj1));
25754 if (SWIG_arg_fail(2)) SWIG_fail;
25755 }
25756 {
25757 PyThreadState* __tstate = wxPyBeginAllowThreads();
25758 {
25759 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25760 result = (wxDateSpan *) &_result_ref;
25761 }
25762
25763 wxPyEndAllowThreads(__tstate);
25764 if (PyErr_Occurred()) SWIG_fail;
25765 }
25766 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25767 return resultobj;
25768 fail:
25769 return NULL;
25770 }
25771
25772
25773 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25774 PyObject *resultobj;
25775 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25776 int result;
25777 PyObject * obj0 = 0 ;
25778 char *kwnames[] = {
25779 (char *) "self", NULL
25780 };
25781
25782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25784 if (SWIG_arg_fail(1)) SWIG_fail;
25785 {
25786 PyThreadState* __tstate = wxPyBeginAllowThreads();
25787 result = (int)((wxDateSpan const *)arg1)->GetYears();
25788
25789 wxPyEndAllowThreads(__tstate);
25790 if (PyErr_Occurred()) SWIG_fail;
25791 }
25792 {
25793 resultobj = SWIG_From_int((int)(result));
25794 }
25795 return resultobj;
25796 fail:
25797 return NULL;
25798 }
25799
25800
25801 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25802 PyObject *resultobj;
25803 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25804 int result;
25805 PyObject * obj0 = 0 ;
25806 char *kwnames[] = {
25807 (char *) "self", NULL
25808 };
25809
25810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25812 if (SWIG_arg_fail(1)) SWIG_fail;
25813 {
25814 PyThreadState* __tstate = wxPyBeginAllowThreads();
25815 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25816
25817 wxPyEndAllowThreads(__tstate);
25818 if (PyErr_Occurred()) SWIG_fail;
25819 }
25820 {
25821 resultobj = SWIG_From_int((int)(result));
25822 }
25823 return resultobj;
25824 fail:
25825 return NULL;
25826 }
25827
25828
25829 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25830 PyObject *resultobj;
25831 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25832 int result;
25833 PyObject * obj0 = 0 ;
25834 char *kwnames[] = {
25835 (char *) "self", NULL
25836 };
25837
25838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25840 if (SWIG_arg_fail(1)) SWIG_fail;
25841 {
25842 PyThreadState* __tstate = wxPyBeginAllowThreads();
25843 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25844
25845 wxPyEndAllowThreads(__tstate);
25846 if (PyErr_Occurred()) SWIG_fail;
25847 }
25848 {
25849 resultobj = SWIG_From_int((int)(result));
25850 }
25851 return resultobj;
25852 fail:
25853 return NULL;
25854 }
25855
25856
25857 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25858 PyObject *resultobj;
25859 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25860 int result;
25861 PyObject * obj0 = 0 ;
25862 char *kwnames[] = {
25863 (char *) "self", NULL
25864 };
25865
25866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25868 if (SWIG_arg_fail(1)) SWIG_fail;
25869 {
25870 PyThreadState* __tstate = wxPyBeginAllowThreads();
25871 result = (int)((wxDateSpan const *)arg1)->GetDays();
25872
25873 wxPyEndAllowThreads(__tstate);
25874 if (PyErr_Occurred()) SWIG_fail;
25875 }
25876 {
25877 resultobj = SWIG_From_int((int)(result));
25878 }
25879 return resultobj;
25880 fail:
25881 return NULL;
25882 }
25883
25884
25885 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25886 PyObject *resultobj;
25887 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25888 int result;
25889 PyObject * obj0 = 0 ;
25890 char *kwnames[] = {
25891 (char *) "self", NULL
25892 };
25893
25894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25896 if (SWIG_arg_fail(1)) SWIG_fail;
25897 {
25898 PyThreadState* __tstate = wxPyBeginAllowThreads();
25899 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25900
25901 wxPyEndAllowThreads(__tstate);
25902 if (PyErr_Occurred()) SWIG_fail;
25903 }
25904 {
25905 resultobj = SWIG_From_int((int)(result));
25906 }
25907 return resultobj;
25908 fail:
25909 return NULL;
25910 }
25911
25912
25913 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25914 PyObject *resultobj;
25915 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25916 wxDateSpan *arg2 = 0 ;
25917 wxDateSpan *result;
25918 PyObject * obj0 = 0 ;
25919 PyObject * obj1 = 0 ;
25920 char *kwnames[] = {
25921 (char *) "self",(char *) "other", NULL
25922 };
25923
25924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25926 if (SWIG_arg_fail(1)) SWIG_fail;
25927 {
25928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25929 if (SWIG_arg_fail(2)) SWIG_fail;
25930 if (arg2 == NULL) {
25931 SWIG_null_ref("wxDateSpan");
25932 }
25933 if (SWIG_arg_fail(2)) SWIG_fail;
25934 }
25935 {
25936 PyThreadState* __tstate = wxPyBeginAllowThreads();
25937 {
25938 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25939 result = (wxDateSpan *) &_result_ref;
25940 }
25941
25942 wxPyEndAllowThreads(__tstate);
25943 if (PyErr_Occurred()) SWIG_fail;
25944 }
25945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25946 return resultobj;
25947 fail:
25948 return NULL;
25949 }
25950
25951
25952 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25953 PyObject *resultobj;
25954 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25955 wxDateSpan *arg2 = 0 ;
25956 wxDateSpan *result;
25957 PyObject * obj0 = 0 ;
25958 PyObject * obj1 = 0 ;
25959 char *kwnames[] = {
25960 (char *) "self",(char *) "other", NULL
25961 };
25962
25963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25968 if (SWIG_arg_fail(2)) SWIG_fail;
25969 if (arg2 == NULL) {
25970 SWIG_null_ref("wxDateSpan");
25971 }
25972 if (SWIG_arg_fail(2)) SWIG_fail;
25973 }
25974 {
25975 PyThreadState* __tstate = wxPyBeginAllowThreads();
25976 {
25977 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25978 result = (wxDateSpan *) &_result_ref;
25979 }
25980
25981 wxPyEndAllowThreads(__tstate);
25982 if (PyErr_Occurred()) SWIG_fail;
25983 }
25984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25985 return resultobj;
25986 fail:
25987 return NULL;
25988 }
25989
25990
25991 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25992 PyObject *resultobj;
25993 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25994 wxDateSpan *result;
25995 PyObject * obj0 = 0 ;
25996 char *kwnames[] = {
25997 (char *) "self", NULL
25998 };
25999
26000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
26001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26002 if (SWIG_arg_fail(1)) SWIG_fail;
26003 {
26004 PyThreadState* __tstate = wxPyBeginAllowThreads();
26005 {
26006 wxDateSpan &_result_ref = (arg1)->Neg();
26007 result = (wxDateSpan *) &_result_ref;
26008 }
26009
26010 wxPyEndAllowThreads(__tstate);
26011 if (PyErr_Occurred()) SWIG_fail;
26012 }
26013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26014 return resultobj;
26015 fail:
26016 return NULL;
26017 }
26018
26019
26020 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
26021 PyObject *resultobj;
26022 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26023 int arg2 ;
26024 wxDateSpan *result;
26025 PyObject * obj0 = 0 ;
26026 PyObject * obj1 = 0 ;
26027 char *kwnames[] = {
26028 (char *) "self",(char *) "factor", NULL
26029 };
26030
26031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
26032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26033 if (SWIG_arg_fail(1)) SWIG_fail;
26034 {
26035 arg2 = (int)(SWIG_As_int(obj1));
26036 if (SWIG_arg_fail(2)) SWIG_fail;
26037 }
26038 {
26039 PyThreadState* __tstate = wxPyBeginAllowThreads();
26040 {
26041 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26042 result = (wxDateSpan *) &_result_ref;
26043 }
26044
26045 wxPyEndAllowThreads(__tstate);
26046 if (PyErr_Occurred()) SWIG_fail;
26047 }
26048 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26049 return resultobj;
26050 fail:
26051 return NULL;
26052 }
26053
26054
26055 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26056 PyObject *resultobj;
26057 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26058 wxDateSpan *arg2 = 0 ;
26059 wxDateSpan *result;
26060 PyObject * obj0 = 0 ;
26061 PyObject * obj1 = 0 ;
26062 char *kwnames[] = {
26063 (char *) "self",(char *) "other", NULL
26064 };
26065
26066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26068 if (SWIG_arg_fail(1)) SWIG_fail;
26069 {
26070 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26071 if (SWIG_arg_fail(2)) SWIG_fail;
26072 if (arg2 == NULL) {
26073 SWIG_null_ref("wxDateSpan");
26074 }
26075 if (SWIG_arg_fail(2)) SWIG_fail;
26076 }
26077 {
26078 PyThreadState* __tstate = wxPyBeginAllowThreads();
26079 {
26080 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26081 result = (wxDateSpan *) &_result_ref;
26082 }
26083
26084 wxPyEndAllowThreads(__tstate);
26085 if (PyErr_Occurred()) SWIG_fail;
26086 }
26087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26088 return resultobj;
26089 fail:
26090 return NULL;
26091 }
26092
26093
26094 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26095 PyObject *resultobj;
26096 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26097 wxDateSpan *arg2 = 0 ;
26098 wxDateSpan *result;
26099 PyObject * obj0 = 0 ;
26100 PyObject * obj1 = 0 ;
26101 char *kwnames[] = {
26102 (char *) "self",(char *) "other", NULL
26103 };
26104
26105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26107 if (SWIG_arg_fail(1)) SWIG_fail;
26108 {
26109 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26110 if (SWIG_arg_fail(2)) SWIG_fail;
26111 if (arg2 == NULL) {
26112 SWIG_null_ref("wxDateSpan");
26113 }
26114 if (SWIG_arg_fail(2)) SWIG_fail;
26115 }
26116 {
26117 PyThreadState* __tstate = wxPyBeginAllowThreads();
26118 {
26119 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26120 result = (wxDateSpan *) &_result_ref;
26121 }
26122
26123 wxPyEndAllowThreads(__tstate);
26124 if (PyErr_Occurred()) SWIG_fail;
26125 }
26126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26127 return resultobj;
26128 fail:
26129 return NULL;
26130 }
26131
26132
26133 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26134 PyObject *resultobj;
26135 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26136 wxDateSpan *result;
26137 PyObject * obj0 = 0 ;
26138 char *kwnames[] = {
26139 (char *) "self", NULL
26140 };
26141
26142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26144 if (SWIG_arg_fail(1)) SWIG_fail;
26145 {
26146 PyThreadState* __tstate = wxPyBeginAllowThreads();
26147 {
26148 wxDateSpan &_result_ref = (arg1)->operator -();
26149 result = (wxDateSpan *) &_result_ref;
26150 }
26151
26152 wxPyEndAllowThreads(__tstate);
26153 if (PyErr_Occurred()) SWIG_fail;
26154 }
26155 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26156 return resultobj;
26157 fail:
26158 return NULL;
26159 }
26160
26161
26162 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26163 PyObject *resultobj;
26164 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26165 int arg2 ;
26166 wxDateSpan *result;
26167 PyObject * obj0 = 0 ;
26168 PyObject * obj1 = 0 ;
26169 char *kwnames[] = {
26170 (char *) "self",(char *) "factor", NULL
26171 };
26172
26173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26175 if (SWIG_arg_fail(1)) SWIG_fail;
26176 {
26177 arg2 = (int)(SWIG_As_int(obj1));
26178 if (SWIG_arg_fail(2)) SWIG_fail;
26179 }
26180 {
26181 PyThreadState* __tstate = wxPyBeginAllowThreads();
26182 {
26183 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26184 result = (wxDateSpan *) &_result_ref;
26185 }
26186
26187 wxPyEndAllowThreads(__tstate);
26188 if (PyErr_Occurred()) SWIG_fail;
26189 }
26190 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26191 return resultobj;
26192 fail:
26193 return NULL;
26194 }
26195
26196
26197 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26198 PyObject *resultobj;
26199 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26200 wxDateSpan *arg2 = 0 ;
26201 wxDateSpan result;
26202 PyObject * obj0 = 0 ;
26203 PyObject * obj1 = 0 ;
26204 char *kwnames[] = {
26205 (char *) "self",(char *) "other", NULL
26206 };
26207
26208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26210 if (SWIG_arg_fail(1)) SWIG_fail;
26211 {
26212 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26213 if (SWIG_arg_fail(2)) SWIG_fail;
26214 if (arg2 == NULL) {
26215 SWIG_null_ref("wxDateSpan");
26216 }
26217 if (SWIG_arg_fail(2)) SWIG_fail;
26218 }
26219 {
26220 PyThreadState* __tstate = wxPyBeginAllowThreads();
26221 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26222
26223 wxPyEndAllowThreads(__tstate);
26224 if (PyErr_Occurred()) SWIG_fail;
26225 }
26226 {
26227 wxDateSpan * resultptr;
26228 resultptr = new wxDateSpan((wxDateSpan &)(result));
26229 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26230 }
26231 return resultobj;
26232 fail:
26233 return NULL;
26234 }
26235
26236
26237 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26238 PyObject *resultobj;
26239 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26240 wxDateSpan *arg2 = 0 ;
26241 wxDateSpan result;
26242 PyObject * obj0 = 0 ;
26243 PyObject * obj1 = 0 ;
26244 char *kwnames[] = {
26245 (char *) "self",(char *) "other", NULL
26246 };
26247
26248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26250 if (SWIG_arg_fail(1)) SWIG_fail;
26251 {
26252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26253 if (SWIG_arg_fail(2)) SWIG_fail;
26254 if (arg2 == NULL) {
26255 SWIG_null_ref("wxDateSpan");
26256 }
26257 if (SWIG_arg_fail(2)) SWIG_fail;
26258 }
26259 {
26260 PyThreadState* __tstate = wxPyBeginAllowThreads();
26261 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26262
26263 wxPyEndAllowThreads(__tstate);
26264 if (PyErr_Occurred()) SWIG_fail;
26265 }
26266 {
26267 wxDateSpan * resultptr;
26268 resultptr = new wxDateSpan((wxDateSpan &)(result));
26269 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26270 }
26271 return resultobj;
26272 fail:
26273 return NULL;
26274 }
26275
26276
26277 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26278 PyObject *resultobj;
26279 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26280 int arg2 ;
26281 wxDateSpan result;
26282 PyObject * obj0 = 0 ;
26283 PyObject * obj1 = 0 ;
26284 char *kwnames[] = {
26285 (char *) "self",(char *) "n", NULL
26286 };
26287
26288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26290 if (SWIG_arg_fail(1)) SWIG_fail;
26291 {
26292 arg2 = (int)(SWIG_As_int(obj1));
26293 if (SWIG_arg_fail(2)) SWIG_fail;
26294 }
26295 {
26296 PyThreadState* __tstate = wxPyBeginAllowThreads();
26297 result = wxDateSpan___mul__(arg1,arg2);
26298
26299 wxPyEndAllowThreads(__tstate);
26300 if (PyErr_Occurred()) SWIG_fail;
26301 }
26302 {
26303 wxDateSpan * resultptr;
26304 resultptr = new wxDateSpan((wxDateSpan &)(result));
26305 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26306 }
26307 return resultobj;
26308 fail:
26309 return NULL;
26310 }
26311
26312
26313 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26314 PyObject *resultobj;
26315 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26316 int arg2 ;
26317 wxDateSpan result;
26318 PyObject * obj0 = 0 ;
26319 PyObject * obj1 = 0 ;
26320 char *kwnames[] = {
26321 (char *) "self",(char *) "n", NULL
26322 };
26323
26324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26326 if (SWIG_arg_fail(1)) SWIG_fail;
26327 {
26328 arg2 = (int)(SWIG_As_int(obj1));
26329 if (SWIG_arg_fail(2)) SWIG_fail;
26330 }
26331 {
26332 PyThreadState* __tstate = wxPyBeginAllowThreads();
26333 result = wxDateSpan___rmul__(arg1,arg2);
26334
26335 wxPyEndAllowThreads(__tstate);
26336 if (PyErr_Occurred()) SWIG_fail;
26337 }
26338 {
26339 wxDateSpan * resultptr;
26340 resultptr = new wxDateSpan((wxDateSpan &)(result));
26341 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26342 }
26343 return resultobj;
26344 fail:
26345 return NULL;
26346 }
26347
26348
26349 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26350 PyObject *resultobj;
26351 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26352 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26353 bool result;
26354 PyObject * obj0 = 0 ;
26355 PyObject * obj1 = 0 ;
26356 char *kwnames[] = {
26357 (char *) "self",(char *) "other", NULL
26358 };
26359
26360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26362 if (SWIG_arg_fail(1)) SWIG_fail;
26363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26364 if (SWIG_arg_fail(2)) SWIG_fail;
26365 {
26366 PyThreadState* __tstate = wxPyBeginAllowThreads();
26367 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26368
26369 wxPyEndAllowThreads(__tstate);
26370 if (PyErr_Occurred()) SWIG_fail;
26371 }
26372 {
26373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26374 }
26375 return resultobj;
26376 fail:
26377 return NULL;
26378 }
26379
26380
26381 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26382 PyObject *resultobj;
26383 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26384 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26385 bool result;
26386 PyObject * obj0 = 0 ;
26387 PyObject * obj1 = 0 ;
26388 char *kwnames[] = {
26389 (char *) "self",(char *) "other", NULL
26390 };
26391
26392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26394 if (SWIG_arg_fail(1)) SWIG_fail;
26395 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26396 if (SWIG_arg_fail(2)) SWIG_fail;
26397 {
26398 PyThreadState* __tstate = wxPyBeginAllowThreads();
26399 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26400
26401 wxPyEndAllowThreads(__tstate);
26402 if (PyErr_Occurred()) SWIG_fail;
26403 }
26404 {
26405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26406 }
26407 return resultobj;
26408 fail:
26409 return NULL;
26410 }
26411
26412
26413 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26414 PyObject *obj;
26415 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26416 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26417 Py_INCREF(obj);
26418 return Py_BuildValue((char *)"");
26419 }
26420 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26421 PyObject *resultobj;
26422 long result;
26423 char *kwnames[] = {
26424 NULL
26425 };
26426
26427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26428 {
26429 PyThreadState* __tstate = wxPyBeginAllowThreads();
26430 result = (long)wxGetLocalTime();
26431
26432 wxPyEndAllowThreads(__tstate);
26433 if (PyErr_Occurred()) SWIG_fail;
26434 }
26435 {
26436 resultobj = SWIG_From_long((long)(result));
26437 }
26438 return resultobj;
26439 fail:
26440 return NULL;
26441 }
26442
26443
26444 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26445 PyObject *resultobj;
26446 long result;
26447 char *kwnames[] = {
26448 NULL
26449 };
26450
26451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26452 {
26453 PyThreadState* __tstate = wxPyBeginAllowThreads();
26454 result = (long)wxGetUTCTime();
26455
26456 wxPyEndAllowThreads(__tstate);
26457 if (PyErr_Occurred()) SWIG_fail;
26458 }
26459 {
26460 resultobj = SWIG_From_long((long)(result));
26461 }
26462 return resultobj;
26463 fail:
26464 return NULL;
26465 }
26466
26467
26468 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26469 PyObject *resultobj;
26470 long result;
26471 char *kwnames[] = {
26472 NULL
26473 };
26474
26475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26476 {
26477 PyThreadState* __tstate = wxPyBeginAllowThreads();
26478 result = (long)wxGetCurrentTime();
26479
26480 wxPyEndAllowThreads(__tstate);
26481 if (PyErr_Occurred()) SWIG_fail;
26482 }
26483 {
26484 resultobj = SWIG_From_long((long)(result));
26485 }
26486 return resultobj;
26487 fail:
26488 return NULL;
26489 }
26490
26491
26492 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26493 PyObject *resultobj;
26494 wxLongLong result;
26495 char *kwnames[] = {
26496 NULL
26497 };
26498
26499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26500 {
26501 PyThreadState* __tstate = wxPyBeginAllowThreads();
26502 result = wxGetLocalTimeMillis();
26503
26504 wxPyEndAllowThreads(__tstate);
26505 if (PyErr_Occurred()) SWIG_fail;
26506 }
26507 {
26508 PyObject *hi, *lo, *shifter, *shifted;
26509 hi = PyLong_FromLong( (&result)->GetHi() );
26510 lo = PyLong_FromLong( (&result)->GetLo() );
26511 shifter = PyLong_FromLong(32);
26512 shifted = PyNumber_Lshift(hi, shifter);
26513 resultobj = PyNumber_Or(shifted, lo);
26514 Py_DECREF(hi);
26515 Py_DECREF(lo);
26516 Py_DECREF(shifter);
26517 Py_DECREF(shifted);
26518 }
26519 return resultobj;
26520 fail:
26521 return NULL;
26522 }
26523
26524
26525 static int _wrap_DefaultDateTime_set(PyObject *) {
26526 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26527 return 1;
26528 }
26529
26530
26531 static PyObject *_wrap_DefaultDateTime_get(void) {
26532 PyObject *pyobj;
26533
26534 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26535 return pyobj;
26536 }
26537
26538
26539 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26540 PyObject *resultobj;
26541 wxDataFormatId arg1 ;
26542 wxDataFormat *result;
26543 PyObject * obj0 = 0 ;
26544 char *kwnames[] = {
26545 (char *) "type", NULL
26546 };
26547
26548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26549 {
26550 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26551 if (SWIG_arg_fail(1)) SWIG_fail;
26552 }
26553 {
26554 PyThreadState* __tstate = wxPyBeginAllowThreads();
26555 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26556
26557 wxPyEndAllowThreads(__tstate);
26558 if (PyErr_Occurred()) SWIG_fail;
26559 }
26560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26561 return resultobj;
26562 fail:
26563 return NULL;
26564 }
26565
26566
26567 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26568 PyObject *resultobj;
26569 wxString *arg1 = 0 ;
26570 wxDataFormat *result;
26571 bool temp1 = false ;
26572 PyObject * obj0 = 0 ;
26573 char *kwnames[] = {
26574 (char *) "format", NULL
26575 };
26576
26577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26578 {
26579 arg1 = wxString_in_helper(obj0);
26580 if (arg1 == NULL) SWIG_fail;
26581 temp1 = true;
26582 }
26583 {
26584 PyThreadState* __tstate = wxPyBeginAllowThreads();
26585 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26586
26587 wxPyEndAllowThreads(__tstate);
26588 if (PyErr_Occurred()) SWIG_fail;
26589 }
26590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26591 {
26592 if (temp1)
26593 delete arg1;
26594 }
26595 return resultobj;
26596 fail:
26597 {
26598 if (temp1)
26599 delete arg1;
26600 }
26601 return NULL;
26602 }
26603
26604
26605 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26606 PyObject *resultobj;
26607 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26608 PyObject * obj0 = 0 ;
26609 char *kwnames[] = {
26610 (char *) "self", NULL
26611 };
26612
26613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26615 if (SWIG_arg_fail(1)) SWIG_fail;
26616 {
26617 PyThreadState* __tstate = wxPyBeginAllowThreads();
26618 delete arg1;
26619
26620 wxPyEndAllowThreads(__tstate);
26621 if (PyErr_Occurred()) SWIG_fail;
26622 }
26623 Py_INCREF(Py_None); resultobj = Py_None;
26624 return resultobj;
26625 fail:
26626 return NULL;
26627 }
26628
26629
26630 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26631 PyObject *resultobj;
26632 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26633 wxDataFormatId arg2 ;
26634 bool result;
26635 PyObject * obj0 = 0 ;
26636 PyObject * obj1 = 0 ;
26637
26638 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26640 if (SWIG_arg_fail(1)) SWIG_fail;
26641 {
26642 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26643 if (SWIG_arg_fail(2)) SWIG_fail;
26644 }
26645 {
26646 PyThreadState* __tstate = wxPyBeginAllowThreads();
26647 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26648
26649 wxPyEndAllowThreads(__tstate);
26650 if (PyErr_Occurred()) SWIG_fail;
26651 }
26652 {
26653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26654 }
26655 return resultobj;
26656 fail:
26657 return NULL;
26658 }
26659
26660
26661 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26662 PyObject *resultobj;
26663 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26664 wxDataFormatId arg2 ;
26665 bool result;
26666 PyObject * obj0 = 0 ;
26667 PyObject * obj1 = 0 ;
26668
26669 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26671 if (SWIG_arg_fail(1)) SWIG_fail;
26672 {
26673 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26674 if (SWIG_arg_fail(2)) SWIG_fail;
26675 }
26676 {
26677 PyThreadState* __tstate = wxPyBeginAllowThreads();
26678 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26679
26680 wxPyEndAllowThreads(__tstate);
26681 if (PyErr_Occurred()) SWIG_fail;
26682 }
26683 {
26684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26685 }
26686 return resultobj;
26687 fail:
26688 return NULL;
26689 }
26690
26691
26692 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26693 PyObject *resultobj;
26694 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26695 wxDataFormat *arg2 = 0 ;
26696 bool result;
26697 PyObject * obj0 = 0 ;
26698 PyObject * obj1 = 0 ;
26699
26700 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26702 if (SWIG_arg_fail(1)) SWIG_fail;
26703 {
26704 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26705 if (SWIG_arg_fail(2)) SWIG_fail;
26706 if (arg2 == NULL) {
26707 SWIG_null_ref("wxDataFormat");
26708 }
26709 if (SWIG_arg_fail(2)) SWIG_fail;
26710 }
26711 {
26712 PyThreadState* __tstate = wxPyBeginAllowThreads();
26713 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26714
26715 wxPyEndAllowThreads(__tstate);
26716 if (PyErr_Occurred()) SWIG_fail;
26717 }
26718 {
26719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26720 }
26721 return resultobj;
26722 fail:
26723 return NULL;
26724 }
26725
26726
26727 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26728 int argc;
26729 PyObject *argv[3];
26730 int ii;
26731
26732 argc = PyObject_Length(args);
26733 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26734 argv[ii] = PyTuple_GetItem(args,ii);
26735 }
26736 if (argc == 2) {
26737 int _v;
26738 {
26739 void *ptr;
26740 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26741 _v = 0;
26742 PyErr_Clear();
26743 } else {
26744 _v = 1;
26745 }
26746 }
26747 if (_v) {
26748 {
26749 void *ptr = 0;
26750 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26751 _v = 0;
26752 PyErr_Clear();
26753 } else {
26754 _v = (ptr != 0);
26755 }
26756 }
26757 if (_v) {
26758 return _wrap_DataFormat___eq____SWIG_1(self,args);
26759 }
26760 }
26761 }
26762 if (argc == 2) {
26763 int _v;
26764 {
26765 void *ptr;
26766 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26767 _v = 0;
26768 PyErr_Clear();
26769 } else {
26770 _v = 1;
26771 }
26772 }
26773 if (_v) {
26774 _v = SWIG_Check_int(argv[1]);
26775 if (_v) {
26776 return _wrap_DataFormat___eq____SWIG_0(self,args);
26777 }
26778 }
26779 }
26780
26781 Py_INCREF(Py_NotImplemented);
26782 return Py_NotImplemented;
26783 }
26784
26785
26786 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26787 PyObject *resultobj;
26788 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26789 wxDataFormat *arg2 = 0 ;
26790 bool result;
26791 PyObject * obj0 = 0 ;
26792 PyObject * obj1 = 0 ;
26793
26794 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26796 if (SWIG_arg_fail(1)) SWIG_fail;
26797 {
26798 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26799 if (SWIG_arg_fail(2)) SWIG_fail;
26800 if (arg2 == NULL) {
26801 SWIG_null_ref("wxDataFormat");
26802 }
26803 if (SWIG_arg_fail(2)) SWIG_fail;
26804 }
26805 {
26806 PyThreadState* __tstate = wxPyBeginAllowThreads();
26807 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26808
26809 wxPyEndAllowThreads(__tstate);
26810 if (PyErr_Occurred()) SWIG_fail;
26811 }
26812 {
26813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26814 }
26815 return resultobj;
26816 fail:
26817 return NULL;
26818 }
26819
26820
26821 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26822 int argc;
26823 PyObject *argv[3];
26824 int ii;
26825
26826 argc = PyObject_Length(args);
26827 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26828 argv[ii] = PyTuple_GetItem(args,ii);
26829 }
26830 if (argc == 2) {
26831 int _v;
26832 {
26833 void *ptr;
26834 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26835 _v = 0;
26836 PyErr_Clear();
26837 } else {
26838 _v = 1;
26839 }
26840 }
26841 if (_v) {
26842 {
26843 void *ptr = 0;
26844 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26845 _v = 0;
26846 PyErr_Clear();
26847 } else {
26848 _v = (ptr != 0);
26849 }
26850 }
26851 if (_v) {
26852 return _wrap_DataFormat___ne____SWIG_1(self,args);
26853 }
26854 }
26855 }
26856 if (argc == 2) {
26857 int _v;
26858 {
26859 void *ptr;
26860 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26861 _v = 0;
26862 PyErr_Clear();
26863 } else {
26864 _v = 1;
26865 }
26866 }
26867 if (_v) {
26868 _v = SWIG_Check_int(argv[1]);
26869 if (_v) {
26870 return _wrap_DataFormat___ne____SWIG_0(self,args);
26871 }
26872 }
26873 }
26874
26875 Py_INCREF(Py_NotImplemented);
26876 return Py_NotImplemented;
26877 }
26878
26879
26880 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26881 PyObject *resultobj;
26882 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26883 wxDataFormatId arg2 ;
26884 PyObject * obj0 = 0 ;
26885 PyObject * obj1 = 0 ;
26886 char *kwnames[] = {
26887 (char *) "self",(char *) "format", NULL
26888 };
26889
26890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26892 if (SWIG_arg_fail(1)) SWIG_fail;
26893 {
26894 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26895 if (SWIG_arg_fail(2)) SWIG_fail;
26896 }
26897 {
26898 PyThreadState* __tstate = wxPyBeginAllowThreads();
26899 (arg1)->SetType((wxDataFormatId )arg2);
26900
26901 wxPyEndAllowThreads(__tstate);
26902 if (PyErr_Occurred()) SWIG_fail;
26903 }
26904 Py_INCREF(Py_None); resultobj = Py_None;
26905 return resultobj;
26906 fail:
26907 return NULL;
26908 }
26909
26910
26911 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26912 PyObject *resultobj;
26913 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26914 wxDataFormatId result;
26915 PyObject * obj0 = 0 ;
26916 char *kwnames[] = {
26917 (char *) "self", NULL
26918 };
26919
26920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26922 if (SWIG_arg_fail(1)) SWIG_fail;
26923 {
26924 PyThreadState* __tstate = wxPyBeginAllowThreads();
26925 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26926
26927 wxPyEndAllowThreads(__tstate);
26928 if (PyErr_Occurred()) SWIG_fail;
26929 }
26930 resultobj = SWIG_From_int((result));
26931 return resultobj;
26932 fail:
26933 return NULL;
26934 }
26935
26936
26937 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26938 PyObject *resultobj;
26939 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26940 wxString result;
26941 PyObject * obj0 = 0 ;
26942 char *kwnames[] = {
26943 (char *) "self", NULL
26944 };
26945
26946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26948 if (SWIG_arg_fail(1)) SWIG_fail;
26949 {
26950 PyThreadState* __tstate = wxPyBeginAllowThreads();
26951 result = ((wxDataFormat const *)arg1)->GetId();
26952
26953 wxPyEndAllowThreads(__tstate);
26954 if (PyErr_Occurred()) SWIG_fail;
26955 }
26956 {
26957 #if wxUSE_UNICODE
26958 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26959 #else
26960 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26961 #endif
26962 }
26963 return resultobj;
26964 fail:
26965 return NULL;
26966 }
26967
26968
26969 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26970 PyObject *resultobj;
26971 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26972 wxString *arg2 = 0 ;
26973 bool temp2 = false ;
26974 PyObject * obj0 = 0 ;
26975 PyObject * obj1 = 0 ;
26976 char *kwnames[] = {
26977 (char *) "self",(char *) "format", NULL
26978 };
26979
26980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26982 if (SWIG_arg_fail(1)) SWIG_fail;
26983 {
26984 arg2 = wxString_in_helper(obj1);
26985 if (arg2 == NULL) SWIG_fail;
26986 temp2 = true;
26987 }
26988 {
26989 PyThreadState* __tstate = wxPyBeginAllowThreads();
26990 (arg1)->SetId((wxString const &)*arg2);
26991
26992 wxPyEndAllowThreads(__tstate);
26993 if (PyErr_Occurred()) SWIG_fail;
26994 }
26995 Py_INCREF(Py_None); resultobj = Py_None;
26996 {
26997 if (temp2)
26998 delete arg2;
26999 }
27000 return resultobj;
27001 fail:
27002 {
27003 if (temp2)
27004 delete arg2;
27005 }
27006 return NULL;
27007 }
27008
27009
27010 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
27011 PyObject *obj;
27012 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27013 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
27014 Py_INCREF(obj);
27015 return Py_BuildValue((char *)"");
27016 }
27017 static int _wrap_FormatInvalid_set(PyObject *) {
27018 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
27019 return 1;
27020 }
27021
27022
27023 static PyObject *_wrap_FormatInvalid_get(void) {
27024 PyObject *pyobj;
27025
27026 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
27027 return pyobj;
27028 }
27029
27030
27031 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27032 PyObject *resultobj;
27033 wxDataObject *arg1 = (wxDataObject *) 0 ;
27034 PyObject * obj0 = 0 ;
27035 char *kwnames[] = {
27036 (char *) "self", NULL
27037 };
27038
27039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27041 if (SWIG_arg_fail(1)) SWIG_fail;
27042 {
27043 PyThreadState* __tstate = wxPyBeginAllowThreads();
27044 delete arg1;
27045
27046 wxPyEndAllowThreads(__tstate);
27047 if (PyErr_Occurred()) SWIG_fail;
27048 }
27049 Py_INCREF(Py_None); resultobj = Py_None;
27050 return resultobj;
27051 fail:
27052 return NULL;
27053 }
27054
27055
27056 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27057 PyObject *resultobj;
27058 wxDataObject *arg1 = (wxDataObject *) 0 ;
27059 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27060 SwigValueWrapper<wxDataFormat > result;
27061 PyObject * obj0 = 0 ;
27062 PyObject * obj1 = 0 ;
27063 char *kwnames[] = {
27064 (char *) "self",(char *) "dir", NULL
27065 };
27066
27067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27069 if (SWIG_arg_fail(1)) SWIG_fail;
27070 if (obj1) {
27071 {
27072 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27073 if (SWIG_arg_fail(2)) SWIG_fail;
27074 }
27075 }
27076 {
27077 PyThreadState* __tstate = wxPyBeginAllowThreads();
27078 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27079
27080 wxPyEndAllowThreads(__tstate);
27081 if (PyErr_Occurred()) SWIG_fail;
27082 }
27083 {
27084 wxDataFormat * resultptr;
27085 resultptr = new wxDataFormat((wxDataFormat &)(result));
27086 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27087 }
27088 return resultobj;
27089 fail:
27090 return NULL;
27091 }
27092
27093
27094 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27095 PyObject *resultobj;
27096 wxDataObject *arg1 = (wxDataObject *) 0 ;
27097 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27098 size_t result;
27099 PyObject * obj0 = 0 ;
27100 PyObject * obj1 = 0 ;
27101 char *kwnames[] = {
27102 (char *) "self",(char *) "dir", NULL
27103 };
27104
27105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27107 if (SWIG_arg_fail(1)) SWIG_fail;
27108 if (obj1) {
27109 {
27110 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27111 if (SWIG_arg_fail(2)) SWIG_fail;
27112 }
27113 }
27114 {
27115 PyThreadState* __tstate = wxPyBeginAllowThreads();
27116 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27117
27118 wxPyEndAllowThreads(__tstate);
27119 if (PyErr_Occurred()) SWIG_fail;
27120 }
27121 {
27122 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27123 }
27124 return resultobj;
27125 fail:
27126 return NULL;
27127 }
27128
27129
27130 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27131 PyObject *resultobj;
27132 wxDataObject *arg1 = (wxDataObject *) 0 ;
27133 wxDataFormat *arg2 = 0 ;
27134 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27135 bool result;
27136 PyObject * obj0 = 0 ;
27137 PyObject * obj1 = 0 ;
27138 PyObject * obj2 = 0 ;
27139 char *kwnames[] = {
27140 (char *) "self",(char *) "format",(char *) "dir", NULL
27141 };
27142
27143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27145 if (SWIG_arg_fail(1)) SWIG_fail;
27146 {
27147 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27148 if (SWIG_arg_fail(2)) SWIG_fail;
27149 if (arg2 == NULL) {
27150 SWIG_null_ref("wxDataFormat");
27151 }
27152 if (SWIG_arg_fail(2)) SWIG_fail;
27153 }
27154 if (obj2) {
27155 {
27156 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27157 if (SWIG_arg_fail(3)) SWIG_fail;
27158 }
27159 }
27160 {
27161 PyThreadState* __tstate = wxPyBeginAllowThreads();
27162 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27163
27164 wxPyEndAllowThreads(__tstate);
27165 if (PyErr_Occurred()) SWIG_fail;
27166 }
27167 {
27168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27169 }
27170 return resultobj;
27171 fail:
27172 return NULL;
27173 }
27174
27175
27176 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27177 PyObject *resultobj;
27178 wxDataObject *arg1 = (wxDataObject *) 0 ;
27179 wxDataFormat *arg2 = 0 ;
27180 size_t result;
27181 PyObject * obj0 = 0 ;
27182 PyObject * obj1 = 0 ;
27183 char *kwnames[] = {
27184 (char *) "self",(char *) "format", NULL
27185 };
27186
27187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27189 if (SWIG_arg_fail(1)) SWIG_fail;
27190 {
27191 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27192 if (SWIG_arg_fail(2)) SWIG_fail;
27193 if (arg2 == NULL) {
27194 SWIG_null_ref("wxDataFormat");
27195 }
27196 if (SWIG_arg_fail(2)) SWIG_fail;
27197 }
27198 {
27199 PyThreadState* __tstate = wxPyBeginAllowThreads();
27200 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27201
27202 wxPyEndAllowThreads(__tstate);
27203 if (PyErr_Occurred()) SWIG_fail;
27204 }
27205 {
27206 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27207 }
27208 return resultobj;
27209 fail:
27210 return NULL;
27211 }
27212
27213
27214 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27215 PyObject *resultobj;
27216 wxDataObject *arg1 = (wxDataObject *) 0 ;
27217 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27218 PyObject *result;
27219 PyObject * obj0 = 0 ;
27220 PyObject * obj1 = 0 ;
27221 char *kwnames[] = {
27222 (char *) "self",(char *) "dir", NULL
27223 };
27224
27225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27227 if (SWIG_arg_fail(1)) SWIG_fail;
27228 if (obj1) {
27229 {
27230 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27231 if (SWIG_arg_fail(2)) SWIG_fail;
27232 }
27233 }
27234 {
27235 PyThreadState* __tstate = wxPyBeginAllowThreads();
27236 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27237
27238 wxPyEndAllowThreads(__tstate);
27239 if (PyErr_Occurred()) SWIG_fail;
27240 }
27241 resultobj = result;
27242 return resultobj;
27243 fail:
27244 return NULL;
27245 }
27246
27247
27248 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27249 PyObject *resultobj;
27250 wxDataObject *arg1 = (wxDataObject *) 0 ;
27251 wxDataFormat *arg2 = 0 ;
27252 PyObject *result;
27253 PyObject * obj0 = 0 ;
27254 PyObject * obj1 = 0 ;
27255 char *kwnames[] = {
27256 (char *) "self",(char *) "format", NULL
27257 };
27258
27259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27261 if (SWIG_arg_fail(1)) SWIG_fail;
27262 {
27263 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27264 if (SWIG_arg_fail(2)) SWIG_fail;
27265 if (arg2 == NULL) {
27266 SWIG_null_ref("wxDataFormat");
27267 }
27268 if (SWIG_arg_fail(2)) SWIG_fail;
27269 }
27270 {
27271 PyThreadState* __tstate = wxPyBeginAllowThreads();
27272 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27273
27274 wxPyEndAllowThreads(__tstate);
27275 if (PyErr_Occurred()) SWIG_fail;
27276 }
27277 resultobj = result;
27278 return resultobj;
27279 fail:
27280 return NULL;
27281 }
27282
27283
27284 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27285 PyObject *resultobj;
27286 wxDataObject *arg1 = (wxDataObject *) 0 ;
27287 wxDataFormat *arg2 = 0 ;
27288 PyObject *arg3 = (PyObject *) 0 ;
27289 bool result;
27290 PyObject * obj0 = 0 ;
27291 PyObject * obj1 = 0 ;
27292 PyObject * obj2 = 0 ;
27293 char *kwnames[] = {
27294 (char *) "self",(char *) "format",(char *) "data", NULL
27295 };
27296
27297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27299 if (SWIG_arg_fail(1)) SWIG_fail;
27300 {
27301 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27302 if (SWIG_arg_fail(2)) SWIG_fail;
27303 if (arg2 == NULL) {
27304 SWIG_null_ref("wxDataFormat");
27305 }
27306 if (SWIG_arg_fail(2)) SWIG_fail;
27307 }
27308 arg3 = obj2;
27309 {
27310 PyThreadState* __tstate = wxPyBeginAllowThreads();
27311 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27312
27313 wxPyEndAllowThreads(__tstate);
27314 if (PyErr_Occurred()) SWIG_fail;
27315 }
27316 {
27317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27318 }
27319 return resultobj;
27320 fail:
27321 return NULL;
27322 }
27323
27324
27325 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27326 PyObject *obj;
27327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27328 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27329 Py_INCREF(obj);
27330 return Py_BuildValue((char *)"");
27331 }
27332 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27333 PyObject *resultobj;
27334 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27335 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27336 wxDataObjectSimple *result;
27337 PyObject * obj0 = 0 ;
27338 char *kwnames[] = {
27339 (char *) "format", NULL
27340 };
27341
27342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27343 if (obj0) {
27344 {
27345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27346 if (SWIG_arg_fail(1)) SWIG_fail;
27347 if (arg1 == NULL) {
27348 SWIG_null_ref("wxDataFormat");
27349 }
27350 if (SWIG_arg_fail(1)) SWIG_fail;
27351 }
27352 }
27353 {
27354 PyThreadState* __tstate = wxPyBeginAllowThreads();
27355 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27356
27357 wxPyEndAllowThreads(__tstate);
27358 if (PyErr_Occurred()) SWIG_fail;
27359 }
27360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27361 return resultobj;
27362 fail:
27363 return NULL;
27364 }
27365
27366
27367 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27368 PyObject *resultobj;
27369 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27370 wxDataFormat *result;
27371 PyObject * obj0 = 0 ;
27372 char *kwnames[] = {
27373 (char *) "self", NULL
27374 };
27375
27376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27378 if (SWIG_arg_fail(1)) SWIG_fail;
27379 {
27380 PyThreadState* __tstate = wxPyBeginAllowThreads();
27381 {
27382 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27383 result = (wxDataFormat *) &_result_ref;
27384 }
27385
27386 wxPyEndAllowThreads(__tstate);
27387 if (PyErr_Occurred()) SWIG_fail;
27388 }
27389 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27390 return resultobj;
27391 fail:
27392 return NULL;
27393 }
27394
27395
27396 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27397 PyObject *resultobj;
27398 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27399 wxDataFormat *arg2 = 0 ;
27400 PyObject * obj0 = 0 ;
27401 PyObject * obj1 = 0 ;
27402 char *kwnames[] = {
27403 (char *) "self",(char *) "format", NULL
27404 };
27405
27406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27408 if (SWIG_arg_fail(1)) SWIG_fail;
27409 {
27410 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27411 if (SWIG_arg_fail(2)) SWIG_fail;
27412 if (arg2 == NULL) {
27413 SWIG_null_ref("wxDataFormat");
27414 }
27415 if (SWIG_arg_fail(2)) SWIG_fail;
27416 }
27417 {
27418 PyThreadState* __tstate = wxPyBeginAllowThreads();
27419 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27420
27421 wxPyEndAllowThreads(__tstate);
27422 if (PyErr_Occurred()) SWIG_fail;
27423 }
27424 Py_INCREF(Py_None); resultobj = Py_None;
27425 return resultobj;
27426 fail:
27427 return NULL;
27428 }
27429
27430
27431 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27432 PyObject *resultobj;
27433 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27434 size_t result;
27435 PyObject * obj0 = 0 ;
27436 char *kwnames[] = {
27437 (char *) "self", NULL
27438 };
27439
27440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27442 if (SWIG_arg_fail(1)) SWIG_fail;
27443 {
27444 PyThreadState* __tstate = wxPyBeginAllowThreads();
27445 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27446
27447 wxPyEndAllowThreads(__tstate);
27448 if (PyErr_Occurred()) SWIG_fail;
27449 }
27450 {
27451 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27452 }
27453 return resultobj;
27454 fail:
27455 return NULL;
27456 }
27457
27458
27459 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27460 PyObject *resultobj;
27461 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27462 PyObject *result;
27463 PyObject * obj0 = 0 ;
27464 char *kwnames[] = {
27465 (char *) "self", NULL
27466 };
27467
27468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27470 if (SWIG_arg_fail(1)) SWIG_fail;
27471 {
27472 PyThreadState* __tstate = wxPyBeginAllowThreads();
27473 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27474
27475 wxPyEndAllowThreads(__tstate);
27476 if (PyErr_Occurred()) SWIG_fail;
27477 }
27478 resultobj = result;
27479 return resultobj;
27480 fail:
27481 return NULL;
27482 }
27483
27484
27485 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27486 PyObject *resultobj;
27487 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27488 PyObject *arg2 = (PyObject *) 0 ;
27489 bool result;
27490 PyObject * obj0 = 0 ;
27491 PyObject * obj1 = 0 ;
27492 char *kwnames[] = {
27493 (char *) "self",(char *) "data", NULL
27494 };
27495
27496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27498 if (SWIG_arg_fail(1)) SWIG_fail;
27499 arg2 = obj1;
27500 {
27501 PyThreadState* __tstate = wxPyBeginAllowThreads();
27502 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27503
27504 wxPyEndAllowThreads(__tstate);
27505 if (PyErr_Occurred()) SWIG_fail;
27506 }
27507 {
27508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27509 }
27510 return resultobj;
27511 fail:
27512 return NULL;
27513 }
27514
27515
27516 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27517 PyObject *obj;
27518 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27519 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27520 Py_INCREF(obj);
27521 return Py_BuildValue((char *)"");
27522 }
27523 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27524 PyObject *resultobj;
27525 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27526 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27527 wxPyDataObjectSimple *result;
27528 PyObject * obj0 = 0 ;
27529 char *kwnames[] = {
27530 (char *) "format", NULL
27531 };
27532
27533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27534 if (obj0) {
27535 {
27536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27537 if (SWIG_arg_fail(1)) SWIG_fail;
27538 if (arg1 == NULL) {
27539 SWIG_null_ref("wxDataFormat");
27540 }
27541 if (SWIG_arg_fail(1)) SWIG_fail;
27542 }
27543 }
27544 {
27545 PyThreadState* __tstate = wxPyBeginAllowThreads();
27546 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27547
27548 wxPyEndAllowThreads(__tstate);
27549 if (PyErr_Occurred()) SWIG_fail;
27550 }
27551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27552 return resultobj;
27553 fail:
27554 return NULL;
27555 }
27556
27557
27558 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27559 PyObject *resultobj;
27560 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27561 PyObject *arg2 = (PyObject *) 0 ;
27562 PyObject *arg3 = (PyObject *) 0 ;
27563 PyObject * obj0 = 0 ;
27564 PyObject * obj1 = 0 ;
27565 PyObject * obj2 = 0 ;
27566 char *kwnames[] = {
27567 (char *) "self",(char *) "self",(char *) "_class", NULL
27568 };
27569
27570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27572 if (SWIG_arg_fail(1)) SWIG_fail;
27573 arg2 = obj1;
27574 arg3 = obj2;
27575 {
27576 PyThreadState* __tstate = wxPyBeginAllowThreads();
27577 (arg1)->_setCallbackInfo(arg2,arg3);
27578
27579 wxPyEndAllowThreads(__tstate);
27580 if (PyErr_Occurred()) SWIG_fail;
27581 }
27582 Py_INCREF(Py_None); resultobj = Py_None;
27583 return resultobj;
27584 fail:
27585 return NULL;
27586 }
27587
27588
27589 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27590 PyObject *obj;
27591 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27592 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27593 Py_INCREF(obj);
27594 return Py_BuildValue((char *)"");
27595 }
27596 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27597 PyObject *resultobj;
27598 wxDataObjectComposite *result;
27599 char *kwnames[] = {
27600 NULL
27601 };
27602
27603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27604 {
27605 PyThreadState* __tstate = wxPyBeginAllowThreads();
27606 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27607
27608 wxPyEndAllowThreads(__tstate);
27609 if (PyErr_Occurred()) SWIG_fail;
27610 }
27611 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27612 return resultobj;
27613 fail:
27614 return NULL;
27615 }
27616
27617
27618 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27619 PyObject *resultobj;
27620 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27621 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27622 bool arg3 = (bool) false ;
27623 PyObject * obj0 = 0 ;
27624 PyObject * obj1 = 0 ;
27625 PyObject * obj2 = 0 ;
27626 char *kwnames[] = {
27627 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27628 };
27629
27630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27632 if (SWIG_arg_fail(1)) SWIG_fail;
27633 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27634 if (SWIG_arg_fail(2)) SWIG_fail;
27635 if (obj2) {
27636 {
27637 arg3 = (bool)(SWIG_As_bool(obj2));
27638 if (SWIG_arg_fail(3)) SWIG_fail;
27639 }
27640 }
27641 {
27642 PyThreadState* __tstate = wxPyBeginAllowThreads();
27643 (arg1)->Add(arg2,arg3);
27644
27645 wxPyEndAllowThreads(__tstate);
27646 if (PyErr_Occurred()) SWIG_fail;
27647 }
27648 Py_INCREF(Py_None); resultobj = Py_None;
27649 return resultobj;
27650 fail:
27651 return NULL;
27652 }
27653
27654
27655 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27656 PyObject *obj;
27657 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27658 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27659 Py_INCREF(obj);
27660 return Py_BuildValue((char *)"");
27661 }
27662 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27663 PyObject *resultobj;
27664 wxString const &arg1_defvalue = wxPyEmptyString ;
27665 wxString *arg1 = (wxString *) &arg1_defvalue ;
27666 wxTextDataObject *result;
27667 bool temp1 = false ;
27668 PyObject * obj0 = 0 ;
27669 char *kwnames[] = {
27670 (char *) "text", NULL
27671 };
27672
27673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27674 if (obj0) {
27675 {
27676 arg1 = wxString_in_helper(obj0);
27677 if (arg1 == NULL) SWIG_fail;
27678 temp1 = true;
27679 }
27680 }
27681 {
27682 PyThreadState* __tstate = wxPyBeginAllowThreads();
27683 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27684
27685 wxPyEndAllowThreads(__tstate);
27686 if (PyErr_Occurred()) SWIG_fail;
27687 }
27688 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27689 {
27690 if (temp1)
27691 delete arg1;
27692 }
27693 return resultobj;
27694 fail:
27695 {
27696 if (temp1)
27697 delete arg1;
27698 }
27699 return NULL;
27700 }
27701
27702
27703 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27704 PyObject *resultobj;
27705 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27706 size_t result;
27707 PyObject * obj0 = 0 ;
27708 char *kwnames[] = {
27709 (char *) "self", NULL
27710 };
27711
27712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27714 if (SWIG_arg_fail(1)) SWIG_fail;
27715 {
27716 PyThreadState* __tstate = wxPyBeginAllowThreads();
27717 result = (size_t)(arg1)->GetTextLength();
27718
27719 wxPyEndAllowThreads(__tstate);
27720 if (PyErr_Occurred()) SWIG_fail;
27721 }
27722 {
27723 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27724 }
27725 return resultobj;
27726 fail:
27727 return NULL;
27728 }
27729
27730
27731 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27732 PyObject *resultobj;
27733 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27734 wxString result;
27735 PyObject * obj0 = 0 ;
27736 char *kwnames[] = {
27737 (char *) "self", NULL
27738 };
27739
27740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27742 if (SWIG_arg_fail(1)) SWIG_fail;
27743 {
27744 PyThreadState* __tstate = wxPyBeginAllowThreads();
27745 result = (arg1)->GetText();
27746
27747 wxPyEndAllowThreads(__tstate);
27748 if (PyErr_Occurred()) SWIG_fail;
27749 }
27750 {
27751 #if wxUSE_UNICODE
27752 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27753 #else
27754 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27755 #endif
27756 }
27757 return resultobj;
27758 fail:
27759 return NULL;
27760 }
27761
27762
27763 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27764 PyObject *resultobj;
27765 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27766 wxString *arg2 = 0 ;
27767 bool temp2 = false ;
27768 PyObject * obj0 = 0 ;
27769 PyObject * obj1 = 0 ;
27770 char *kwnames[] = {
27771 (char *) "self",(char *) "text", NULL
27772 };
27773
27774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27776 if (SWIG_arg_fail(1)) SWIG_fail;
27777 {
27778 arg2 = wxString_in_helper(obj1);
27779 if (arg2 == NULL) SWIG_fail;
27780 temp2 = true;
27781 }
27782 {
27783 PyThreadState* __tstate = wxPyBeginAllowThreads();
27784 (arg1)->SetText((wxString const &)*arg2);
27785
27786 wxPyEndAllowThreads(__tstate);
27787 if (PyErr_Occurred()) SWIG_fail;
27788 }
27789 Py_INCREF(Py_None); resultobj = Py_None;
27790 {
27791 if (temp2)
27792 delete arg2;
27793 }
27794 return resultobj;
27795 fail:
27796 {
27797 if (temp2)
27798 delete arg2;
27799 }
27800 return NULL;
27801 }
27802
27803
27804 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27805 PyObject *obj;
27806 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27807 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27808 Py_INCREF(obj);
27809 return Py_BuildValue((char *)"");
27810 }
27811 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27812 PyObject *resultobj;
27813 wxString const &arg1_defvalue = wxPyEmptyString ;
27814 wxString *arg1 = (wxString *) &arg1_defvalue ;
27815 wxPyTextDataObject *result;
27816 bool temp1 = false ;
27817 PyObject * obj0 = 0 ;
27818 char *kwnames[] = {
27819 (char *) "text", NULL
27820 };
27821
27822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27823 if (obj0) {
27824 {
27825 arg1 = wxString_in_helper(obj0);
27826 if (arg1 == NULL) SWIG_fail;
27827 temp1 = true;
27828 }
27829 }
27830 {
27831 PyThreadState* __tstate = wxPyBeginAllowThreads();
27832 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27833
27834 wxPyEndAllowThreads(__tstate);
27835 if (PyErr_Occurred()) SWIG_fail;
27836 }
27837 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27838 {
27839 if (temp1)
27840 delete arg1;
27841 }
27842 return resultobj;
27843 fail:
27844 {
27845 if (temp1)
27846 delete arg1;
27847 }
27848 return NULL;
27849 }
27850
27851
27852 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27853 PyObject *resultobj;
27854 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27855 PyObject *arg2 = (PyObject *) 0 ;
27856 PyObject *arg3 = (PyObject *) 0 ;
27857 PyObject * obj0 = 0 ;
27858 PyObject * obj1 = 0 ;
27859 PyObject * obj2 = 0 ;
27860 char *kwnames[] = {
27861 (char *) "self",(char *) "self",(char *) "_class", NULL
27862 };
27863
27864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27866 if (SWIG_arg_fail(1)) SWIG_fail;
27867 arg2 = obj1;
27868 arg3 = obj2;
27869 {
27870 PyThreadState* __tstate = wxPyBeginAllowThreads();
27871 (arg1)->_setCallbackInfo(arg2,arg3);
27872
27873 wxPyEndAllowThreads(__tstate);
27874 if (PyErr_Occurred()) SWIG_fail;
27875 }
27876 Py_INCREF(Py_None); resultobj = Py_None;
27877 return resultobj;
27878 fail:
27879 return NULL;
27880 }
27881
27882
27883 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27884 PyObject *obj;
27885 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27886 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27887 Py_INCREF(obj);
27888 return Py_BuildValue((char *)"");
27889 }
27890 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27891 PyObject *resultobj;
27892 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27893 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27894 wxBitmapDataObject *result;
27895 PyObject * obj0 = 0 ;
27896 char *kwnames[] = {
27897 (char *) "bitmap", NULL
27898 };
27899
27900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27901 if (obj0) {
27902 {
27903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27904 if (SWIG_arg_fail(1)) SWIG_fail;
27905 if (arg1 == NULL) {
27906 SWIG_null_ref("wxBitmap");
27907 }
27908 if (SWIG_arg_fail(1)) SWIG_fail;
27909 }
27910 }
27911 {
27912 PyThreadState* __tstate = wxPyBeginAllowThreads();
27913 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27914
27915 wxPyEndAllowThreads(__tstate);
27916 if (PyErr_Occurred()) SWIG_fail;
27917 }
27918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27919 return resultobj;
27920 fail:
27921 return NULL;
27922 }
27923
27924
27925 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27926 PyObject *resultobj;
27927 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27928 wxBitmap result;
27929 PyObject * obj0 = 0 ;
27930 char *kwnames[] = {
27931 (char *) "self", NULL
27932 };
27933
27934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27936 if (SWIG_arg_fail(1)) SWIG_fail;
27937 {
27938 PyThreadState* __tstate = wxPyBeginAllowThreads();
27939 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27940
27941 wxPyEndAllowThreads(__tstate);
27942 if (PyErr_Occurred()) SWIG_fail;
27943 }
27944 {
27945 wxBitmap * resultptr;
27946 resultptr = new wxBitmap((wxBitmap &)(result));
27947 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27948 }
27949 return resultobj;
27950 fail:
27951 return NULL;
27952 }
27953
27954
27955 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27956 PyObject *resultobj;
27957 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27958 wxBitmap *arg2 = 0 ;
27959 PyObject * obj0 = 0 ;
27960 PyObject * obj1 = 0 ;
27961 char *kwnames[] = {
27962 (char *) "self",(char *) "bitmap", NULL
27963 };
27964
27965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27967 if (SWIG_arg_fail(1)) SWIG_fail;
27968 {
27969 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27970 if (SWIG_arg_fail(2)) SWIG_fail;
27971 if (arg2 == NULL) {
27972 SWIG_null_ref("wxBitmap");
27973 }
27974 if (SWIG_arg_fail(2)) SWIG_fail;
27975 }
27976 {
27977 PyThreadState* __tstate = wxPyBeginAllowThreads();
27978 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27979
27980 wxPyEndAllowThreads(__tstate);
27981 if (PyErr_Occurred()) SWIG_fail;
27982 }
27983 Py_INCREF(Py_None); resultobj = Py_None;
27984 return resultobj;
27985 fail:
27986 return NULL;
27987 }
27988
27989
27990 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27991 PyObject *obj;
27992 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27993 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27994 Py_INCREF(obj);
27995 return Py_BuildValue((char *)"");
27996 }
27997 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27998 PyObject *resultobj;
27999 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28000 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28001 wxPyBitmapDataObject *result;
28002 PyObject * obj0 = 0 ;
28003 char *kwnames[] = {
28004 (char *) "bitmap", NULL
28005 };
28006
28007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
28008 if (obj0) {
28009 {
28010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28011 if (SWIG_arg_fail(1)) SWIG_fail;
28012 if (arg1 == NULL) {
28013 SWIG_null_ref("wxBitmap");
28014 }
28015 if (SWIG_arg_fail(1)) SWIG_fail;
28016 }
28017 }
28018 {
28019 PyThreadState* __tstate = wxPyBeginAllowThreads();
28020 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
28021
28022 wxPyEndAllowThreads(__tstate);
28023 if (PyErr_Occurred()) SWIG_fail;
28024 }
28025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
28026 return resultobj;
28027 fail:
28028 return NULL;
28029 }
28030
28031
28032 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28033 PyObject *resultobj;
28034 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28035 PyObject *arg2 = (PyObject *) 0 ;
28036 PyObject *arg3 = (PyObject *) 0 ;
28037 PyObject * obj0 = 0 ;
28038 PyObject * obj1 = 0 ;
28039 PyObject * obj2 = 0 ;
28040 char *kwnames[] = {
28041 (char *) "self",(char *) "self",(char *) "_class", NULL
28042 };
28043
28044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28046 if (SWIG_arg_fail(1)) SWIG_fail;
28047 arg2 = obj1;
28048 arg3 = obj2;
28049 {
28050 PyThreadState* __tstate = wxPyBeginAllowThreads();
28051 (arg1)->_setCallbackInfo(arg2,arg3);
28052
28053 wxPyEndAllowThreads(__tstate);
28054 if (PyErr_Occurred()) SWIG_fail;
28055 }
28056 Py_INCREF(Py_None); resultobj = Py_None;
28057 return resultobj;
28058 fail:
28059 return NULL;
28060 }
28061
28062
28063 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28064 PyObject *obj;
28065 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28066 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28067 Py_INCREF(obj);
28068 return Py_BuildValue((char *)"");
28069 }
28070 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28071 PyObject *resultobj;
28072 wxFileDataObject *result;
28073 char *kwnames[] = {
28074 NULL
28075 };
28076
28077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28078 {
28079 PyThreadState* __tstate = wxPyBeginAllowThreads();
28080 result = (wxFileDataObject *)new wxFileDataObject();
28081
28082 wxPyEndAllowThreads(__tstate);
28083 if (PyErr_Occurred()) SWIG_fail;
28084 }
28085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28086 return resultobj;
28087 fail:
28088 return NULL;
28089 }
28090
28091
28092 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28093 PyObject *resultobj;
28094 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28095 wxArrayString *result;
28096 PyObject * obj0 = 0 ;
28097 char *kwnames[] = {
28098 (char *) "self", NULL
28099 };
28100
28101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28103 if (SWIG_arg_fail(1)) SWIG_fail;
28104 {
28105 PyThreadState* __tstate = wxPyBeginAllowThreads();
28106 {
28107 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28108 result = (wxArrayString *) &_result_ref;
28109 }
28110
28111 wxPyEndAllowThreads(__tstate);
28112 if (PyErr_Occurred()) SWIG_fail;
28113 }
28114 {
28115 resultobj = wxArrayString2PyList_helper(*result);
28116 }
28117 return resultobj;
28118 fail:
28119 return NULL;
28120 }
28121
28122
28123 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28124 PyObject *resultobj;
28125 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28126 wxString *arg2 = 0 ;
28127 bool temp2 = false ;
28128 PyObject * obj0 = 0 ;
28129 PyObject * obj1 = 0 ;
28130 char *kwnames[] = {
28131 (char *) "self",(char *) "filename", NULL
28132 };
28133
28134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28136 if (SWIG_arg_fail(1)) SWIG_fail;
28137 {
28138 arg2 = wxString_in_helper(obj1);
28139 if (arg2 == NULL) SWIG_fail;
28140 temp2 = true;
28141 }
28142 {
28143 PyThreadState* __tstate = wxPyBeginAllowThreads();
28144 (arg1)->AddFile((wxString const &)*arg2);
28145
28146 wxPyEndAllowThreads(__tstate);
28147 if (PyErr_Occurred()) SWIG_fail;
28148 }
28149 Py_INCREF(Py_None); resultobj = Py_None;
28150 {
28151 if (temp2)
28152 delete arg2;
28153 }
28154 return resultobj;
28155 fail:
28156 {
28157 if (temp2)
28158 delete arg2;
28159 }
28160 return NULL;
28161 }
28162
28163
28164 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28165 PyObject *obj;
28166 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28167 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28168 Py_INCREF(obj);
28169 return Py_BuildValue((char *)"");
28170 }
28171 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28172 PyObject *resultobj;
28173 wxDataFormat *arg1 = 0 ;
28174 wxCustomDataObject *result;
28175 PyObject * obj0 = 0 ;
28176
28177 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28178 {
28179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28180 if (SWIG_arg_fail(1)) SWIG_fail;
28181 if (arg1 == NULL) {
28182 SWIG_null_ref("wxDataFormat");
28183 }
28184 if (SWIG_arg_fail(1)) SWIG_fail;
28185 }
28186 {
28187 PyThreadState* __tstate = wxPyBeginAllowThreads();
28188 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28189
28190 wxPyEndAllowThreads(__tstate);
28191 if (PyErr_Occurred()) SWIG_fail;
28192 }
28193 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28194 return resultobj;
28195 fail:
28196 return NULL;
28197 }
28198
28199
28200 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28201 PyObject *resultobj;
28202 wxString *arg1 = 0 ;
28203 wxCustomDataObject *result;
28204 bool temp1 = false ;
28205 PyObject * obj0 = 0 ;
28206
28207 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28208 {
28209 arg1 = wxString_in_helper(obj0);
28210 if (arg1 == NULL) SWIG_fail;
28211 temp1 = true;
28212 }
28213 {
28214 PyThreadState* __tstate = wxPyBeginAllowThreads();
28215 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28216
28217 wxPyEndAllowThreads(__tstate);
28218 if (PyErr_Occurred()) SWIG_fail;
28219 }
28220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28221 {
28222 if (temp1)
28223 delete arg1;
28224 }
28225 return resultobj;
28226 fail:
28227 {
28228 if (temp1)
28229 delete arg1;
28230 }
28231 return NULL;
28232 }
28233
28234
28235 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28236 PyObject *resultobj;
28237 wxCustomDataObject *result;
28238
28239 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28240 {
28241 PyThreadState* __tstate = wxPyBeginAllowThreads();
28242 result = (wxCustomDataObject *)new wxCustomDataObject();
28243
28244 wxPyEndAllowThreads(__tstate);
28245 if (PyErr_Occurred()) SWIG_fail;
28246 }
28247 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28248 return resultobj;
28249 fail:
28250 return NULL;
28251 }
28252
28253
28254 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28255 int argc;
28256 PyObject *argv[2];
28257 int ii;
28258
28259 argc = PyObject_Length(args);
28260 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28261 argv[ii] = PyTuple_GetItem(args,ii);
28262 }
28263 if (argc == 0) {
28264 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28265 }
28266 if (argc == 1) {
28267 int _v;
28268 {
28269 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28270 }
28271 if (_v) {
28272 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28273 }
28274 }
28275 if (argc == 1) {
28276 int _v;
28277 {
28278 void *ptr = 0;
28279 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28280 _v = 0;
28281 PyErr_Clear();
28282 } else {
28283 _v = (ptr != 0);
28284 }
28285 }
28286 if (_v) {
28287 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28288 }
28289 }
28290
28291 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28292 return NULL;
28293 }
28294
28295
28296 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28297 PyObject *resultobj;
28298 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28299 PyObject *arg2 = (PyObject *) 0 ;
28300 bool result;
28301 PyObject * obj0 = 0 ;
28302 PyObject * obj1 = 0 ;
28303 char *kwnames[] = {
28304 (char *) "self",(char *) "data", NULL
28305 };
28306
28307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28309 if (SWIG_arg_fail(1)) SWIG_fail;
28310 arg2 = obj1;
28311 {
28312 PyThreadState* __tstate = wxPyBeginAllowThreads();
28313 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28314
28315 wxPyEndAllowThreads(__tstate);
28316 if (PyErr_Occurred()) SWIG_fail;
28317 }
28318 {
28319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28320 }
28321 return resultobj;
28322 fail:
28323 return NULL;
28324 }
28325
28326
28327 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28328 PyObject *resultobj;
28329 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28330 size_t result;
28331 PyObject * obj0 = 0 ;
28332 char *kwnames[] = {
28333 (char *) "self", NULL
28334 };
28335
28336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28338 if (SWIG_arg_fail(1)) SWIG_fail;
28339 {
28340 PyThreadState* __tstate = wxPyBeginAllowThreads();
28341 result = (size_t)(arg1)->GetSize();
28342
28343 wxPyEndAllowThreads(__tstate);
28344 if (PyErr_Occurred()) SWIG_fail;
28345 }
28346 {
28347 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28348 }
28349 return resultobj;
28350 fail:
28351 return NULL;
28352 }
28353
28354
28355 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28356 PyObject *resultobj;
28357 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28358 PyObject *result;
28359 PyObject * obj0 = 0 ;
28360 char *kwnames[] = {
28361 (char *) "self", NULL
28362 };
28363
28364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28366 if (SWIG_arg_fail(1)) SWIG_fail;
28367 {
28368 PyThreadState* __tstate = wxPyBeginAllowThreads();
28369 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28370
28371 wxPyEndAllowThreads(__tstate);
28372 if (PyErr_Occurred()) SWIG_fail;
28373 }
28374 resultobj = result;
28375 return resultobj;
28376 fail:
28377 return NULL;
28378 }
28379
28380
28381 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28382 PyObject *obj;
28383 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28384 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28385 Py_INCREF(obj);
28386 return Py_BuildValue((char *)"");
28387 }
28388 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28389 PyObject *resultobj;
28390 wxURLDataObject *result;
28391 char *kwnames[] = {
28392 NULL
28393 };
28394
28395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28396 {
28397 PyThreadState* __tstate = wxPyBeginAllowThreads();
28398 result = (wxURLDataObject *)new wxURLDataObject();
28399
28400 wxPyEndAllowThreads(__tstate);
28401 if (PyErr_Occurred()) SWIG_fail;
28402 }
28403 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28404 return resultobj;
28405 fail:
28406 return NULL;
28407 }
28408
28409
28410 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28411 PyObject *resultobj;
28412 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28413 wxString result;
28414 PyObject * obj0 = 0 ;
28415 char *kwnames[] = {
28416 (char *) "self", NULL
28417 };
28418
28419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28421 if (SWIG_arg_fail(1)) SWIG_fail;
28422 {
28423 PyThreadState* __tstate = wxPyBeginAllowThreads();
28424 result = (arg1)->GetURL();
28425
28426 wxPyEndAllowThreads(__tstate);
28427 if (PyErr_Occurred()) SWIG_fail;
28428 }
28429 {
28430 #if wxUSE_UNICODE
28431 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28432 #else
28433 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28434 #endif
28435 }
28436 return resultobj;
28437 fail:
28438 return NULL;
28439 }
28440
28441
28442 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28443 PyObject *resultobj;
28444 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28445 wxString *arg2 = 0 ;
28446 bool temp2 = false ;
28447 PyObject * obj0 = 0 ;
28448 PyObject * obj1 = 0 ;
28449 char *kwnames[] = {
28450 (char *) "self",(char *) "url", NULL
28451 };
28452
28453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28455 if (SWIG_arg_fail(1)) SWIG_fail;
28456 {
28457 arg2 = wxString_in_helper(obj1);
28458 if (arg2 == NULL) SWIG_fail;
28459 temp2 = true;
28460 }
28461 {
28462 PyThreadState* __tstate = wxPyBeginAllowThreads();
28463 (arg1)->SetURL((wxString const &)*arg2);
28464
28465 wxPyEndAllowThreads(__tstate);
28466 if (PyErr_Occurred()) SWIG_fail;
28467 }
28468 Py_INCREF(Py_None); resultobj = Py_None;
28469 {
28470 if (temp2)
28471 delete arg2;
28472 }
28473 return resultobj;
28474 fail:
28475 {
28476 if (temp2)
28477 delete arg2;
28478 }
28479 return NULL;
28480 }
28481
28482
28483 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28484 PyObject *obj;
28485 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28486 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28487 Py_INCREF(obj);
28488 return Py_BuildValue((char *)"");
28489 }
28490 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28491 PyObject *resultobj;
28492 wxMetafileDataObject *result;
28493 char *kwnames[] = {
28494 NULL
28495 };
28496
28497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28498 {
28499 PyThreadState* __tstate = wxPyBeginAllowThreads();
28500 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28501
28502 wxPyEndAllowThreads(__tstate);
28503 if (PyErr_Occurred()) SWIG_fail;
28504 }
28505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28506 return resultobj;
28507 fail:
28508 return NULL;
28509 }
28510
28511
28512 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28513 PyObject *resultobj;
28514 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28515 wxMetafile *arg2 = 0 ;
28516 PyObject * obj0 = 0 ;
28517 PyObject * obj1 = 0 ;
28518 char *kwnames[] = {
28519 (char *) "self",(char *) "metafile", NULL
28520 };
28521
28522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28524 if (SWIG_arg_fail(1)) SWIG_fail;
28525 {
28526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28527 if (SWIG_arg_fail(2)) SWIG_fail;
28528 if (arg2 == NULL) {
28529 SWIG_null_ref("wxMetafile");
28530 }
28531 if (SWIG_arg_fail(2)) SWIG_fail;
28532 }
28533 {
28534 PyThreadState* __tstate = wxPyBeginAllowThreads();
28535 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28536
28537 wxPyEndAllowThreads(__tstate);
28538 if (PyErr_Occurred()) SWIG_fail;
28539 }
28540 Py_INCREF(Py_None); resultobj = Py_None;
28541 return resultobj;
28542 fail:
28543 return NULL;
28544 }
28545
28546
28547 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28548 PyObject *resultobj;
28549 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28550 wxMetafile result;
28551 PyObject * obj0 = 0 ;
28552 char *kwnames[] = {
28553 (char *) "self", NULL
28554 };
28555
28556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28558 if (SWIG_arg_fail(1)) SWIG_fail;
28559 {
28560 PyThreadState* __tstate = wxPyBeginAllowThreads();
28561 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28562
28563 wxPyEndAllowThreads(__tstate);
28564 if (PyErr_Occurred()) SWIG_fail;
28565 }
28566 {
28567 wxMetafile * resultptr;
28568 resultptr = new wxMetafile((wxMetafile &)(result));
28569 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28570 }
28571 return resultobj;
28572 fail:
28573 return NULL;
28574 }
28575
28576
28577 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28578 PyObject *obj;
28579 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28580 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28581 Py_INCREF(obj);
28582 return Py_BuildValue((char *)"");
28583 }
28584 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28585 PyObject *resultobj;
28586 wxDragResult arg1 ;
28587 bool result;
28588 PyObject * obj0 = 0 ;
28589 char *kwnames[] = {
28590 (char *) "res", NULL
28591 };
28592
28593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28594 {
28595 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28596 if (SWIG_arg_fail(1)) SWIG_fail;
28597 }
28598 {
28599 PyThreadState* __tstate = wxPyBeginAllowThreads();
28600 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28601
28602 wxPyEndAllowThreads(__tstate);
28603 if (PyErr_Occurred()) SWIG_fail;
28604 }
28605 {
28606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28607 }
28608 return resultobj;
28609 fail:
28610 return NULL;
28611 }
28612
28613
28614 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28615 PyObject *resultobj;
28616 wxWindow *arg1 = (wxWindow *) 0 ;
28617 wxCursor const &arg2_defvalue = wxNullCursor ;
28618 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28619 wxCursor const &arg3_defvalue = wxNullCursor ;
28620 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28621 wxCursor const &arg4_defvalue = wxNullCursor ;
28622 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28623 wxPyDropSource *result;
28624 PyObject * obj0 = 0 ;
28625 PyObject * obj1 = 0 ;
28626 PyObject * obj2 = 0 ;
28627 PyObject * obj3 = 0 ;
28628 char *kwnames[] = {
28629 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28630 };
28631
28632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28634 if (SWIG_arg_fail(1)) SWIG_fail;
28635 if (obj1) {
28636 {
28637 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28638 if (SWIG_arg_fail(2)) SWIG_fail;
28639 if (arg2 == NULL) {
28640 SWIG_null_ref("wxCursor");
28641 }
28642 if (SWIG_arg_fail(2)) SWIG_fail;
28643 }
28644 }
28645 if (obj2) {
28646 {
28647 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28648 if (SWIG_arg_fail(3)) SWIG_fail;
28649 if (arg3 == NULL) {
28650 SWIG_null_ref("wxCursor");
28651 }
28652 if (SWIG_arg_fail(3)) SWIG_fail;
28653 }
28654 }
28655 if (obj3) {
28656 {
28657 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28658 if (SWIG_arg_fail(4)) SWIG_fail;
28659 if (arg4 == NULL) {
28660 SWIG_null_ref("wxCursor");
28661 }
28662 if (SWIG_arg_fail(4)) SWIG_fail;
28663 }
28664 }
28665 {
28666 PyThreadState* __tstate = wxPyBeginAllowThreads();
28667 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28668
28669 wxPyEndAllowThreads(__tstate);
28670 if (PyErr_Occurred()) SWIG_fail;
28671 }
28672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28673 return resultobj;
28674 fail:
28675 return NULL;
28676 }
28677
28678
28679 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28680 PyObject *resultobj;
28681 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28682 PyObject *arg2 = (PyObject *) 0 ;
28683 PyObject *arg3 = (PyObject *) 0 ;
28684 int arg4 ;
28685 PyObject * obj0 = 0 ;
28686 PyObject * obj1 = 0 ;
28687 PyObject * obj2 = 0 ;
28688 PyObject * obj3 = 0 ;
28689 char *kwnames[] = {
28690 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28691 };
28692
28693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28695 if (SWIG_arg_fail(1)) SWIG_fail;
28696 arg2 = obj1;
28697 arg3 = obj2;
28698 {
28699 arg4 = (int)(SWIG_As_int(obj3));
28700 if (SWIG_arg_fail(4)) SWIG_fail;
28701 }
28702 {
28703 PyThreadState* __tstate = wxPyBeginAllowThreads();
28704 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28705
28706 wxPyEndAllowThreads(__tstate);
28707 if (PyErr_Occurred()) SWIG_fail;
28708 }
28709 Py_INCREF(Py_None); resultobj = Py_None;
28710 return resultobj;
28711 fail:
28712 return NULL;
28713 }
28714
28715
28716 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28717 PyObject *resultobj;
28718 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28719 PyObject * obj0 = 0 ;
28720 char *kwnames[] = {
28721 (char *) "self", NULL
28722 };
28723
28724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28726 if (SWIG_arg_fail(1)) SWIG_fail;
28727 {
28728 PyThreadState* __tstate = wxPyBeginAllowThreads();
28729 delete arg1;
28730
28731 wxPyEndAllowThreads(__tstate);
28732 if (PyErr_Occurred()) SWIG_fail;
28733 }
28734 Py_INCREF(Py_None); resultobj = Py_None;
28735 return resultobj;
28736 fail:
28737 return NULL;
28738 }
28739
28740
28741 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28742 PyObject *resultobj;
28743 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28744 wxDataObject *arg2 = 0 ;
28745 PyObject * obj0 = 0 ;
28746 PyObject * obj1 = 0 ;
28747 char *kwnames[] = {
28748 (char *) "self",(char *) "data", NULL
28749 };
28750
28751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28753 if (SWIG_arg_fail(1)) SWIG_fail;
28754 {
28755 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28756 if (SWIG_arg_fail(2)) SWIG_fail;
28757 if (arg2 == NULL) {
28758 SWIG_null_ref("wxDataObject");
28759 }
28760 if (SWIG_arg_fail(2)) SWIG_fail;
28761 }
28762 {
28763 PyThreadState* __tstate = wxPyBeginAllowThreads();
28764 (arg1)->SetData(*arg2);
28765
28766 wxPyEndAllowThreads(__tstate);
28767 if (PyErr_Occurred()) SWIG_fail;
28768 }
28769 Py_INCREF(Py_None); resultobj = Py_None;
28770 return resultobj;
28771 fail:
28772 return NULL;
28773 }
28774
28775
28776 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28777 PyObject *resultobj;
28778 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28779 wxDataObject *result;
28780 PyObject * obj0 = 0 ;
28781 char *kwnames[] = {
28782 (char *) "self", NULL
28783 };
28784
28785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28787 if (SWIG_arg_fail(1)) SWIG_fail;
28788 {
28789 PyThreadState* __tstate = wxPyBeginAllowThreads();
28790 result = (wxDataObject *)(arg1)->GetDataObject();
28791
28792 wxPyEndAllowThreads(__tstate);
28793 if (PyErr_Occurred()) SWIG_fail;
28794 }
28795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28796 return resultobj;
28797 fail:
28798 return NULL;
28799 }
28800
28801
28802 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28803 PyObject *resultobj;
28804 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28805 wxDragResult arg2 ;
28806 wxCursor *arg3 = 0 ;
28807 PyObject * obj0 = 0 ;
28808 PyObject * obj1 = 0 ;
28809 PyObject * obj2 = 0 ;
28810 char *kwnames[] = {
28811 (char *) "self",(char *) "res",(char *) "cursor", NULL
28812 };
28813
28814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28816 if (SWIG_arg_fail(1)) SWIG_fail;
28817 {
28818 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28819 if (SWIG_arg_fail(2)) SWIG_fail;
28820 }
28821 {
28822 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28823 if (SWIG_arg_fail(3)) SWIG_fail;
28824 if (arg3 == NULL) {
28825 SWIG_null_ref("wxCursor");
28826 }
28827 if (SWIG_arg_fail(3)) SWIG_fail;
28828 }
28829 {
28830 PyThreadState* __tstate = wxPyBeginAllowThreads();
28831 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28832
28833 wxPyEndAllowThreads(__tstate);
28834 if (PyErr_Occurred()) SWIG_fail;
28835 }
28836 Py_INCREF(Py_None); resultobj = Py_None;
28837 return resultobj;
28838 fail:
28839 return NULL;
28840 }
28841
28842
28843 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28844 PyObject *resultobj;
28845 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28846 int arg2 = (int) wxDrag_CopyOnly ;
28847 wxDragResult result;
28848 PyObject * obj0 = 0 ;
28849 PyObject * obj1 = 0 ;
28850 char *kwnames[] = {
28851 (char *) "self",(char *) "flags", NULL
28852 };
28853
28854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28856 if (SWIG_arg_fail(1)) SWIG_fail;
28857 if (obj1) {
28858 {
28859 arg2 = (int)(SWIG_As_int(obj1));
28860 if (SWIG_arg_fail(2)) SWIG_fail;
28861 }
28862 }
28863 {
28864 PyThreadState* __tstate = wxPyBeginAllowThreads();
28865 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28866
28867 wxPyEndAllowThreads(__tstate);
28868 if (PyErr_Occurred()) SWIG_fail;
28869 }
28870 resultobj = SWIG_From_int((result));
28871 return resultobj;
28872 fail:
28873 return NULL;
28874 }
28875
28876
28877 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28878 PyObject *resultobj;
28879 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28880 wxDragResult arg2 ;
28881 bool result;
28882 PyObject * obj0 = 0 ;
28883 PyObject * obj1 = 0 ;
28884 char *kwnames[] = {
28885 (char *) "self",(char *) "effect", NULL
28886 };
28887
28888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28890 if (SWIG_arg_fail(1)) SWIG_fail;
28891 {
28892 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28893 if (SWIG_arg_fail(2)) SWIG_fail;
28894 }
28895 {
28896 PyThreadState* __tstate = wxPyBeginAllowThreads();
28897 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28898
28899 wxPyEndAllowThreads(__tstate);
28900 if (PyErr_Occurred()) SWIG_fail;
28901 }
28902 {
28903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28904 }
28905 return resultobj;
28906 fail:
28907 return NULL;
28908 }
28909
28910
28911 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28912 PyObject *obj;
28913 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28914 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28915 Py_INCREF(obj);
28916 return Py_BuildValue((char *)"");
28917 }
28918 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28919 PyObject *resultobj;
28920 wxDataObject *arg1 = (wxDataObject *) NULL ;
28921 wxPyDropTarget *result;
28922 PyObject * obj0 = 0 ;
28923 char *kwnames[] = {
28924 (char *) "dataObject", NULL
28925 };
28926
28927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28928 if (obj0) {
28929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28930 if (SWIG_arg_fail(1)) SWIG_fail;
28931 }
28932 {
28933 PyThreadState* __tstate = wxPyBeginAllowThreads();
28934 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28935
28936 wxPyEndAllowThreads(__tstate);
28937 if (PyErr_Occurred()) SWIG_fail;
28938 }
28939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28940 return resultobj;
28941 fail:
28942 return NULL;
28943 }
28944
28945
28946 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28947 PyObject *resultobj;
28948 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28949 PyObject *arg2 = (PyObject *) 0 ;
28950 PyObject *arg3 = (PyObject *) 0 ;
28951 PyObject * obj0 = 0 ;
28952 PyObject * obj1 = 0 ;
28953 PyObject * obj2 = 0 ;
28954 char *kwnames[] = {
28955 (char *) "self",(char *) "self",(char *) "_class", NULL
28956 };
28957
28958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28960 if (SWIG_arg_fail(1)) SWIG_fail;
28961 arg2 = obj1;
28962 arg3 = obj2;
28963 {
28964 PyThreadState* __tstate = wxPyBeginAllowThreads();
28965 (arg1)->_setCallbackInfo(arg2,arg3);
28966
28967 wxPyEndAllowThreads(__tstate);
28968 if (PyErr_Occurred()) SWIG_fail;
28969 }
28970 Py_INCREF(Py_None); resultobj = Py_None;
28971 return resultobj;
28972 fail:
28973 return NULL;
28974 }
28975
28976
28977 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28978 PyObject *resultobj;
28979 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28980 PyObject * obj0 = 0 ;
28981 char *kwnames[] = {
28982 (char *) "self", NULL
28983 };
28984
28985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28987 if (SWIG_arg_fail(1)) SWIG_fail;
28988 {
28989 PyThreadState* __tstate = wxPyBeginAllowThreads();
28990 delete arg1;
28991
28992 wxPyEndAllowThreads(__tstate);
28993 if (PyErr_Occurred()) SWIG_fail;
28994 }
28995 Py_INCREF(Py_None); resultobj = Py_None;
28996 return resultobj;
28997 fail:
28998 return NULL;
28999 }
29000
29001
29002 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29003 PyObject *resultobj;
29004 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29005 wxDataObject *result;
29006 PyObject * obj0 = 0 ;
29007 char *kwnames[] = {
29008 (char *) "self", NULL
29009 };
29010
29011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
29012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29013 if (SWIG_arg_fail(1)) SWIG_fail;
29014 {
29015 PyThreadState* __tstate = wxPyBeginAllowThreads();
29016 result = (wxDataObject *)(arg1)->GetDataObject();
29017
29018 wxPyEndAllowThreads(__tstate);
29019 if (PyErr_Occurred()) SWIG_fail;
29020 }
29021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
29022 return resultobj;
29023 fail:
29024 return NULL;
29025 }
29026
29027
29028 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29029 PyObject *resultobj;
29030 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29031 wxDataObject *arg2 = (wxDataObject *) 0 ;
29032 PyObject * obj0 = 0 ;
29033 PyObject * obj1 = 0 ;
29034 char *kwnames[] = {
29035 (char *) "self",(char *) "dataObject", NULL
29036 };
29037
29038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
29039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29040 if (SWIG_arg_fail(1)) SWIG_fail;
29041 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29042 if (SWIG_arg_fail(2)) SWIG_fail;
29043 {
29044 PyThreadState* __tstate = wxPyBeginAllowThreads();
29045 (arg1)->SetDataObject(arg2);
29046
29047 wxPyEndAllowThreads(__tstate);
29048 if (PyErr_Occurred()) SWIG_fail;
29049 }
29050 Py_INCREF(Py_None); resultobj = Py_None;
29051 return resultobj;
29052 fail:
29053 return NULL;
29054 }
29055
29056
29057 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29058 PyObject *resultobj;
29059 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29060 int arg2 ;
29061 int arg3 ;
29062 wxDragResult arg4 ;
29063 wxDragResult result;
29064 PyObject * obj0 = 0 ;
29065 PyObject * obj1 = 0 ;
29066 PyObject * obj2 = 0 ;
29067 PyObject * obj3 = 0 ;
29068 char *kwnames[] = {
29069 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29070 };
29071
29072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29074 if (SWIG_arg_fail(1)) SWIG_fail;
29075 {
29076 arg2 = (int)(SWIG_As_int(obj1));
29077 if (SWIG_arg_fail(2)) SWIG_fail;
29078 }
29079 {
29080 arg3 = (int)(SWIG_As_int(obj2));
29081 if (SWIG_arg_fail(3)) SWIG_fail;
29082 }
29083 {
29084 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29085 if (SWIG_arg_fail(4)) SWIG_fail;
29086 }
29087 {
29088 PyThreadState* __tstate = wxPyBeginAllowThreads();
29089 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29090
29091 wxPyEndAllowThreads(__tstate);
29092 if (PyErr_Occurred()) SWIG_fail;
29093 }
29094 resultobj = SWIG_From_int((result));
29095 return resultobj;
29096 fail:
29097 return NULL;
29098 }
29099
29100
29101 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29102 PyObject *resultobj;
29103 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29104 int arg2 ;
29105 int arg3 ;
29106 wxDragResult arg4 ;
29107 wxDragResult result;
29108 PyObject * obj0 = 0 ;
29109 PyObject * obj1 = 0 ;
29110 PyObject * obj2 = 0 ;
29111 PyObject * obj3 = 0 ;
29112 char *kwnames[] = {
29113 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29114 };
29115
29116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg2 = (int)(SWIG_As_int(obj1));
29121 if (SWIG_arg_fail(2)) SWIG_fail;
29122 }
29123 {
29124 arg3 = (int)(SWIG_As_int(obj2));
29125 if (SWIG_arg_fail(3)) SWIG_fail;
29126 }
29127 {
29128 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29129 if (SWIG_arg_fail(4)) SWIG_fail;
29130 }
29131 {
29132 PyThreadState* __tstate = wxPyBeginAllowThreads();
29133 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29134
29135 wxPyEndAllowThreads(__tstate);
29136 if (PyErr_Occurred()) SWIG_fail;
29137 }
29138 resultobj = SWIG_From_int((result));
29139 return resultobj;
29140 fail:
29141 return NULL;
29142 }
29143
29144
29145 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29146 PyObject *resultobj;
29147 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29148 PyObject * obj0 = 0 ;
29149 char *kwnames[] = {
29150 (char *) "self", NULL
29151 };
29152
29153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29155 if (SWIG_arg_fail(1)) SWIG_fail;
29156 {
29157 PyThreadState* __tstate = wxPyBeginAllowThreads();
29158 (arg1)->base_OnLeave();
29159
29160 wxPyEndAllowThreads(__tstate);
29161 if (PyErr_Occurred()) SWIG_fail;
29162 }
29163 Py_INCREF(Py_None); resultobj = Py_None;
29164 return resultobj;
29165 fail:
29166 return NULL;
29167 }
29168
29169
29170 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29171 PyObject *resultobj;
29172 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29173 int arg2 ;
29174 int arg3 ;
29175 bool result;
29176 PyObject * obj0 = 0 ;
29177 PyObject * obj1 = 0 ;
29178 PyObject * obj2 = 0 ;
29179 char *kwnames[] = {
29180 (char *) "self",(char *) "x",(char *) "y", NULL
29181 };
29182
29183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29185 if (SWIG_arg_fail(1)) SWIG_fail;
29186 {
29187 arg2 = (int)(SWIG_As_int(obj1));
29188 if (SWIG_arg_fail(2)) SWIG_fail;
29189 }
29190 {
29191 arg3 = (int)(SWIG_As_int(obj2));
29192 if (SWIG_arg_fail(3)) SWIG_fail;
29193 }
29194 {
29195 PyThreadState* __tstate = wxPyBeginAllowThreads();
29196 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29197
29198 wxPyEndAllowThreads(__tstate);
29199 if (PyErr_Occurred()) SWIG_fail;
29200 }
29201 {
29202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29203 }
29204 return resultobj;
29205 fail:
29206 return NULL;
29207 }
29208
29209
29210 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29211 PyObject *resultobj;
29212 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29213 bool result;
29214 PyObject * obj0 = 0 ;
29215 char *kwnames[] = {
29216 (char *) "self", NULL
29217 };
29218
29219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29221 if (SWIG_arg_fail(1)) SWIG_fail;
29222 {
29223 PyThreadState* __tstate = wxPyBeginAllowThreads();
29224 result = (bool)(arg1)->GetData();
29225
29226 wxPyEndAllowThreads(__tstate);
29227 if (PyErr_Occurred()) SWIG_fail;
29228 }
29229 {
29230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29231 }
29232 return resultobj;
29233 fail:
29234 return NULL;
29235 }
29236
29237
29238 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29239 PyObject *resultobj;
29240 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29241 wxDragResult arg2 ;
29242 PyObject * obj0 = 0 ;
29243 PyObject * obj1 = 0 ;
29244 char *kwnames[] = {
29245 (char *) "self",(char *) "action", NULL
29246 };
29247
29248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29250 if (SWIG_arg_fail(1)) SWIG_fail;
29251 {
29252 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29253 if (SWIG_arg_fail(2)) SWIG_fail;
29254 }
29255 {
29256 PyThreadState* __tstate = wxPyBeginAllowThreads();
29257 (arg1)->SetDefaultAction((wxDragResult )arg2);
29258
29259 wxPyEndAllowThreads(__tstate);
29260 if (PyErr_Occurred()) SWIG_fail;
29261 }
29262 Py_INCREF(Py_None); resultobj = Py_None;
29263 return resultobj;
29264 fail:
29265 return NULL;
29266 }
29267
29268
29269 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29270 PyObject *resultobj;
29271 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29272 wxDragResult result;
29273 PyObject * obj0 = 0 ;
29274 char *kwnames[] = {
29275 (char *) "self", NULL
29276 };
29277
29278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29280 if (SWIG_arg_fail(1)) SWIG_fail;
29281 {
29282 PyThreadState* __tstate = wxPyBeginAllowThreads();
29283 result = (wxDragResult)(arg1)->GetDefaultAction();
29284
29285 wxPyEndAllowThreads(__tstate);
29286 if (PyErr_Occurred()) SWIG_fail;
29287 }
29288 resultobj = SWIG_From_int((result));
29289 return resultobj;
29290 fail:
29291 return NULL;
29292 }
29293
29294
29295 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29296 PyObject *obj;
29297 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29298 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29299 Py_INCREF(obj);
29300 return Py_BuildValue((char *)"");
29301 }
29302 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29303 PyObject *resultobj;
29304 wxPyTextDropTarget *result;
29305 char *kwnames[] = {
29306 NULL
29307 };
29308
29309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29310 {
29311 PyThreadState* __tstate = wxPyBeginAllowThreads();
29312 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29313
29314 wxPyEndAllowThreads(__tstate);
29315 if (PyErr_Occurred()) SWIG_fail;
29316 }
29317 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29318 return resultobj;
29319 fail:
29320 return NULL;
29321 }
29322
29323
29324 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29325 PyObject *resultobj;
29326 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29327 PyObject *arg2 = (PyObject *) 0 ;
29328 PyObject *arg3 = (PyObject *) 0 ;
29329 PyObject * obj0 = 0 ;
29330 PyObject * obj1 = 0 ;
29331 PyObject * obj2 = 0 ;
29332 char *kwnames[] = {
29333 (char *) "self",(char *) "self",(char *) "_class", NULL
29334 };
29335
29336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29338 if (SWIG_arg_fail(1)) SWIG_fail;
29339 arg2 = obj1;
29340 arg3 = obj2;
29341 {
29342 PyThreadState* __tstate = wxPyBeginAllowThreads();
29343 (arg1)->_setCallbackInfo(arg2,arg3);
29344
29345 wxPyEndAllowThreads(__tstate);
29346 if (PyErr_Occurred()) SWIG_fail;
29347 }
29348 Py_INCREF(Py_None); resultobj = Py_None;
29349 return resultobj;
29350 fail:
29351 return NULL;
29352 }
29353
29354
29355 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29356 PyObject *resultobj;
29357 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29358 int arg2 ;
29359 int arg3 ;
29360 wxDragResult arg4 ;
29361 wxDragResult result;
29362 PyObject * obj0 = 0 ;
29363 PyObject * obj1 = 0 ;
29364 PyObject * obj2 = 0 ;
29365 PyObject * obj3 = 0 ;
29366 char *kwnames[] = {
29367 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29368 };
29369
29370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29372 if (SWIG_arg_fail(1)) SWIG_fail;
29373 {
29374 arg2 = (int)(SWIG_As_int(obj1));
29375 if (SWIG_arg_fail(2)) SWIG_fail;
29376 }
29377 {
29378 arg3 = (int)(SWIG_As_int(obj2));
29379 if (SWIG_arg_fail(3)) SWIG_fail;
29380 }
29381 {
29382 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29383 if (SWIG_arg_fail(4)) SWIG_fail;
29384 }
29385 {
29386 PyThreadState* __tstate = wxPyBeginAllowThreads();
29387 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29388
29389 wxPyEndAllowThreads(__tstate);
29390 if (PyErr_Occurred()) SWIG_fail;
29391 }
29392 resultobj = SWIG_From_int((result));
29393 return resultobj;
29394 fail:
29395 return NULL;
29396 }
29397
29398
29399 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29400 PyObject *resultobj;
29401 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29402 int arg2 ;
29403 int arg3 ;
29404 wxDragResult arg4 ;
29405 wxDragResult result;
29406 PyObject * obj0 = 0 ;
29407 PyObject * obj1 = 0 ;
29408 PyObject * obj2 = 0 ;
29409 PyObject * obj3 = 0 ;
29410 char *kwnames[] = {
29411 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29412 };
29413
29414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg2 = (int)(SWIG_As_int(obj1));
29419 if (SWIG_arg_fail(2)) SWIG_fail;
29420 }
29421 {
29422 arg3 = (int)(SWIG_As_int(obj2));
29423 if (SWIG_arg_fail(3)) SWIG_fail;
29424 }
29425 {
29426 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29427 if (SWIG_arg_fail(4)) SWIG_fail;
29428 }
29429 {
29430 PyThreadState* __tstate = wxPyBeginAllowThreads();
29431 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29432
29433 wxPyEndAllowThreads(__tstate);
29434 if (PyErr_Occurred()) SWIG_fail;
29435 }
29436 resultobj = SWIG_From_int((result));
29437 return resultobj;
29438 fail:
29439 return NULL;
29440 }
29441
29442
29443 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29444 PyObject *resultobj;
29445 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29446 PyObject * obj0 = 0 ;
29447 char *kwnames[] = {
29448 (char *) "self", NULL
29449 };
29450
29451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29453 if (SWIG_arg_fail(1)) SWIG_fail;
29454 {
29455 PyThreadState* __tstate = wxPyBeginAllowThreads();
29456 (arg1)->base_OnLeave();
29457
29458 wxPyEndAllowThreads(__tstate);
29459 if (PyErr_Occurred()) SWIG_fail;
29460 }
29461 Py_INCREF(Py_None); resultobj = Py_None;
29462 return resultobj;
29463 fail:
29464 return NULL;
29465 }
29466
29467
29468 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29469 PyObject *resultobj;
29470 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29471 int arg2 ;
29472 int arg3 ;
29473 bool result;
29474 PyObject * obj0 = 0 ;
29475 PyObject * obj1 = 0 ;
29476 PyObject * obj2 = 0 ;
29477 char *kwnames[] = {
29478 (char *) "self",(char *) "x",(char *) "y", NULL
29479 };
29480
29481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29483 if (SWIG_arg_fail(1)) SWIG_fail;
29484 {
29485 arg2 = (int)(SWIG_As_int(obj1));
29486 if (SWIG_arg_fail(2)) SWIG_fail;
29487 }
29488 {
29489 arg3 = (int)(SWIG_As_int(obj2));
29490 if (SWIG_arg_fail(3)) SWIG_fail;
29491 }
29492 {
29493 PyThreadState* __tstate = wxPyBeginAllowThreads();
29494 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29495
29496 wxPyEndAllowThreads(__tstate);
29497 if (PyErr_Occurred()) SWIG_fail;
29498 }
29499 {
29500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29501 }
29502 return resultobj;
29503 fail:
29504 return NULL;
29505 }
29506
29507
29508 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29509 PyObject *resultobj;
29510 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29511 int arg2 ;
29512 int arg3 ;
29513 wxDragResult arg4 ;
29514 wxDragResult result;
29515 PyObject * obj0 = 0 ;
29516 PyObject * obj1 = 0 ;
29517 PyObject * obj2 = 0 ;
29518 PyObject * obj3 = 0 ;
29519 char *kwnames[] = {
29520 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29521 };
29522
29523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29525 if (SWIG_arg_fail(1)) SWIG_fail;
29526 {
29527 arg2 = (int)(SWIG_As_int(obj1));
29528 if (SWIG_arg_fail(2)) SWIG_fail;
29529 }
29530 {
29531 arg3 = (int)(SWIG_As_int(obj2));
29532 if (SWIG_arg_fail(3)) SWIG_fail;
29533 }
29534 {
29535 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29536 if (SWIG_arg_fail(4)) SWIG_fail;
29537 }
29538 {
29539 PyThreadState* __tstate = wxPyBeginAllowThreads();
29540 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29541
29542 wxPyEndAllowThreads(__tstate);
29543 if (PyErr_Occurred()) SWIG_fail;
29544 }
29545 resultobj = SWIG_From_int((result));
29546 return resultobj;
29547 fail:
29548 return NULL;
29549 }
29550
29551
29552 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29553 PyObject *obj;
29554 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29555 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29556 Py_INCREF(obj);
29557 return Py_BuildValue((char *)"");
29558 }
29559 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29560 PyObject *resultobj;
29561 wxPyFileDropTarget *result;
29562 char *kwnames[] = {
29563 NULL
29564 };
29565
29566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29567 {
29568 PyThreadState* __tstate = wxPyBeginAllowThreads();
29569 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29570
29571 wxPyEndAllowThreads(__tstate);
29572 if (PyErr_Occurred()) SWIG_fail;
29573 }
29574 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29575 return resultobj;
29576 fail:
29577 return NULL;
29578 }
29579
29580
29581 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29582 PyObject *resultobj;
29583 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29584 PyObject *arg2 = (PyObject *) 0 ;
29585 PyObject *arg3 = (PyObject *) 0 ;
29586 PyObject * obj0 = 0 ;
29587 PyObject * obj1 = 0 ;
29588 PyObject * obj2 = 0 ;
29589 char *kwnames[] = {
29590 (char *) "self",(char *) "self",(char *) "_class", NULL
29591 };
29592
29593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29595 if (SWIG_arg_fail(1)) SWIG_fail;
29596 arg2 = obj1;
29597 arg3 = obj2;
29598 {
29599 PyThreadState* __tstate = wxPyBeginAllowThreads();
29600 (arg1)->_setCallbackInfo(arg2,arg3);
29601
29602 wxPyEndAllowThreads(__tstate);
29603 if (PyErr_Occurred()) SWIG_fail;
29604 }
29605 Py_INCREF(Py_None); resultobj = Py_None;
29606 return resultobj;
29607 fail:
29608 return NULL;
29609 }
29610
29611
29612 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29613 PyObject *resultobj;
29614 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29615 int arg2 ;
29616 int arg3 ;
29617 wxDragResult arg4 ;
29618 wxDragResult result;
29619 PyObject * obj0 = 0 ;
29620 PyObject * obj1 = 0 ;
29621 PyObject * obj2 = 0 ;
29622 PyObject * obj3 = 0 ;
29623 char *kwnames[] = {
29624 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29625 };
29626
29627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29629 if (SWIG_arg_fail(1)) SWIG_fail;
29630 {
29631 arg2 = (int)(SWIG_As_int(obj1));
29632 if (SWIG_arg_fail(2)) SWIG_fail;
29633 }
29634 {
29635 arg3 = (int)(SWIG_As_int(obj2));
29636 if (SWIG_arg_fail(3)) SWIG_fail;
29637 }
29638 {
29639 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29640 if (SWIG_arg_fail(4)) SWIG_fail;
29641 }
29642 {
29643 PyThreadState* __tstate = wxPyBeginAllowThreads();
29644 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29645
29646 wxPyEndAllowThreads(__tstate);
29647 if (PyErr_Occurred()) SWIG_fail;
29648 }
29649 resultobj = SWIG_From_int((result));
29650 return resultobj;
29651 fail:
29652 return NULL;
29653 }
29654
29655
29656 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29657 PyObject *resultobj;
29658 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29659 int arg2 ;
29660 int arg3 ;
29661 wxDragResult arg4 ;
29662 wxDragResult result;
29663 PyObject * obj0 = 0 ;
29664 PyObject * obj1 = 0 ;
29665 PyObject * obj2 = 0 ;
29666 PyObject * obj3 = 0 ;
29667 char *kwnames[] = {
29668 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29669 };
29670
29671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg2 = (int)(SWIG_As_int(obj1));
29676 if (SWIG_arg_fail(2)) SWIG_fail;
29677 }
29678 {
29679 arg3 = (int)(SWIG_As_int(obj2));
29680 if (SWIG_arg_fail(3)) SWIG_fail;
29681 }
29682 {
29683 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29684 if (SWIG_arg_fail(4)) SWIG_fail;
29685 }
29686 {
29687 PyThreadState* __tstate = wxPyBeginAllowThreads();
29688 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29689
29690 wxPyEndAllowThreads(__tstate);
29691 if (PyErr_Occurred()) SWIG_fail;
29692 }
29693 resultobj = SWIG_From_int((result));
29694 return resultobj;
29695 fail:
29696 return NULL;
29697 }
29698
29699
29700 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29701 PyObject *resultobj;
29702 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29703 PyObject * obj0 = 0 ;
29704 char *kwnames[] = {
29705 (char *) "self", NULL
29706 };
29707
29708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29710 if (SWIG_arg_fail(1)) SWIG_fail;
29711 {
29712 PyThreadState* __tstate = wxPyBeginAllowThreads();
29713 (arg1)->base_OnLeave();
29714
29715 wxPyEndAllowThreads(__tstate);
29716 if (PyErr_Occurred()) SWIG_fail;
29717 }
29718 Py_INCREF(Py_None); resultobj = Py_None;
29719 return resultobj;
29720 fail:
29721 return NULL;
29722 }
29723
29724
29725 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29726 PyObject *resultobj;
29727 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29728 int arg2 ;
29729 int arg3 ;
29730 bool result;
29731 PyObject * obj0 = 0 ;
29732 PyObject * obj1 = 0 ;
29733 PyObject * obj2 = 0 ;
29734 char *kwnames[] = {
29735 (char *) "self",(char *) "x",(char *) "y", NULL
29736 };
29737
29738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29740 if (SWIG_arg_fail(1)) SWIG_fail;
29741 {
29742 arg2 = (int)(SWIG_As_int(obj1));
29743 if (SWIG_arg_fail(2)) SWIG_fail;
29744 }
29745 {
29746 arg3 = (int)(SWIG_As_int(obj2));
29747 if (SWIG_arg_fail(3)) SWIG_fail;
29748 }
29749 {
29750 PyThreadState* __tstate = wxPyBeginAllowThreads();
29751 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29752
29753 wxPyEndAllowThreads(__tstate);
29754 if (PyErr_Occurred()) SWIG_fail;
29755 }
29756 {
29757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29758 }
29759 return resultobj;
29760 fail:
29761 return NULL;
29762 }
29763
29764
29765 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29766 PyObject *resultobj;
29767 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29768 int arg2 ;
29769 int arg3 ;
29770 wxDragResult arg4 ;
29771 wxDragResult result;
29772 PyObject * obj0 = 0 ;
29773 PyObject * obj1 = 0 ;
29774 PyObject * obj2 = 0 ;
29775 PyObject * obj3 = 0 ;
29776 char *kwnames[] = {
29777 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29778 };
29779
29780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29782 if (SWIG_arg_fail(1)) SWIG_fail;
29783 {
29784 arg2 = (int)(SWIG_As_int(obj1));
29785 if (SWIG_arg_fail(2)) SWIG_fail;
29786 }
29787 {
29788 arg3 = (int)(SWIG_As_int(obj2));
29789 if (SWIG_arg_fail(3)) SWIG_fail;
29790 }
29791 {
29792 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29793 if (SWIG_arg_fail(4)) SWIG_fail;
29794 }
29795 {
29796 PyThreadState* __tstate = wxPyBeginAllowThreads();
29797 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29798
29799 wxPyEndAllowThreads(__tstate);
29800 if (PyErr_Occurred()) SWIG_fail;
29801 }
29802 resultobj = SWIG_From_int((result));
29803 return resultobj;
29804 fail:
29805 return NULL;
29806 }
29807
29808
29809 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29810 PyObject *obj;
29811 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29812 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29813 Py_INCREF(obj);
29814 return Py_BuildValue((char *)"");
29815 }
29816 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29817 PyObject *resultobj;
29818 wxClipboard *result;
29819 char *kwnames[] = {
29820 NULL
29821 };
29822
29823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29824 {
29825 PyThreadState* __tstate = wxPyBeginAllowThreads();
29826 result = (wxClipboard *)new wxClipboard();
29827
29828 wxPyEndAllowThreads(__tstate);
29829 if (PyErr_Occurred()) SWIG_fail;
29830 }
29831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29832 return resultobj;
29833 fail:
29834 return NULL;
29835 }
29836
29837
29838 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29839 PyObject *resultobj;
29840 wxClipboard *arg1 = (wxClipboard *) 0 ;
29841 PyObject * obj0 = 0 ;
29842 char *kwnames[] = {
29843 (char *) "self", NULL
29844 };
29845
29846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29848 if (SWIG_arg_fail(1)) SWIG_fail;
29849 {
29850 PyThreadState* __tstate = wxPyBeginAllowThreads();
29851 delete arg1;
29852
29853 wxPyEndAllowThreads(__tstate);
29854 if (PyErr_Occurred()) SWIG_fail;
29855 }
29856 Py_INCREF(Py_None); resultobj = Py_None;
29857 return resultobj;
29858 fail:
29859 return NULL;
29860 }
29861
29862
29863 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29864 PyObject *resultobj;
29865 wxClipboard *arg1 = (wxClipboard *) 0 ;
29866 bool result;
29867 PyObject * obj0 = 0 ;
29868 char *kwnames[] = {
29869 (char *) "self", NULL
29870 };
29871
29872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29874 if (SWIG_arg_fail(1)) SWIG_fail;
29875 {
29876 PyThreadState* __tstate = wxPyBeginAllowThreads();
29877 result = (bool)(arg1)->Open();
29878
29879 wxPyEndAllowThreads(__tstate);
29880 if (PyErr_Occurred()) SWIG_fail;
29881 }
29882 {
29883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29884 }
29885 return resultobj;
29886 fail:
29887 return NULL;
29888 }
29889
29890
29891 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29892 PyObject *resultobj;
29893 wxClipboard *arg1 = (wxClipboard *) 0 ;
29894 PyObject * obj0 = 0 ;
29895 char *kwnames[] = {
29896 (char *) "self", NULL
29897 };
29898
29899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29901 if (SWIG_arg_fail(1)) SWIG_fail;
29902 {
29903 PyThreadState* __tstate = wxPyBeginAllowThreads();
29904 (arg1)->Close();
29905
29906 wxPyEndAllowThreads(__tstate);
29907 if (PyErr_Occurred()) SWIG_fail;
29908 }
29909 Py_INCREF(Py_None); resultobj = Py_None;
29910 return resultobj;
29911 fail:
29912 return NULL;
29913 }
29914
29915
29916 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29917 PyObject *resultobj;
29918 wxClipboard *arg1 = (wxClipboard *) 0 ;
29919 bool result;
29920 PyObject * obj0 = 0 ;
29921 char *kwnames[] = {
29922 (char *) "self", NULL
29923 };
29924
29925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29927 if (SWIG_arg_fail(1)) SWIG_fail;
29928 {
29929 PyThreadState* __tstate = wxPyBeginAllowThreads();
29930 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29931
29932 wxPyEndAllowThreads(__tstate);
29933 if (PyErr_Occurred()) SWIG_fail;
29934 }
29935 {
29936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29937 }
29938 return resultobj;
29939 fail:
29940 return NULL;
29941 }
29942
29943
29944 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29945 PyObject *resultobj;
29946 wxClipboard *arg1 = (wxClipboard *) 0 ;
29947 wxDataObject *arg2 = (wxDataObject *) 0 ;
29948 bool result;
29949 PyObject * obj0 = 0 ;
29950 PyObject * obj1 = 0 ;
29951 char *kwnames[] = {
29952 (char *) "self",(char *) "data", NULL
29953 };
29954
29955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29957 if (SWIG_arg_fail(1)) SWIG_fail;
29958 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29959 if (SWIG_arg_fail(2)) SWIG_fail;
29960 {
29961 PyThreadState* __tstate = wxPyBeginAllowThreads();
29962 result = (bool)(arg1)->AddData(arg2);
29963
29964 wxPyEndAllowThreads(__tstate);
29965 if (PyErr_Occurred()) SWIG_fail;
29966 }
29967 {
29968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29969 }
29970 return resultobj;
29971 fail:
29972 return NULL;
29973 }
29974
29975
29976 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29977 PyObject *resultobj;
29978 wxClipboard *arg1 = (wxClipboard *) 0 ;
29979 wxDataObject *arg2 = (wxDataObject *) 0 ;
29980 bool result;
29981 PyObject * obj0 = 0 ;
29982 PyObject * obj1 = 0 ;
29983 char *kwnames[] = {
29984 (char *) "self",(char *) "data", NULL
29985 };
29986
29987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29989 if (SWIG_arg_fail(1)) SWIG_fail;
29990 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29991 if (SWIG_arg_fail(2)) SWIG_fail;
29992 {
29993 PyThreadState* __tstate = wxPyBeginAllowThreads();
29994 result = (bool)(arg1)->SetData(arg2);
29995
29996 wxPyEndAllowThreads(__tstate);
29997 if (PyErr_Occurred()) SWIG_fail;
29998 }
29999 {
30000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30001 }
30002 return resultobj;
30003 fail:
30004 return NULL;
30005 }
30006
30007
30008 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
30009 PyObject *resultobj;
30010 wxClipboard *arg1 = (wxClipboard *) 0 ;
30011 wxDataFormat *arg2 = 0 ;
30012 bool result;
30013 PyObject * obj0 = 0 ;
30014 PyObject * obj1 = 0 ;
30015 char *kwnames[] = {
30016 (char *) "self",(char *) "format", NULL
30017 };
30018
30019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
30020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30021 if (SWIG_arg_fail(1)) SWIG_fail;
30022 {
30023 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
30024 if (SWIG_arg_fail(2)) SWIG_fail;
30025 if (arg2 == NULL) {
30026 SWIG_null_ref("wxDataFormat");
30027 }
30028 if (SWIG_arg_fail(2)) SWIG_fail;
30029 }
30030 {
30031 PyThreadState* __tstate = wxPyBeginAllowThreads();
30032 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
30033
30034 wxPyEndAllowThreads(__tstate);
30035 if (PyErr_Occurred()) SWIG_fail;
30036 }
30037 {
30038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30039 }
30040 return resultobj;
30041 fail:
30042 return NULL;
30043 }
30044
30045
30046 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30047 PyObject *resultobj;
30048 wxClipboard *arg1 = (wxClipboard *) 0 ;
30049 wxDataObject *arg2 = 0 ;
30050 bool result;
30051 PyObject * obj0 = 0 ;
30052 PyObject * obj1 = 0 ;
30053 char *kwnames[] = {
30054 (char *) "self",(char *) "data", NULL
30055 };
30056
30057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30059 if (SWIG_arg_fail(1)) SWIG_fail;
30060 {
30061 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30062 if (SWIG_arg_fail(2)) SWIG_fail;
30063 if (arg2 == NULL) {
30064 SWIG_null_ref("wxDataObject");
30065 }
30066 if (SWIG_arg_fail(2)) SWIG_fail;
30067 }
30068 {
30069 PyThreadState* __tstate = wxPyBeginAllowThreads();
30070 result = (bool)(arg1)->GetData(*arg2);
30071
30072 wxPyEndAllowThreads(__tstate);
30073 if (PyErr_Occurred()) SWIG_fail;
30074 }
30075 {
30076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30077 }
30078 return resultobj;
30079 fail:
30080 return NULL;
30081 }
30082
30083
30084 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30085 PyObject *resultobj;
30086 wxClipboard *arg1 = (wxClipboard *) 0 ;
30087 PyObject * obj0 = 0 ;
30088 char *kwnames[] = {
30089 (char *) "self", NULL
30090 };
30091
30092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30094 if (SWIG_arg_fail(1)) SWIG_fail;
30095 {
30096 PyThreadState* __tstate = wxPyBeginAllowThreads();
30097 (arg1)->Clear();
30098
30099 wxPyEndAllowThreads(__tstate);
30100 if (PyErr_Occurred()) SWIG_fail;
30101 }
30102 Py_INCREF(Py_None); resultobj = Py_None;
30103 return resultobj;
30104 fail:
30105 return NULL;
30106 }
30107
30108
30109 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30110 PyObject *resultobj;
30111 wxClipboard *arg1 = (wxClipboard *) 0 ;
30112 bool result;
30113 PyObject * obj0 = 0 ;
30114 char *kwnames[] = {
30115 (char *) "self", NULL
30116 };
30117
30118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30120 if (SWIG_arg_fail(1)) SWIG_fail;
30121 {
30122 PyThreadState* __tstate = wxPyBeginAllowThreads();
30123 result = (bool)(arg1)->Flush();
30124
30125 wxPyEndAllowThreads(__tstate);
30126 if (PyErr_Occurred()) SWIG_fail;
30127 }
30128 {
30129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30130 }
30131 return resultobj;
30132 fail:
30133 return NULL;
30134 }
30135
30136
30137 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30138 PyObject *resultobj;
30139 wxClipboard *arg1 = (wxClipboard *) 0 ;
30140 bool arg2 = (bool) true ;
30141 PyObject * obj0 = 0 ;
30142 PyObject * obj1 = 0 ;
30143 char *kwnames[] = {
30144 (char *) "self",(char *) "primary", NULL
30145 };
30146
30147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30149 if (SWIG_arg_fail(1)) SWIG_fail;
30150 if (obj1) {
30151 {
30152 arg2 = (bool)(SWIG_As_bool(obj1));
30153 if (SWIG_arg_fail(2)) SWIG_fail;
30154 }
30155 }
30156 {
30157 PyThreadState* __tstate = wxPyBeginAllowThreads();
30158 (arg1)->UsePrimarySelection(arg2);
30159
30160 wxPyEndAllowThreads(__tstate);
30161 if (PyErr_Occurred()) SWIG_fail;
30162 }
30163 Py_INCREF(Py_None); resultobj = Py_None;
30164 return resultobj;
30165 fail:
30166 return NULL;
30167 }
30168
30169
30170 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30171 PyObject *resultobj;
30172 wxClipboard *result;
30173 char *kwnames[] = {
30174 NULL
30175 };
30176
30177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30178 {
30179 PyThreadState* __tstate = wxPyBeginAllowThreads();
30180 result = (wxClipboard *)wxClipboard::Get();
30181
30182 wxPyEndAllowThreads(__tstate);
30183 if (PyErr_Occurred()) SWIG_fail;
30184 }
30185 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30186 return resultobj;
30187 fail:
30188 return NULL;
30189 }
30190
30191
30192 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30193 PyObject *obj;
30194 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30195 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30196 Py_INCREF(obj);
30197 return Py_BuildValue((char *)"");
30198 }
30199 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30200 PyObject *resultobj;
30201 wxClipboard *arg1 = (wxClipboard *) NULL ;
30202 wxClipboardLocker *result;
30203 PyObject * obj0 = 0 ;
30204 char *kwnames[] = {
30205 (char *) "clipboard", NULL
30206 };
30207
30208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30209 if (obj0) {
30210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30211 if (SWIG_arg_fail(1)) SWIG_fail;
30212 }
30213 {
30214 PyThreadState* __tstate = wxPyBeginAllowThreads();
30215 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30216
30217 wxPyEndAllowThreads(__tstate);
30218 if (PyErr_Occurred()) SWIG_fail;
30219 }
30220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30221 return resultobj;
30222 fail:
30223 return NULL;
30224 }
30225
30226
30227 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30228 PyObject *resultobj;
30229 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30230 PyObject * obj0 = 0 ;
30231 char *kwnames[] = {
30232 (char *) "self", NULL
30233 };
30234
30235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30237 if (SWIG_arg_fail(1)) SWIG_fail;
30238 {
30239 PyThreadState* __tstate = wxPyBeginAllowThreads();
30240 delete arg1;
30241
30242 wxPyEndAllowThreads(__tstate);
30243 if (PyErr_Occurred()) SWIG_fail;
30244 }
30245 Py_INCREF(Py_None); resultobj = Py_None;
30246 return resultobj;
30247 fail:
30248 return NULL;
30249 }
30250
30251
30252 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30253 PyObject *resultobj;
30254 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30255 bool result;
30256 PyObject * obj0 = 0 ;
30257 char *kwnames[] = {
30258 (char *) "self", NULL
30259 };
30260
30261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30263 if (SWIG_arg_fail(1)) SWIG_fail;
30264 {
30265 PyThreadState* __tstate = wxPyBeginAllowThreads();
30266 result = (bool)wxClipboardLocker___nonzero__(arg1);
30267
30268 wxPyEndAllowThreads(__tstate);
30269 if (PyErr_Occurred()) SWIG_fail;
30270 }
30271 {
30272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30273 }
30274 return resultobj;
30275 fail:
30276 return NULL;
30277 }
30278
30279
30280 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30281 PyObject *obj;
30282 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30283 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30284 Py_INCREF(obj);
30285 return Py_BuildValue((char *)"");
30286 }
30287 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30288 PyObject *resultobj;
30289 int arg1 = (int) 0 ;
30290 int arg2 = (int) 0 ;
30291 int arg3 = (int) 0 ;
30292 int arg4 = (int) 0 ;
30293 wxVideoMode *result;
30294 PyObject * obj0 = 0 ;
30295 PyObject * obj1 = 0 ;
30296 PyObject * obj2 = 0 ;
30297 PyObject * obj3 = 0 ;
30298 char *kwnames[] = {
30299 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30300 };
30301
30302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30303 if (obj0) {
30304 {
30305 arg1 = (int)(SWIG_As_int(obj0));
30306 if (SWIG_arg_fail(1)) SWIG_fail;
30307 }
30308 }
30309 if (obj1) {
30310 {
30311 arg2 = (int)(SWIG_As_int(obj1));
30312 if (SWIG_arg_fail(2)) SWIG_fail;
30313 }
30314 }
30315 if (obj2) {
30316 {
30317 arg3 = (int)(SWIG_As_int(obj2));
30318 if (SWIG_arg_fail(3)) SWIG_fail;
30319 }
30320 }
30321 if (obj3) {
30322 {
30323 arg4 = (int)(SWIG_As_int(obj3));
30324 if (SWIG_arg_fail(4)) SWIG_fail;
30325 }
30326 }
30327 {
30328 PyThreadState* __tstate = wxPyBeginAllowThreads();
30329 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30330
30331 wxPyEndAllowThreads(__tstate);
30332 if (PyErr_Occurred()) SWIG_fail;
30333 }
30334 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30335 return resultobj;
30336 fail:
30337 return NULL;
30338 }
30339
30340
30341 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30342 PyObject *resultobj;
30343 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30344 PyObject * obj0 = 0 ;
30345 char *kwnames[] = {
30346 (char *) "self", NULL
30347 };
30348
30349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30351 if (SWIG_arg_fail(1)) SWIG_fail;
30352 {
30353 PyThreadState* __tstate = wxPyBeginAllowThreads();
30354 delete arg1;
30355
30356 wxPyEndAllowThreads(__tstate);
30357 if (PyErr_Occurred()) SWIG_fail;
30358 }
30359 Py_INCREF(Py_None); resultobj = Py_None;
30360 return resultobj;
30361 fail:
30362 return NULL;
30363 }
30364
30365
30366 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30367 PyObject *resultobj;
30368 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30369 wxVideoMode *arg2 = 0 ;
30370 bool result;
30371 PyObject * obj0 = 0 ;
30372 PyObject * obj1 = 0 ;
30373 char *kwnames[] = {
30374 (char *) "self",(char *) "other", NULL
30375 };
30376
30377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30379 if (SWIG_arg_fail(1)) SWIG_fail;
30380 {
30381 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30382 if (SWIG_arg_fail(2)) SWIG_fail;
30383 if (arg2 == NULL) {
30384 SWIG_null_ref("wxVideoMode");
30385 }
30386 if (SWIG_arg_fail(2)) SWIG_fail;
30387 }
30388 {
30389 PyThreadState* __tstate = wxPyBeginAllowThreads();
30390 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30391
30392 wxPyEndAllowThreads(__tstate);
30393 if (PyErr_Occurred()) SWIG_fail;
30394 }
30395 {
30396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30397 }
30398 return resultobj;
30399 fail:
30400 return NULL;
30401 }
30402
30403
30404 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30405 PyObject *resultobj;
30406 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30407 int result;
30408 PyObject * obj0 = 0 ;
30409 char *kwnames[] = {
30410 (char *) "self", NULL
30411 };
30412
30413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30415 if (SWIG_arg_fail(1)) SWIG_fail;
30416 {
30417 PyThreadState* __tstate = wxPyBeginAllowThreads();
30418 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30419
30420 wxPyEndAllowThreads(__tstate);
30421 if (PyErr_Occurred()) SWIG_fail;
30422 }
30423 {
30424 resultobj = SWIG_From_int((int)(result));
30425 }
30426 return resultobj;
30427 fail:
30428 return NULL;
30429 }
30430
30431
30432 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30433 PyObject *resultobj;
30434 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30435 int result;
30436 PyObject * obj0 = 0 ;
30437 char *kwnames[] = {
30438 (char *) "self", NULL
30439 };
30440
30441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30443 if (SWIG_arg_fail(1)) SWIG_fail;
30444 {
30445 PyThreadState* __tstate = wxPyBeginAllowThreads();
30446 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30447
30448 wxPyEndAllowThreads(__tstate);
30449 if (PyErr_Occurred()) SWIG_fail;
30450 }
30451 {
30452 resultobj = SWIG_From_int((int)(result));
30453 }
30454 return resultobj;
30455 fail:
30456 return NULL;
30457 }
30458
30459
30460 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30461 PyObject *resultobj;
30462 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30463 int result;
30464 PyObject * obj0 = 0 ;
30465 char *kwnames[] = {
30466 (char *) "self", NULL
30467 };
30468
30469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30471 if (SWIG_arg_fail(1)) SWIG_fail;
30472 {
30473 PyThreadState* __tstate = wxPyBeginAllowThreads();
30474 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30475
30476 wxPyEndAllowThreads(__tstate);
30477 if (PyErr_Occurred()) SWIG_fail;
30478 }
30479 {
30480 resultobj = SWIG_From_int((int)(result));
30481 }
30482 return resultobj;
30483 fail:
30484 return NULL;
30485 }
30486
30487
30488 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30489 PyObject *resultobj;
30490 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30491 bool result;
30492 PyObject * obj0 = 0 ;
30493 char *kwnames[] = {
30494 (char *) "self", NULL
30495 };
30496
30497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30499 if (SWIG_arg_fail(1)) SWIG_fail;
30500 {
30501 PyThreadState* __tstate = wxPyBeginAllowThreads();
30502 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30503
30504 wxPyEndAllowThreads(__tstate);
30505 if (PyErr_Occurred()) SWIG_fail;
30506 }
30507 {
30508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30509 }
30510 return resultobj;
30511 fail:
30512 return NULL;
30513 }
30514
30515
30516 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30517 PyObject *resultobj;
30518 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30519 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30520 bool result;
30521 PyObject * obj0 = 0 ;
30522 PyObject * obj1 = 0 ;
30523 char *kwnames[] = {
30524 (char *) "self",(char *) "other", NULL
30525 };
30526
30527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30529 if (SWIG_arg_fail(1)) SWIG_fail;
30530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30531 if (SWIG_arg_fail(2)) SWIG_fail;
30532 {
30533 PyThreadState* __tstate = wxPyBeginAllowThreads();
30534 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30535
30536 wxPyEndAllowThreads(__tstate);
30537 if (PyErr_Occurred()) SWIG_fail;
30538 }
30539 {
30540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30541 }
30542 return resultobj;
30543 fail:
30544 return NULL;
30545 }
30546
30547
30548 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30549 PyObject *resultobj;
30550 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30551 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30552 bool result;
30553 PyObject * obj0 = 0 ;
30554 PyObject * obj1 = 0 ;
30555 char *kwnames[] = {
30556 (char *) "self",(char *) "other", NULL
30557 };
30558
30559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30561 if (SWIG_arg_fail(1)) SWIG_fail;
30562 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30563 if (SWIG_arg_fail(2)) SWIG_fail;
30564 {
30565 PyThreadState* __tstate = wxPyBeginAllowThreads();
30566 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30567
30568 wxPyEndAllowThreads(__tstate);
30569 if (PyErr_Occurred()) SWIG_fail;
30570 }
30571 {
30572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30573 }
30574 return resultobj;
30575 fail:
30576 return NULL;
30577 }
30578
30579
30580 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30581 PyObject *resultobj;
30582 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30583 int arg2 ;
30584 PyObject * obj0 = 0 ;
30585 PyObject * obj1 = 0 ;
30586 char *kwnames[] = {
30587 (char *) "self",(char *) "w", NULL
30588 };
30589
30590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30592 if (SWIG_arg_fail(1)) SWIG_fail;
30593 {
30594 arg2 = (int)(SWIG_As_int(obj1));
30595 if (SWIG_arg_fail(2)) SWIG_fail;
30596 }
30597 if (arg1) (arg1)->w = arg2;
30598
30599 Py_INCREF(Py_None); resultobj = Py_None;
30600 return resultobj;
30601 fail:
30602 return NULL;
30603 }
30604
30605
30606 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30607 PyObject *resultobj;
30608 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30609 int result;
30610 PyObject * obj0 = 0 ;
30611 char *kwnames[] = {
30612 (char *) "self", NULL
30613 };
30614
30615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30617 if (SWIG_arg_fail(1)) SWIG_fail;
30618 result = (int) ((arg1)->w);
30619
30620 {
30621 resultobj = SWIG_From_int((int)(result));
30622 }
30623 return resultobj;
30624 fail:
30625 return NULL;
30626 }
30627
30628
30629 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30630 PyObject *resultobj;
30631 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30632 int arg2 ;
30633 PyObject * obj0 = 0 ;
30634 PyObject * obj1 = 0 ;
30635 char *kwnames[] = {
30636 (char *) "self",(char *) "h", NULL
30637 };
30638
30639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30641 if (SWIG_arg_fail(1)) SWIG_fail;
30642 {
30643 arg2 = (int)(SWIG_As_int(obj1));
30644 if (SWIG_arg_fail(2)) SWIG_fail;
30645 }
30646 if (arg1) (arg1)->h = arg2;
30647
30648 Py_INCREF(Py_None); resultobj = Py_None;
30649 return resultobj;
30650 fail:
30651 return NULL;
30652 }
30653
30654
30655 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30656 PyObject *resultobj;
30657 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30658 int result;
30659 PyObject * obj0 = 0 ;
30660 char *kwnames[] = {
30661 (char *) "self", NULL
30662 };
30663
30664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30666 if (SWIG_arg_fail(1)) SWIG_fail;
30667 result = (int) ((arg1)->h);
30668
30669 {
30670 resultobj = SWIG_From_int((int)(result));
30671 }
30672 return resultobj;
30673 fail:
30674 return NULL;
30675 }
30676
30677
30678 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30679 PyObject *resultobj;
30680 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30681 int arg2 ;
30682 PyObject * obj0 = 0 ;
30683 PyObject * obj1 = 0 ;
30684 char *kwnames[] = {
30685 (char *) "self",(char *) "bpp", NULL
30686 };
30687
30688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30690 if (SWIG_arg_fail(1)) SWIG_fail;
30691 {
30692 arg2 = (int)(SWIG_As_int(obj1));
30693 if (SWIG_arg_fail(2)) SWIG_fail;
30694 }
30695 if (arg1) (arg1)->bpp = arg2;
30696
30697 Py_INCREF(Py_None); resultobj = Py_None;
30698 return resultobj;
30699 fail:
30700 return NULL;
30701 }
30702
30703
30704 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30705 PyObject *resultobj;
30706 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30707 int result;
30708 PyObject * obj0 = 0 ;
30709 char *kwnames[] = {
30710 (char *) "self", NULL
30711 };
30712
30713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30715 if (SWIG_arg_fail(1)) SWIG_fail;
30716 result = (int) ((arg1)->bpp);
30717
30718 {
30719 resultobj = SWIG_From_int((int)(result));
30720 }
30721 return resultobj;
30722 fail:
30723 return NULL;
30724 }
30725
30726
30727 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30728 PyObject *resultobj;
30729 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30730 int arg2 ;
30731 PyObject * obj0 = 0 ;
30732 PyObject * obj1 = 0 ;
30733 char *kwnames[] = {
30734 (char *) "self",(char *) "refresh", NULL
30735 };
30736
30737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30739 if (SWIG_arg_fail(1)) SWIG_fail;
30740 {
30741 arg2 = (int)(SWIG_As_int(obj1));
30742 if (SWIG_arg_fail(2)) SWIG_fail;
30743 }
30744 if (arg1) (arg1)->refresh = arg2;
30745
30746 Py_INCREF(Py_None); resultobj = Py_None;
30747 return resultobj;
30748 fail:
30749 return NULL;
30750 }
30751
30752
30753 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30754 PyObject *resultobj;
30755 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30756 int result;
30757 PyObject * obj0 = 0 ;
30758 char *kwnames[] = {
30759 (char *) "self", NULL
30760 };
30761
30762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30764 if (SWIG_arg_fail(1)) SWIG_fail;
30765 result = (int) ((arg1)->refresh);
30766
30767 {
30768 resultobj = SWIG_From_int((int)(result));
30769 }
30770 return resultobj;
30771 fail:
30772 return NULL;
30773 }
30774
30775
30776 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30777 PyObject *obj;
30778 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30779 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30780 Py_INCREF(obj);
30781 return Py_BuildValue((char *)"");
30782 }
30783 static int _wrap_DefaultVideoMode_set(PyObject *) {
30784 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30785 return 1;
30786 }
30787
30788
30789 static PyObject *_wrap_DefaultVideoMode_get(void) {
30790 PyObject *pyobj;
30791
30792 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30793 return pyobj;
30794 }
30795
30796
30797 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30798 PyObject *resultobj;
30799 size_t arg1 = (size_t) 0 ;
30800 wxDisplay *result;
30801 PyObject * obj0 = 0 ;
30802 char *kwnames[] = {
30803 (char *) "index", NULL
30804 };
30805
30806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30807 if (obj0) {
30808 {
30809 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30810 if (SWIG_arg_fail(1)) SWIG_fail;
30811 }
30812 }
30813 {
30814 PyThreadState* __tstate = wxPyBeginAllowThreads();
30815 result = (wxDisplay *)new wxDisplay(arg1);
30816
30817 wxPyEndAllowThreads(__tstate);
30818 if (PyErr_Occurred()) SWIG_fail;
30819 }
30820 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30821 return resultobj;
30822 fail:
30823 return NULL;
30824 }
30825
30826
30827 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30828 PyObject *resultobj;
30829 wxDisplay *arg1 = (wxDisplay *) 0 ;
30830 PyObject * obj0 = 0 ;
30831 char *kwnames[] = {
30832 (char *) "self", NULL
30833 };
30834
30835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30837 if (SWIG_arg_fail(1)) SWIG_fail;
30838 {
30839 PyThreadState* __tstate = wxPyBeginAllowThreads();
30840 delete arg1;
30841
30842 wxPyEndAllowThreads(__tstate);
30843 if (PyErr_Occurred()) SWIG_fail;
30844 }
30845 Py_INCREF(Py_None); resultobj = Py_None;
30846 return resultobj;
30847 fail:
30848 return NULL;
30849 }
30850
30851
30852 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30853 PyObject *resultobj;
30854 size_t result;
30855 char *kwnames[] = {
30856 NULL
30857 };
30858
30859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30860 {
30861 PyThreadState* __tstate = wxPyBeginAllowThreads();
30862 result = (size_t)wxDisplay::GetCount();
30863
30864 wxPyEndAllowThreads(__tstate);
30865 if (PyErr_Occurred()) SWIG_fail;
30866 }
30867 {
30868 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30869 }
30870 return resultobj;
30871 fail:
30872 return NULL;
30873 }
30874
30875
30876 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30877 PyObject *resultobj;
30878 wxPoint *arg1 = 0 ;
30879 int result;
30880 wxPoint temp1 ;
30881 PyObject * obj0 = 0 ;
30882 char *kwnames[] = {
30883 (char *) "pt", NULL
30884 };
30885
30886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30887 {
30888 arg1 = &temp1;
30889 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30890 }
30891 {
30892 PyThreadState* __tstate = wxPyBeginAllowThreads();
30893 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30894
30895 wxPyEndAllowThreads(__tstate);
30896 if (PyErr_Occurred()) SWIG_fail;
30897 }
30898 {
30899 resultobj = SWIG_From_int((int)(result));
30900 }
30901 return resultobj;
30902 fail:
30903 return NULL;
30904 }
30905
30906
30907 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30908 PyObject *resultobj;
30909 wxWindow *arg1 = (wxWindow *) 0 ;
30910 int result;
30911 PyObject * obj0 = 0 ;
30912 char *kwnames[] = {
30913 (char *) "window", NULL
30914 };
30915
30916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30918 if (SWIG_arg_fail(1)) SWIG_fail;
30919 {
30920 PyThreadState* __tstate = wxPyBeginAllowThreads();
30921 result = (int)Display_GetFromWindow(arg1);
30922
30923 wxPyEndAllowThreads(__tstate);
30924 if (PyErr_Occurred()) SWIG_fail;
30925 }
30926 {
30927 resultobj = SWIG_From_int((int)(result));
30928 }
30929 return resultobj;
30930 fail:
30931 return NULL;
30932 }
30933
30934
30935 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30936 PyObject *resultobj;
30937 wxDisplay *arg1 = (wxDisplay *) 0 ;
30938 bool result;
30939 PyObject * obj0 = 0 ;
30940 char *kwnames[] = {
30941 (char *) "self", NULL
30942 };
30943
30944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30946 if (SWIG_arg_fail(1)) SWIG_fail;
30947 {
30948 PyThreadState* __tstate = wxPyBeginAllowThreads();
30949 result = (bool)((wxDisplay const *)arg1)->IsOk();
30950
30951 wxPyEndAllowThreads(__tstate);
30952 if (PyErr_Occurred()) SWIG_fail;
30953 }
30954 {
30955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30956 }
30957 return resultobj;
30958 fail:
30959 return NULL;
30960 }
30961
30962
30963 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30964 PyObject *resultobj;
30965 wxDisplay *arg1 = (wxDisplay *) 0 ;
30966 wxRect result;
30967 PyObject * obj0 = 0 ;
30968 char *kwnames[] = {
30969 (char *) "self", NULL
30970 };
30971
30972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30974 if (SWIG_arg_fail(1)) SWIG_fail;
30975 {
30976 PyThreadState* __tstate = wxPyBeginAllowThreads();
30977 result = ((wxDisplay const *)arg1)->GetGeometry();
30978
30979 wxPyEndAllowThreads(__tstate);
30980 if (PyErr_Occurred()) SWIG_fail;
30981 }
30982 {
30983 wxRect * resultptr;
30984 resultptr = new wxRect((wxRect &)(result));
30985 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30986 }
30987 return resultobj;
30988 fail:
30989 return NULL;
30990 }
30991
30992
30993 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30994 PyObject *resultobj;
30995 wxDisplay *arg1 = (wxDisplay *) 0 ;
30996 wxString result;
30997 PyObject * obj0 = 0 ;
30998 char *kwnames[] = {
30999 (char *) "self", NULL
31000 };
31001
31002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
31003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31004 if (SWIG_arg_fail(1)) SWIG_fail;
31005 {
31006 PyThreadState* __tstate = wxPyBeginAllowThreads();
31007 result = ((wxDisplay const *)arg1)->GetName();
31008
31009 wxPyEndAllowThreads(__tstate);
31010 if (PyErr_Occurred()) SWIG_fail;
31011 }
31012 {
31013 #if wxUSE_UNICODE
31014 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31015 #else
31016 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31017 #endif
31018 }
31019 return resultobj;
31020 fail:
31021 return NULL;
31022 }
31023
31024
31025 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
31026 PyObject *resultobj;
31027 wxDisplay *arg1 = (wxDisplay *) 0 ;
31028 bool result;
31029 PyObject * obj0 = 0 ;
31030 char *kwnames[] = {
31031 (char *) "self", NULL
31032 };
31033
31034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
31035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31036 if (SWIG_arg_fail(1)) SWIG_fail;
31037 {
31038 PyThreadState* __tstate = wxPyBeginAllowThreads();
31039 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
31040
31041 wxPyEndAllowThreads(__tstate);
31042 if (PyErr_Occurred()) SWIG_fail;
31043 }
31044 {
31045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31046 }
31047 return resultobj;
31048 fail:
31049 return NULL;
31050 }
31051
31052
31053 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31054 PyObject *resultobj;
31055 wxDisplay *arg1 = (wxDisplay *) 0 ;
31056 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31057 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31058 PyObject *result;
31059 PyObject * obj0 = 0 ;
31060 PyObject * obj1 = 0 ;
31061 char *kwnames[] = {
31062 (char *) "self",(char *) "mode", NULL
31063 };
31064
31065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31067 if (SWIG_arg_fail(1)) SWIG_fail;
31068 if (obj1) {
31069 {
31070 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31071 if (SWIG_arg_fail(2)) SWIG_fail;
31072 if (arg2 == NULL) {
31073 SWIG_null_ref("wxVideoMode");
31074 }
31075 if (SWIG_arg_fail(2)) SWIG_fail;
31076 }
31077 }
31078 {
31079 PyThreadState* __tstate = wxPyBeginAllowThreads();
31080 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31081
31082 wxPyEndAllowThreads(__tstate);
31083 if (PyErr_Occurred()) SWIG_fail;
31084 }
31085 resultobj = result;
31086 return resultobj;
31087 fail:
31088 return NULL;
31089 }
31090
31091
31092 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31093 PyObject *resultobj;
31094 wxDisplay *arg1 = (wxDisplay *) 0 ;
31095 wxVideoMode result;
31096 PyObject * obj0 = 0 ;
31097 char *kwnames[] = {
31098 (char *) "self", NULL
31099 };
31100
31101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31103 if (SWIG_arg_fail(1)) SWIG_fail;
31104 {
31105 PyThreadState* __tstate = wxPyBeginAllowThreads();
31106 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31107
31108 wxPyEndAllowThreads(__tstate);
31109 if (PyErr_Occurred()) SWIG_fail;
31110 }
31111 {
31112 wxVideoMode * resultptr;
31113 resultptr = new wxVideoMode((wxVideoMode &)(result));
31114 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31115 }
31116 return resultobj;
31117 fail:
31118 return NULL;
31119 }
31120
31121
31122 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31123 PyObject *resultobj;
31124 wxDisplay *arg1 = (wxDisplay *) 0 ;
31125 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31126 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31127 bool result;
31128 PyObject * obj0 = 0 ;
31129 PyObject * obj1 = 0 ;
31130 char *kwnames[] = {
31131 (char *) "self",(char *) "mode", NULL
31132 };
31133
31134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) 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 if (obj1) {
31138 {
31139 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31140 if (SWIG_arg_fail(2)) SWIG_fail;
31141 if (arg2 == NULL) {
31142 SWIG_null_ref("wxVideoMode");
31143 }
31144 if (SWIG_arg_fail(2)) SWIG_fail;
31145 }
31146 }
31147 {
31148 PyThreadState* __tstate = wxPyBeginAllowThreads();
31149 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31150
31151 wxPyEndAllowThreads(__tstate);
31152 if (PyErr_Occurred()) SWIG_fail;
31153 }
31154 {
31155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31156 }
31157 return resultobj;
31158 fail:
31159 return NULL;
31160 }
31161
31162
31163 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31164 PyObject *resultobj;
31165 wxDisplay *arg1 = (wxDisplay *) 0 ;
31166 PyObject * obj0 = 0 ;
31167 char *kwnames[] = {
31168 (char *) "self", NULL
31169 };
31170
31171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31173 if (SWIG_arg_fail(1)) SWIG_fail;
31174 {
31175 PyThreadState* __tstate = wxPyBeginAllowThreads();
31176 (arg1)->ResetMode();
31177
31178 wxPyEndAllowThreads(__tstate);
31179 if (PyErr_Occurred()) SWIG_fail;
31180 }
31181 Py_INCREF(Py_None); resultobj = Py_None;
31182 return resultobj;
31183 fail:
31184 return NULL;
31185 }
31186
31187
31188 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31189 PyObject *obj;
31190 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31191 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31192 Py_INCREF(obj);
31193 return Py_BuildValue((char *)"");
31194 }
31195 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31196 PyObject *resultobj;
31197 wxStandardPaths *result;
31198 char *kwnames[] = {
31199 NULL
31200 };
31201
31202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31203 {
31204 PyThreadState* __tstate = wxPyBeginAllowThreads();
31205 result = (wxStandardPaths *)StandardPaths_Get();
31206
31207 wxPyEndAllowThreads(__tstate);
31208 if (PyErr_Occurred()) SWIG_fail;
31209 }
31210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31211 return resultobj;
31212 fail:
31213 return NULL;
31214 }
31215
31216
31217 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31218 PyObject *resultobj;
31219 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31220 wxString result;
31221 PyObject * obj0 = 0 ;
31222 char *kwnames[] = {
31223 (char *) "self", NULL
31224 };
31225
31226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31228 if (SWIG_arg_fail(1)) SWIG_fail;
31229 {
31230 PyThreadState* __tstate = wxPyBeginAllowThreads();
31231 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31232
31233 wxPyEndAllowThreads(__tstate);
31234 if (PyErr_Occurred()) SWIG_fail;
31235 }
31236 {
31237 #if wxUSE_UNICODE
31238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31239 #else
31240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31241 #endif
31242 }
31243 return resultobj;
31244 fail:
31245 return NULL;
31246 }
31247
31248
31249 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31250 PyObject *resultobj;
31251 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31252 wxString result;
31253 PyObject * obj0 = 0 ;
31254 char *kwnames[] = {
31255 (char *) "self", NULL
31256 };
31257
31258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31260 if (SWIG_arg_fail(1)) SWIG_fail;
31261 {
31262 PyThreadState* __tstate = wxPyBeginAllowThreads();
31263 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31264
31265 wxPyEndAllowThreads(__tstate);
31266 if (PyErr_Occurred()) SWIG_fail;
31267 }
31268 {
31269 #if wxUSE_UNICODE
31270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31271 #else
31272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31273 #endif
31274 }
31275 return resultobj;
31276 fail:
31277 return NULL;
31278 }
31279
31280
31281 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31282 PyObject *resultobj;
31283 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31284 wxString result;
31285 PyObject * obj0 = 0 ;
31286 char *kwnames[] = {
31287 (char *) "self", NULL
31288 };
31289
31290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31292 if (SWIG_arg_fail(1)) SWIG_fail;
31293 {
31294 PyThreadState* __tstate = wxPyBeginAllowThreads();
31295 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31296
31297 wxPyEndAllowThreads(__tstate);
31298 if (PyErr_Occurred()) SWIG_fail;
31299 }
31300 {
31301 #if wxUSE_UNICODE
31302 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31303 #else
31304 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31305 #endif
31306 }
31307 return resultobj;
31308 fail:
31309 return NULL;
31310 }
31311
31312
31313 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31314 PyObject *resultobj;
31315 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31316 wxString result;
31317 PyObject * obj0 = 0 ;
31318 char *kwnames[] = {
31319 (char *) "self", NULL
31320 };
31321
31322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31324 if (SWIG_arg_fail(1)) SWIG_fail;
31325 {
31326 PyThreadState* __tstate = wxPyBeginAllowThreads();
31327 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31328
31329 wxPyEndAllowThreads(__tstate);
31330 if (PyErr_Occurred()) SWIG_fail;
31331 }
31332 {
31333 #if wxUSE_UNICODE
31334 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31335 #else
31336 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31337 #endif
31338 }
31339 return resultobj;
31340 fail:
31341 return NULL;
31342 }
31343
31344
31345 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31346 PyObject *resultobj;
31347 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31348 wxString result;
31349 PyObject * obj0 = 0 ;
31350 char *kwnames[] = {
31351 (char *) "self", NULL
31352 };
31353
31354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31356 if (SWIG_arg_fail(1)) SWIG_fail;
31357 {
31358 PyThreadState* __tstate = wxPyBeginAllowThreads();
31359 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31360
31361 wxPyEndAllowThreads(__tstate);
31362 if (PyErr_Occurred()) SWIG_fail;
31363 }
31364 {
31365 #if wxUSE_UNICODE
31366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31367 #else
31368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31369 #endif
31370 }
31371 return resultobj;
31372 fail:
31373 return NULL;
31374 }
31375
31376
31377 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31378 PyObject *resultobj;
31379 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31380 wxString result;
31381 PyObject * obj0 = 0 ;
31382 char *kwnames[] = {
31383 (char *) "self", NULL
31384 };
31385
31386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31388 if (SWIG_arg_fail(1)) SWIG_fail;
31389 {
31390 PyThreadState* __tstate = wxPyBeginAllowThreads();
31391 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31392
31393 wxPyEndAllowThreads(__tstate);
31394 if (PyErr_Occurred()) SWIG_fail;
31395 }
31396 {
31397 #if wxUSE_UNICODE
31398 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31399 #else
31400 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31401 #endif
31402 }
31403 return resultobj;
31404 fail:
31405 return NULL;
31406 }
31407
31408
31409 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31410 PyObject *resultobj;
31411 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31412 wxString result;
31413 PyObject * obj0 = 0 ;
31414 char *kwnames[] = {
31415 (char *) "self", NULL
31416 };
31417
31418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31420 if (SWIG_arg_fail(1)) SWIG_fail;
31421 {
31422 PyThreadState* __tstate = wxPyBeginAllowThreads();
31423 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31424
31425 wxPyEndAllowThreads(__tstate);
31426 if (PyErr_Occurred()) SWIG_fail;
31427 }
31428 {
31429 #if wxUSE_UNICODE
31430 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31431 #else
31432 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31433 #endif
31434 }
31435 return resultobj;
31436 fail:
31437 return NULL;
31438 }
31439
31440
31441 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31442 PyObject *resultobj;
31443 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31444 wxString *arg2 = 0 ;
31445 bool temp2 = false ;
31446 PyObject * obj0 = 0 ;
31447 PyObject * obj1 = 0 ;
31448 char *kwnames[] = {
31449 (char *) "self",(char *) "prefix", NULL
31450 };
31451
31452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31454 if (SWIG_arg_fail(1)) SWIG_fail;
31455 {
31456 arg2 = wxString_in_helper(obj1);
31457 if (arg2 == NULL) SWIG_fail;
31458 temp2 = true;
31459 }
31460 {
31461 PyThreadState* __tstate = wxPyBeginAllowThreads();
31462 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31463
31464 wxPyEndAllowThreads(__tstate);
31465 if (PyErr_Occurred()) SWIG_fail;
31466 }
31467 Py_INCREF(Py_None); resultobj = Py_None;
31468 {
31469 if (temp2)
31470 delete arg2;
31471 }
31472 return resultobj;
31473 fail:
31474 {
31475 if (temp2)
31476 delete arg2;
31477 }
31478 return NULL;
31479 }
31480
31481
31482 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31483 PyObject *resultobj;
31484 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31485 wxString result;
31486 PyObject * obj0 = 0 ;
31487 char *kwnames[] = {
31488 (char *) "self", NULL
31489 };
31490
31491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31493 if (SWIG_arg_fail(1)) SWIG_fail;
31494 {
31495 PyThreadState* __tstate = wxPyBeginAllowThreads();
31496 result = wxStandardPaths_GetInstallPrefix(arg1);
31497
31498 wxPyEndAllowThreads(__tstate);
31499 if (PyErr_Occurred()) SWIG_fail;
31500 }
31501 {
31502 #if wxUSE_UNICODE
31503 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31504 #else
31505 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31506 #endif
31507 }
31508 return resultobj;
31509 fail:
31510 return NULL;
31511 }
31512
31513
31514 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31515 PyObject *obj;
31516 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31517 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31518 Py_INCREF(obj);
31519 return Py_BuildValue((char *)"");
31520 }
31521 static PyMethodDef SwigMethods[] = {
31522 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31529 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31537 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31602 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31610 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31628 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31631 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31634 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31637 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31643 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31657 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31663 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31669 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31672 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31686 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31689 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31690 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31693 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31720 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31722 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31724 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31726 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31733 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31739 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31753 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31757 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31760 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31777 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31785 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31832 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31850 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31860 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31876 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31892 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31906 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31916 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31959 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31962 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31965 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31969 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32062 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32063 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32064 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32065 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32082 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32127 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32161 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32169 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32170 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32175 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32184 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32191 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32194 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32197 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32201 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32202 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32205 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32209 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32212 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32215 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32216 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32217 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32221 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32225 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32229 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32231 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32236 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32239 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32243 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32244 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32245 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32247 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32249 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32250 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32251 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32252 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32253 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32256 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32257 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32258 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32259 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32260 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32261 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32262 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32263 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32264 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32265 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32267 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32268 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32271 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32272 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32273 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32274 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32275 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32276 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32277 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32278 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32279 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32280 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32281 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32282 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32283 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32284 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32285 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32286 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32287 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32288 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32289 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32290 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32291 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32292 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32293 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32294 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32295 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32296 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32297 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32298 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32299 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32300 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32301 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32302 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32303 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32304 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32305 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32306 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32307 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32308 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32309 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32310 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32311 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32312 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32313 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32314 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32315 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32316 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32317 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32318 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32319 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32320 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32321 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32322 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32323 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32324 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32325 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32326 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32327 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32328 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32329 { NULL, NULL, 0, NULL }
32330 };
32331
32332
32333 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32334
32335 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32336 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32337 }
32338 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32339 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32340 }
32341 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32342 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32343 }
32344 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32345 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32346 }
32347 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32348 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32349 }
32350 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32351 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32352 }
32353 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32354 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32355 }
32356 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32357 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32358 }
32359 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32360 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32361 }
32362 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32363 return (void *)((wxEvent *) ((wxPyEvent *) x));
32364 }
32365 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32366 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32367 }
32368 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32369 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32370 }
32371 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32372 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32373 }
32374 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32375 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32376 }
32377 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32378 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32379 }
32380 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32381 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32382 }
32383 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32384 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32385 }
32386 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32387 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32388 }
32389 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32390 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32391 }
32392 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32393 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32394 }
32395 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32396 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32397 }
32398 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32399 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32400 }
32401 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32402 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32403 }
32404 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32405 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32406 }
32407 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32408 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32409 }
32410 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32411 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32412 }
32413 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32414 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32415 }
32416 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32417 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32418 }
32419 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32420 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32421 }
32422 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32423 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32424 }
32425 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32426 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32427 }
32428 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32429 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32430 }
32431 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32432 return (void *)((wxEvent *) ((wxShowEvent *) x));
32433 }
32434 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32435 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32436 }
32437 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32438 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32439 }
32440 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32441 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32442 }
32443 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32444 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32445 }
32446 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32447 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32448 }
32449 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32450 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32451 }
32452 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32453 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32454 }
32455 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32456 return (void *)((wxConfigBase *) ((wxConfig *) x));
32457 }
32458 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32459 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32460 }
32461 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32462 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32463 }
32464 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32465 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32466 }
32467 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32468 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32469 }
32470 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32471 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32472 }
32473 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32474 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32475 }
32476 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32477 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32478 }
32479 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32480 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32481 }
32482 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32483 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32484 }
32485 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32486 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32487 }
32488 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32489 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32490 }
32491 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32492 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32493 }
32494 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32495 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32496 }
32497 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32498 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32499 }
32500 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32501 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32502 }
32503 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32504 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32505 }
32506 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32507 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32508 }
32509 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32510 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32511 }
32512 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32513 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32514 }
32515 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32516 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32517 }
32518 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32519 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32520 }
32521 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32522 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32523 }
32524 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32525 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32526 }
32527 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32528 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32529 }
32530 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32531 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32532 }
32533 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32534 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32535 }
32536 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32537 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32538 }
32539 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32540 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32541 }
32542 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32543 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32544 }
32545 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32546 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32547 }
32548 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32549 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32550 }
32551 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32552 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32553 }
32554 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32555 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32556 }
32557 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32558 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32559 }
32560 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32561 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32562 }
32563 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32564 return (void *)((wxObject *) ((wxSizerItem *) x));
32565 }
32566 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32567 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32568 }
32569 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32570 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32571 }
32572 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32573 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32574 }
32575 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32576 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32577 }
32578 static void *_p_wxSizerTo_p_wxObject(void *x) {
32579 return (void *)((wxObject *) ((wxSizer *) x));
32580 }
32581 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32582 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32583 }
32584 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32585 return (void *)((wxObject *) ((wxFileHistory *) x));
32586 }
32587 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32588 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32589 }
32590 static void *_p_wxEventTo_p_wxObject(void *x) {
32591 return (void *)((wxObject *) ((wxEvent *) x));
32592 }
32593 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32594 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32595 }
32596 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32597 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32598 }
32599 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32600 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32601 }
32602 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32603 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32604 }
32605 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32606 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32607 }
32608 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32609 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32610 }
32611 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32612 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32613 }
32614 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32615 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32616 }
32617 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32618 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32619 }
32620 static void *_p_wxControlTo_p_wxObject(void *x) {
32621 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32622 }
32623 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32624 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32625 }
32626 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32627 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32628 }
32629 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32630 return (void *)((wxObject *) ((wxFSFile *) x));
32631 }
32632 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32633 return (void *)((wxObject *) ((wxClipboard *) x));
32634 }
32635 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32636 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32637 }
32638 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32639 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32640 }
32641 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32642 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32643 }
32644 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32645 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32646 }
32647 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32648 return (void *)((wxObject *) ((wxToolTip *) x));
32649 }
32650 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32651 return (void *)((wxObject *) ((wxMenuItem *) x));
32652 }
32653 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32654 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32655 }
32656 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32657 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32658 }
32659 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32660 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32661 }
32662 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32663 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32664 }
32665 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32666 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32667 }
32668 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32669 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32670 }
32671 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32672 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32673 }
32674 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32675 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32676 }
32677 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32678 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32679 }
32680 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32681 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32682 }
32683 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32684 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32685 }
32686 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32687 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32688 }
32689 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32690 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32691 }
32692 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32693 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32694 }
32695 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32696 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32697 }
32698 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32699 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32700 }
32701 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32702 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32703 }
32704 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32705 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32706 }
32707 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32708 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32709 }
32710 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32711 return (void *)((wxObject *) ((wxImageHandler *) x));
32712 }
32713 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32714 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32715 }
32716 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32717 return (void *)((wxObject *) ((wxEvtHandler *) x));
32718 }
32719 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32720 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32721 }
32722 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32723 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32724 }
32725 static void *_p_wxImageTo_p_wxObject(void *x) {
32726 return (void *)((wxObject *) ((wxImage *) x));
32727 }
32728 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32729 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32730 }
32731 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32732 return (void *)((wxObject *) ((wxSystemOptions *) x));
32733 }
32734 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32735 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32736 }
32737 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32738 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32739 }
32740 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32741 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32742 }
32743 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32744 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32745 }
32746 static void *_p_wxWindowTo_p_wxObject(void *x) {
32747 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32748 }
32749 static void *_p_wxMenuTo_p_wxObject(void *x) {
32750 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32751 }
32752 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32753 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32754 }
32755 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32756 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32757 }
32758 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32759 return (void *)((wxObject *) ((wxFileSystem *) x));
32760 }
32761 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32762 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32763 }
32764 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32765 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32766 }
32767 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32768 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32769 }
32770 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32771 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32772 }
32773 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32774 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32775 }
32776 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32777 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32778 }
32779 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32780 return (void *)((wxObject *) ((wxBusyInfo *) x));
32781 }
32782 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32783 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32784 }
32785 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32786 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32787 }
32788 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32789 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32790 }
32791 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32792 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32793 }
32794 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32795 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32796 }
32797 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32798 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32799 }
32800 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32801 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32802 }
32803 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32804 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32805 }
32806 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32807 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32808 }
32809 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32810 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32811 }
32812 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32813 return (void *)((wxLog *) ((wxLogStderr *) x));
32814 }
32815 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32816 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32817 }
32818 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32819 return (void *)((wxLog *) ((wxLogWindow *) x));
32820 }
32821 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32822 return (void *)((wxLog *) ((wxLogChain *) x));
32823 }
32824 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32825 return (void *)((wxLog *) ((wxLogGui *) x));
32826 }
32827 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32828 return (void *)((wxLog *) ((wxPyLog *) x));
32829 }
32830 static void *_p_wxControlTo_p_wxWindow(void *x) {
32831 return (void *)((wxWindow *) ((wxControl *) x));
32832 }
32833 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32834 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32835 }
32836 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32837 return (void *)((wxWindow *) ((wxMenuBar *) x));
32838 }
32839 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32840 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32841 }
32842 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32843 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32844 }
32845 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}};
32846 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}};
32847 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}};
32848 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}};
32849 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}};
32850 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}};
32851 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}};
32852 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}};
32853 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}};
32854 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}};
32855 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}};
32856 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}};
32857 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}};
32858 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}};
32859 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}};
32860 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}};
32861 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}};
32862 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}};
32863 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}};
32864 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}};
32865 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}};
32866 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}};
32867 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}};
32868 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}};
32869 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}};
32870 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}};
32871 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}};
32872 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}};
32873 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}};
32874 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}};
32875 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}};
32876 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}};
32877 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}};
32878 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}};
32879 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}};
32880 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}};
32881 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}};
32882 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}};
32883 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}};
32884 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}};
32885 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}};
32886 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}};
32887 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}};
32888 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}};
32889 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}};
32890 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}};
32891 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}};
32892 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}};
32893 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}};
32894 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}};
32895 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}};
32896 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}};
32897 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}};
32898 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}};
32899 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}};
32900 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}};
32901 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}};
32902 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}};
32903 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}};
32904 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}};
32905 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}};
32906 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}};
32907 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}};
32908 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}};
32909 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}};
32910 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}};
32911 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}};
32912 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}};
32913 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}};
32914 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}};
32915 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}};
32916 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}};
32917 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}};
32918 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}};
32919 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}};
32920 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}};
32921 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}};
32922 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}};
32923 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}};
32924 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}};
32925 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}};
32926 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}};
32927 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}};
32928 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}};
32929 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}};
32930 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}};
32931 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}};
32932 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}};
32933 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}};
32934 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}};
32935 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}};
32936 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}};
32937 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}};
32938 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}};
32939 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}};
32940 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}};
32941 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}};
32942
32943 static swig_type_info *swig_types_initial[] = {
32944 _swigt__p_wxLogChain,
32945 _swigt__p_wxMutexGuiLocker,
32946 _swigt__p_wxMetafile,
32947 _swigt__p_wxFileHistory,
32948 _swigt__p_wxLog,
32949 _swigt__p_wxMenu,
32950 _swigt__p_wxEvent,
32951 _swigt__p_wxDateTime__TimeZone,
32952 _swigt__p_wxConfigBase,
32953 _swigt__p_wxDisplay,
32954 _swigt__p_wxFileType,
32955 _swigt__p_wxLogGui,
32956 _swigt__p_wxFont,
32957 _swigt__p_wxDataFormat,
32958 _swigt__p_wxTimerEvent,
32959 _swigt__p_wxCaret,
32960 _swigt__ptrdiff_t,
32961 _swigt__std__ptrdiff_t,
32962 _swigt__p_int,
32963 _swigt__p_wxSize,
32964 _swigt__p_wxClipboard,
32965 _swigt__p_wxStopWatch,
32966 _swigt__p_wxDC,
32967 _swigt__p_wxClipboardLocker,
32968 _swigt__p_wxIcon,
32969 _swigt__p_wxLogStderr,
32970 _swigt__p_wxLogTextCtrl,
32971 _swigt__p_wxTextCtrl,
32972 _swigt__p_wxBusyCursor,
32973 _swigt__p_wxBitmapDataObject,
32974 _swigt__p_wxTextDataObject,
32975 _swigt__p_wxDataObject,
32976 _swigt__p_wxPyTextDataObject,
32977 _swigt__p_wxPyBitmapDataObject,
32978 _swigt__p_wxFileDataObject,
32979 _swigt__p_wxCustomDataObject,
32980 _swigt__p_wxURLDataObject,
32981 _swigt__p_wxMetafileDataObject,
32982 _swigt__p_wxSound,
32983 _swigt__p_wxTimerRunner,
32984 _swigt__p_wxLogWindow,
32985 _swigt__p_wxTimeSpan,
32986 _swigt__p_wxArrayString,
32987 _swigt__p_wxWindowDisabler,
32988 _swigt__p_form_ops_t,
32989 _swigt__p_wxToolTip,
32990 _swigt__p_wxDataObjectComposite,
32991 _swigt__p_wxSystemSettings,
32992 _swigt__p_wxFileConfig,
32993 _swigt__p_wxVideoMode,
32994 _swigt__p_wxDataObjectSimple,
32995 _swigt__p_wxPyDataObjectSimple,
32996 _swigt__p_wxDuplexMode,
32997 _swigt__p_wxEvtHandler,
32998 _swigt__p_wxRect,
32999 _swigt__p_char,
33000 _swigt__p_wxSingleInstanceChecker,
33001 _swigt__p_wxStandardPaths,
33002 _swigt__p_wxFileTypeInfo,
33003 _swigt__p_wxFrame,
33004 _swigt__p_wxTimer,
33005 _swigt__p_wxPaperSize,
33006 _swigt__p_wxMimeTypesManager,
33007 _swigt__p_wxPyArtProvider,
33008 _swigt__p_wxPyTipProvider,
33009 _swigt__p_wxTipProvider,
33010 _swigt__p_wxJoystick,
33011 _swigt__p_wxSystemOptions,
33012 _swigt__p_wxPoint,
33013 _swigt__p_wxJoystickEvent,
33014 _swigt__p_wxCursor,
33015 _swigt__p_wxObject,
33016 _swigt__p_wxOutputStream,
33017 _swigt__p_wxDateTime,
33018 _swigt__p_wxPyDropSource,
33019 _swigt__p_unsigned_long,
33020 _swigt__p_wxKillError,
33021 _swigt__p_wxWindow,
33022 _swigt__p_wxString,
33023 _swigt__p_wxPyProcess,
33024 _swigt__p_wxBitmap,
33025 _swigt__p_wxConfig,
33026 _swigt__unsigned_int,
33027 _swigt__p_unsigned_int,
33028 _swigt__p_unsigned_char,
33029 _swigt__p_wxChar,
33030 _swigt__p_wxBusyInfo,
33031 _swigt__p_wxPyDropTarget,
33032 _swigt__p_wxPyTextDropTarget,
33033 _swigt__p_wxPyFileDropTarget,
33034 _swigt__p_wxProcessEvent,
33035 _swigt__p_wxPyLog,
33036 _swigt__p_wxLogNull,
33037 _swigt__p_wxColour,
33038 _swigt__p_wxPyTimer,
33039 _swigt__p_wxConfigPathChanger,
33040 _swigt__p_wxDateSpan,
33041 0
33042 };
33043
33044
33045 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33046
33047 static swig_const_info swig_const_table[] = {
33048 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
33049 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
33050 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
33051 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
33052 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
33053 {0, 0, 0, 0.0, 0, 0}};
33054
33055 #ifdef __cplusplus
33056 }
33057 #endif
33058
33059
33060 #ifdef __cplusplus
33061 extern "C" {
33062 #endif
33063
33064 /* Python-specific SWIG API */
33065 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33066 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33067 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33068
33069 /* -----------------------------------------------------------------------------
33070 * global variable support code.
33071 * ----------------------------------------------------------------------------- */
33072
33073 typedef struct swig_globalvar {
33074 char *name; /* Name of global variable */
33075 PyObject *(*get_attr)(); /* Return the current value */
33076 int (*set_attr)(PyObject *); /* Set the value */
33077 struct swig_globalvar *next;
33078 } swig_globalvar;
33079
33080 typedef struct swig_varlinkobject {
33081 PyObject_HEAD
33082 swig_globalvar *vars;
33083 } swig_varlinkobject;
33084
33085 static PyObject *
33086 swig_varlink_repr(swig_varlinkobject *v) {
33087 v = v;
33088 return PyString_FromString("<Swig global variables>");
33089 }
33090
33091 static int
33092 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33093 swig_globalvar *var;
33094 flags = flags;
33095 fprintf(fp,"Swig global variables { ");
33096 for (var = v->vars; var; var=var->next) {
33097 fprintf(fp,"%s", var->name);
33098 if (var->next) fprintf(fp,", ");
33099 }
33100 fprintf(fp," }\n");
33101 return 0;
33102 }
33103
33104 static PyObject *
33105 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33106 swig_globalvar *var = v->vars;
33107 while (var) {
33108 if (strcmp(var->name,n) == 0) {
33109 return (*var->get_attr)();
33110 }
33111 var = var->next;
33112 }
33113 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33114 return NULL;
33115 }
33116
33117 static int
33118 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33119 swig_globalvar *var = v->vars;
33120 while (var) {
33121 if (strcmp(var->name,n) == 0) {
33122 return (*var->set_attr)(p);
33123 }
33124 var = var->next;
33125 }
33126 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33127 return 1;
33128 }
33129
33130 static PyTypeObject varlinktype = {
33131 PyObject_HEAD_INIT(0)
33132 0, /* Number of items in variable part (ob_size) */
33133 (char *)"swigvarlink", /* Type name (tp_name) */
33134 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33135 0, /* Itemsize (tp_itemsize) */
33136 0, /* Deallocator (tp_dealloc) */
33137 (printfunc) swig_varlink_print, /* Print (tp_print) */
33138 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33139 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33140 0, /* tp_compare */
33141 (reprfunc) swig_varlink_repr, /* tp_repr */
33142 0, /* tp_as_number */
33143 0, /* tp_as_sequence */
33144 0, /* tp_as_mapping */
33145 0, /* tp_hash */
33146 0, /* tp_call */
33147 0, /* tp_str */
33148 0, /* tp_getattro */
33149 0, /* tp_setattro */
33150 0, /* tp_as_buffer */
33151 0, /* tp_flags */
33152 0, /* tp_doc */
33153 #if PY_VERSION_HEX >= 0x02000000
33154 0, /* tp_traverse */
33155 0, /* tp_clear */
33156 #endif
33157 #if PY_VERSION_HEX >= 0x02010000
33158 0, /* tp_richcompare */
33159 0, /* tp_weaklistoffset */
33160 #endif
33161 #if PY_VERSION_HEX >= 0x02020000
33162 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33163 #endif
33164 #if PY_VERSION_HEX >= 0x02030000
33165 0, /* tp_del */
33166 #endif
33167 #ifdef COUNT_ALLOCS
33168 0,0,0,0 /* tp_alloc -> tp_next */
33169 #endif
33170 };
33171
33172 /* Create a variable linking object for use later */
33173 static PyObject *
33174 SWIG_Python_newvarlink(void) {
33175 swig_varlinkobject *result = 0;
33176 result = PyMem_NEW(swig_varlinkobject,1);
33177 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33178 result->ob_type = &varlinktype;
33179 result->vars = 0;
33180 result->ob_refcnt = 0;
33181 Py_XINCREF((PyObject *) result);
33182 return ((PyObject*) result);
33183 }
33184
33185 static void
33186 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33187 swig_varlinkobject *v;
33188 swig_globalvar *gv;
33189 v= (swig_varlinkobject *) p;
33190 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33191 gv->name = (char *) malloc(strlen(name)+1);
33192 strcpy(gv->name,name);
33193 gv->get_attr = get_attr;
33194 gv->set_attr = set_attr;
33195 gv->next = v->vars;
33196 v->vars = gv;
33197 }
33198
33199 /* -----------------------------------------------------------------------------
33200 * constants/methods manipulation
33201 * ----------------------------------------------------------------------------- */
33202
33203 /* Install Constants */
33204 static void
33205 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33206 PyObject *obj = 0;
33207 size_t i;
33208 for (i = 0; constants[i].type; i++) {
33209 switch(constants[i].type) {
33210 case SWIG_PY_INT:
33211 obj = PyInt_FromLong(constants[i].lvalue);
33212 break;
33213 case SWIG_PY_FLOAT:
33214 obj = PyFloat_FromDouble(constants[i].dvalue);
33215 break;
33216 case SWIG_PY_STRING:
33217 if (constants[i].pvalue) {
33218 obj = PyString_FromString((char *) constants[i].pvalue);
33219 } else {
33220 Py_INCREF(Py_None);
33221 obj = Py_None;
33222 }
33223 break;
33224 case SWIG_PY_POINTER:
33225 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33226 break;
33227 case SWIG_PY_BINARY:
33228 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33229 break;
33230 default:
33231 obj = 0;
33232 break;
33233 }
33234 if (obj) {
33235 PyDict_SetItemString(d,constants[i].name,obj);
33236 Py_DECREF(obj);
33237 }
33238 }
33239 }
33240
33241 /* -----------------------------------------------------------------------------*/
33242 /* Fix SwigMethods to carry the callback ptrs when needed */
33243 /* -----------------------------------------------------------------------------*/
33244
33245 static void
33246 SWIG_Python_FixMethods(PyMethodDef *methods,
33247 swig_const_info *const_table,
33248 swig_type_info **types,
33249 swig_type_info **types_initial) {
33250 size_t i;
33251 for (i = 0; methods[i].ml_name; ++i) {
33252 char *c = methods[i].ml_doc;
33253 if (c && (c = strstr(c, "swig_ptr: "))) {
33254 int j;
33255 swig_const_info *ci = 0;
33256 char *name = c + 10;
33257 for (j = 0; const_table[j].type; j++) {
33258 if (strncmp(const_table[j].name, name,
33259 strlen(const_table[j].name)) == 0) {
33260 ci = &(const_table[j]);
33261 break;
33262 }
33263 }
33264 if (ci) {
33265 size_t shift = (ci->ptype) - types;
33266 swig_type_info *ty = types_initial[shift];
33267 size_t ldoc = (c - methods[i].ml_doc);
33268 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33269 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33270 char *buff = ndoc;
33271 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33272 strncpy(buff, methods[i].ml_doc, ldoc);
33273 buff += ldoc;
33274 strncpy(buff, "swig_ptr: ", 10);
33275 buff += 10;
33276 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33277 methods[i].ml_doc = ndoc;
33278 }
33279 }
33280 }
33281 }
33282
33283 /* -----------------------------------------------------------------------------*
33284 * Initialize type list
33285 * -----------------------------------------------------------------------------*/
33286
33287 #if PY_MAJOR_VERSION < 2
33288 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33289 is copied out of Python/modsupport.c in python version 2.3.4 */
33290 static int
33291 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33292 {
33293 PyObject *dict;
33294 if (!PyModule_Check(m)) {
33295 PyErr_SetString(PyExc_TypeError,
33296 "PyModule_AddObject() needs module as first arg");
33297 return -1;
33298 }
33299 if (!o) {
33300 PyErr_SetString(PyExc_TypeError,
33301 "PyModule_AddObject() needs non-NULL value");
33302 return -1;
33303 }
33304
33305 dict = PyModule_GetDict(m);
33306 if (dict == NULL) {
33307 /* Internal error -- modules must have a dict! */
33308 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33309 PyModule_GetName(m));
33310 return -1;
33311 }
33312 if (PyDict_SetItemString(dict, name, o))
33313 return -1;
33314 Py_DECREF(o);
33315 return 0;
33316 }
33317 #endif
33318
33319 static swig_type_info **
33320 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33321 static PyMethodDef swig_empty_runtime_method_table[] = {
33322 {
33323 NULL, NULL, 0, NULL
33324 }
33325 };/* Sentinel */
33326
33327 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33328 swig_empty_runtime_method_table);
33329 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33330 if (pointer && module) {
33331 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33332 }
33333 return type_list_handle;
33334 }
33335
33336 static swig_type_info **
33337 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33338 swig_type_info **type_pointer;
33339
33340 /* first check if module already created */
33341 type_pointer = SWIG_Python_GetTypeListHandle();
33342 if (type_pointer) {
33343 return type_pointer;
33344 } else {
33345 /* create a new module and variable */
33346 return SWIG_Python_SetTypeListHandle(type_list_handle);
33347 }
33348 }
33349
33350 #ifdef __cplusplus
33351 }
33352 #endif
33353
33354 /* -----------------------------------------------------------------------------*
33355 * Partial Init method
33356 * -----------------------------------------------------------------------------*/
33357
33358 #ifdef SWIG_LINK_RUNTIME
33359 #ifdef __cplusplus
33360 extern "C"
33361 #endif
33362 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33363 #endif
33364
33365 #ifdef __cplusplus
33366 extern "C"
33367 #endif
33368 SWIGEXPORT(void) SWIG_init(void) {
33369 static PyObject *SWIG_globals = 0;
33370 static int typeinit = 0;
33371 PyObject *m, *d;
33372 int i;
33373 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33374
33375 /* Fix SwigMethods to carry the callback ptrs when needed */
33376 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33377
33378 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33379 d = PyModule_GetDict(m);
33380
33381 if (!typeinit) {
33382 #ifdef SWIG_LINK_RUNTIME
33383 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33384 #else
33385 # ifndef SWIG_STATIC_RUNTIME
33386 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33387 # endif
33388 #endif
33389 for (i = 0; swig_types_initial[i]; i++) {
33390 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33391 }
33392 typeinit = 1;
33393 }
33394 SWIG_InstallConstants(d,swig_const_table);
33395
33396 {
33397 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33398 }
33399 {
33400 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33401 }
33402 {
33403 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33404 }
33405 {
33406 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33407 }
33408 {
33409 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33410 }
33411 {
33412 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33413 }
33414 {
33415 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33416 }
33417 {
33418 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33419 }
33420 {
33421 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33422 }
33423 {
33424 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33425 }
33426 {
33427 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33428 }
33429 {
33430 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33431 }
33432 {
33433 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33434 }
33435 {
33436 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33437 }
33438 {
33439 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33440 }
33441 {
33442 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33443 }
33444 {
33445 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33446 }
33447 {
33448 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33449 }
33450 {
33451 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33452 }
33453 {
33454 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33455 }
33456 {
33457 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33458 }
33459 {
33460 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33461 }
33462 {
33463 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33464 }
33465 {
33466 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33467 }
33468 {
33469 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33470 }
33471 {
33472 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33473 }
33474 {
33475 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33476 }
33477 {
33478 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33479 }
33480 {
33481 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33482 }
33483 {
33484 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33485 }
33486 {
33487 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33488 }
33489 {
33490 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33491 }
33492 {
33493 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33494 }
33495 {
33496 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33497 }
33498 {
33499 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33500 }
33501 {
33502 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33503 }
33504 {
33505 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33506 }
33507 {
33508 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33509 }
33510 {
33511 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33512 }
33513 {
33514 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33515 }
33516 {
33517 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33518 }
33519 {
33520 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33521 }
33522 {
33523 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33524 }
33525 {
33526 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33527 }
33528 {
33529 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33530 }
33531 {
33532 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33533 }
33534 {
33535 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33536 }
33537 {
33538 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33539 }
33540 {
33541 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33542 }
33543 {
33544 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33545 }
33546 {
33547 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33548 }
33549 {
33550 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33551 }
33552 {
33553 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33554 }
33555 {
33556 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33557 }
33558 {
33559 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33560 }
33561 {
33562 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33563 }
33564 {
33565 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33566 }
33567 {
33568 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33569 }
33570 {
33571 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33572 }
33573 {
33574 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33575 }
33576 {
33577 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33578 }
33579 {
33580 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33581 }
33582 {
33583 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33584 }
33585 {
33586 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33587 }
33588 {
33589 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33590 }
33591 {
33592 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33593 }
33594 {
33595 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33596 }
33597 {
33598 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33599 }
33600 {
33601 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33602 }
33603 {
33604 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33605 }
33606 {
33607 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33608 }
33609 {
33610 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33611 }
33612 {
33613 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33614 }
33615 {
33616 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33617 }
33618 {
33619 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33620 }
33621 {
33622 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33623 }
33624 {
33625 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33626 }
33627 {
33628 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33629 }
33630 {
33631 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33632 }
33633 {
33634 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33635 }
33636 {
33637 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33638 }
33639 {
33640 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33641 }
33642 {
33643 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33644 }
33645 {
33646 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33647 }
33648 {
33649 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33650 }
33651 {
33652 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33653 }
33654 {
33655 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33656 }
33657 {
33658 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33659 }
33660 {
33661 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33662 }
33663 {
33664 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33665 }
33666 {
33667 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33668 }
33669 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33670 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33671 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33672 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33673 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33674 {
33675 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33676 }
33677 {
33678 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33679 }
33680 {
33681 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33682 }
33683 {
33684 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33685 }
33686 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33687
33688 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33689
33690 {
33691 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33692 }
33693 {
33694 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33695 }
33696 {
33697 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33698 }
33699 {
33700 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33701 }
33702 {
33703 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33704 }
33705 {
33706 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33707 }
33708 {
33709 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33710 }
33711 {
33712 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33713 }
33714 {
33715 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33716 }
33717 {
33718 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33719 }
33720 {
33721 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33722 }
33723 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33724 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33725 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33726 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33727 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33728 {
33729 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33730 }
33731 {
33732 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33733 }
33734 {
33735 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33736 }
33737 {
33738 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33739 }
33740 {
33741 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33742 }
33743 {
33744 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33745 }
33746 {
33747 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33748 }
33749 {
33750 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33751 }
33752 {
33753 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33754 }
33755 {
33756 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33757 }
33758 {
33759 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33760 }
33761 {
33762 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33763 }
33764 {
33765 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33766 }
33767 {
33768 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33769 }
33770 {
33771 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33778 }
33779 {
33780 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33781 }
33782 {
33783 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33784 }
33785 {
33786 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33790 }
33791 {
33792 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33793 }
33794 {
33795 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33796 }
33797 {
33798 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33799 }
33800 {
33801 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33802 }
33803 {
33804 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33805 }
33806 {
33807 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33808 }
33809 {
33810 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33811 }
33812 {
33813 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33814 }
33815 {
33816 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33817 }
33818 {
33819 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33820 }
33821 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33822 {
33823 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33824 }
33825 {
33826 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33827 }
33828 {
33829 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33830 }
33831 {
33832 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33833 }
33834 {
33835 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33836 }
33837
33838 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33839
33840 {
33841 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33842 }
33843 {
33844 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33845 }
33846 {
33847 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33851 }
33852 {
33853 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33854 }
33855 {
33856 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33857 }
33858 {
33859 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33860 }
33861 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33862 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33863 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33864 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33865 {
33866 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33867 }
33868 {
33869 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33870 }
33871 {
33872 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33873 }
33874 {
33875 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33876 }
33877 {
33878 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33879 }
33880 {
33881 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33882 }
33883 {
33884 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33885 }
33886 {
33887 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33888 }
33889 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33890 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33891 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33892 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33893 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33894 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33895 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33896 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33897 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33898 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33899 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33900 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33901 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33902 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33903 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33904 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33905 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33906 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33907 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33908 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33909 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33910 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33911 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33912 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33913 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33914 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33915 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33916 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33917 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33918 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33919 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33920 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33921 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33922 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33923 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33924 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33925 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33926 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33927 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33928 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33929 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33930 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33931 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33932 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33933 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33934 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33935 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33936 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33937 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33938 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33939 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33940 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33941 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33942 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33943 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33944 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33945
33946 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33947
33948 {
33949 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33950 }
33951 {
33952 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33953 }
33954 {
33955 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33956 }
33957 {
33958 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33959 }
33960 {
33961 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33962 }
33963 {
33964 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33965 }
33966 {
33967 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33968 }
33969 {
33970 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33971 }
33972 {
33973 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33974 }
33975 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33976 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33977 {
33978 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33979 }
33980 {
33981 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33982 }
33983 {
33984 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33985 }
33986 {
33987 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33988 }
33989 {
33990 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33991 }
33992 {
33993 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33994 }
33995 {
33996 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33997 }
33998 {
33999 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
34000 }
34001 {
34002 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
34003 }
34004 {
34005 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
34006 }
34007 {
34008 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
34009 }
34010 {
34011 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
34012 }
34013 {
34014 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
34015 }
34016 {
34017 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
34018 }
34019 {
34020 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
34021 }
34022 {
34023 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
34024 }
34025 {
34026 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
34027 }
34028 {
34029 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
34030 }
34031 {
34032 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
34033 }
34034 {
34035 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
34036 }
34037 {
34038 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
34039 }
34040 {
34041 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
34042 }
34043 {
34044 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
34045 }
34046 {
34047 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
34048 }
34049 {
34050 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
34051 }
34052 {
34053 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
34054 }
34055 {
34056 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34057 }
34058 {
34059 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34060 }
34061 {
34062 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34063 }
34064 {
34065 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34066 }
34067 {
34068 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34069 }
34070 {
34071 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34072 }
34073 {
34074 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34075 }
34076 {
34077 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34078 }
34079 {
34080 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34081 }
34082 {
34083 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34084 }
34085 {
34086 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34087 }
34088 {
34089 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34090 }
34091 {
34092 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34093 }
34094 {
34095 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34096 }
34097 {
34098 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34099 }
34100 {
34101 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34102 }
34103 {
34104 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34105 }
34106 {
34107 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34108 }
34109 {
34110 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34111 }
34112 {
34113 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34114 }
34115 {
34116 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34117 }
34118 {
34119 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34120 }
34121 {
34122 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34123 }
34124 {
34125 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34126 }
34127 {
34128 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34129 }
34130 {
34131 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34132 }
34133 {
34134 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34135 }
34136 {
34137 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34138 }
34139 {
34140 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34141 }
34142 {
34143 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34144 }
34145 {
34146 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34147 }
34148 {
34149 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34150 }
34151 {
34152 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34153 }
34154 {
34155 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34156 }
34157 {
34158 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34159 }
34160 {
34161 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34162 }
34163 {
34164 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34165 }
34166 {
34167 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34168 }
34169 {
34170 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34171 }
34172 {
34173 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34174 }
34175 {
34176 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34177 }
34178 {
34179 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34180 }
34181 {
34182 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34183 }
34184 {
34185 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34186 }
34187 {
34188 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34189 }
34190 {
34191 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34192 }
34193 {
34194 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34195 }
34196 {
34197 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34198 }
34199 {
34200 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34201 }
34202 {
34203 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34204 }
34205 {
34206 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34207 }
34208 {
34209 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34210 }
34211 {
34212 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34213 }
34214 {
34215 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34216 }
34217 {
34218 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34219 }
34220 {
34221 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34222 }
34223 {
34224 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34225 }
34226 {
34227 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34228 }
34229 {
34230 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34231 }
34232 {
34233 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34234 }
34235 {
34236 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34237 }
34238 {
34239 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34240 }
34241 {
34242 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34243 }
34244 {
34245 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34246 }
34247 {
34248 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34249 }
34250 {
34251 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34252 }
34253 {
34254 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34255 }
34256 {
34257 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34258 }
34259 {
34260 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34261 }
34262 {
34263 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34264 }
34265 {
34266 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34267 }
34268 {
34269 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34270 }
34271 {
34272 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34273 }
34274 {
34275 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34276 }
34277 {
34278 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34279 }
34280 {
34281 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34282 }
34283 {
34284 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34285 }
34286 {
34287 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34288 }
34289 {
34290 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34291 }
34292 {
34293 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34294 }
34295 {
34296 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34297 }
34298 {
34299 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34300 }
34301 {
34302 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34303 }
34304 {
34305 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34306 }
34307 {
34308 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34309 }
34310 {
34311 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34312 }
34313 {
34314 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34315 }
34316 {
34317 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34318 }
34319 {
34320 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34321 }
34322 {
34323 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34324 }
34325 {
34326 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34327 }
34328 {
34329 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34330 }
34331 {
34332 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34333 }
34334 {
34335 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34336 }
34337 {
34338 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34339 }
34340 {
34341 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34342 }
34343 {
34344 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34345 }
34346 {
34347 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34348 }
34349 {
34350 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34351 }
34352 {
34353 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34354 }
34355 {
34356 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34357 }
34358 {
34359 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34360 }
34361 {
34362 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34363 }
34364 {
34365 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34366 }
34367 {
34368 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34369 }
34370 {
34371 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34372 }
34373 {
34374 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34375 }
34376 {
34377 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34378 }
34379 {
34380 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34381 }
34382 {
34383 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34384 }
34385 {
34386 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34387 }
34388 {
34389 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34390 }
34391 {
34392 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34393 }
34394 {
34395 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34396 }
34397 {
34398 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34399 }
34400 {
34401 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34402 }
34403 {
34404 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34405 }
34406 {
34407 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34408 }
34409 {
34410 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34411 }
34412 {
34413 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34414 }
34415 {
34416 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34417 }
34418 {
34419 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34420 }
34421 {
34422 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34423 }
34424 {
34425 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34426 }
34427 {
34428 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34429 }
34430 {
34431 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34432 }
34433 {
34434 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34435 }
34436 {
34437 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34438 }
34439 {
34440 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34441 }
34442 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34443 {
34444 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34445 }
34446 {
34447 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34448 }
34449 {
34450 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34451 }
34452 {
34453 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34454 }
34455 {
34456 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34457 }
34458 {
34459 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34460 }
34461 {
34462 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34463 }
34464 {
34465 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34466 }
34467 {
34468 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34469 }
34470 {
34471 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34472 }
34473 {
34474 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34475 }
34476 {
34477 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34478 }
34479 {
34480 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34481 }
34482 {
34483 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34484 }
34485 {
34486 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34487 }
34488 {
34489 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34490 }
34491 {
34492 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34493 }
34494 {
34495 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34496 }
34497 {
34498 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34499 }
34500 {
34501 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34502 }
34503 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34504 {
34505 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34506 }
34507 {
34508 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34509 }
34510 {
34511 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34512 }
34513 {
34514 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34515 }
34516 {
34517 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34518 }
34519 {
34520 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34521 }
34522 {
34523 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34524 }
34525 {
34526 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34527 }
34528 {
34529 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34530 }
34531 {
34532 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34533 }
34534 {
34535 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34536 }
34537 {
34538 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34539 }
34540
34541 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34542 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34543 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34544 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34545
34546 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34547 }
34548
wxWidgets (Impactor)