]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
A few build tweaks
[wxWidgets.git] / wxPython / src / msw / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 iconIndex = loc.GetIndex();
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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2533 #define SWIG_From_unsigned_SS_int SWIG_From_long
2534 /*@@*/
2535 #else
2536 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2959 PyObject* pyList = NULL;
2960 wxArrayVideoModes arr = self->GetModes(mode);
2961 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2962 pyList = PyList_New(0);
2963 for (int i=0; i < arr.GetCount(); i++) {
2964 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2965 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2966 PyList_Append(pyList, pyObj);
2967 Py_DECREF(pyObj);
2968 }
2969 wxPyEndBlockThreads(blocked);
2970 return pyList;
2971 }
2972
2973 #include <wx/stdpaths.h>
2974
2975 static wxStandardPaths *StandardPaths_Get(){
2976 return (wxStandardPaths*) &wxStandardPaths::Get();
2977 }
2978 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2979 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2980 #ifdef __cplusplus
2981 extern "C" {
2982 #endif
2983 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2984 PyObject *resultobj;
2985 wxSystemColour arg1 ;
2986 wxColour result;
2987 PyObject * obj0 = 0 ;
2988 char *kwnames[] = {
2989 (char *) "index", NULL
2990 };
2991
2992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2993 {
2994 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2995 if (SWIG_arg_fail(1)) SWIG_fail;
2996 }
2997 {
2998 if (!wxPyCheckForApp()) SWIG_fail;
2999 PyThreadState* __tstate = wxPyBeginAllowThreads();
3000 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3001
3002 wxPyEndAllowThreads(__tstate);
3003 if (PyErr_Occurred()) SWIG_fail;
3004 }
3005 {
3006 wxColour * resultptr;
3007 resultptr = new wxColour((wxColour &)(result));
3008 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3009 }
3010 return resultobj;
3011 fail:
3012 return NULL;
3013 }
3014
3015
3016 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3017 PyObject *resultobj;
3018 wxSystemFont arg1 ;
3019 wxFont result;
3020 PyObject * obj0 = 0 ;
3021 char *kwnames[] = {
3022 (char *) "index", NULL
3023 };
3024
3025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3026 {
3027 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3028 if (SWIG_arg_fail(1)) SWIG_fail;
3029 }
3030 {
3031 if (!wxPyCheckForApp()) SWIG_fail;
3032 PyThreadState* __tstate = wxPyBeginAllowThreads();
3033 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3034
3035 wxPyEndAllowThreads(__tstate);
3036 if (PyErr_Occurred()) SWIG_fail;
3037 }
3038 {
3039 wxFont * resultptr;
3040 resultptr = new wxFont((wxFont &)(result));
3041 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3042 }
3043 return resultobj;
3044 fail:
3045 return NULL;
3046 }
3047
3048
3049 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3050 PyObject *resultobj;
3051 wxSystemMetric arg1 ;
3052 wxWindow *arg2 = (wxWindow *) NULL ;
3053 int result;
3054 PyObject * obj0 = 0 ;
3055 PyObject * obj1 = 0 ;
3056 char *kwnames[] = {
3057 (char *) "index",(char *) "win", NULL
3058 };
3059
3060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3061 {
3062 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3063 if (SWIG_arg_fail(1)) SWIG_fail;
3064 }
3065 if (obj1) {
3066 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3067 if (SWIG_arg_fail(2)) SWIG_fail;
3068 }
3069 {
3070 if (!wxPyCheckForApp()) SWIG_fail;
3071 PyThreadState* __tstate = wxPyBeginAllowThreads();
3072 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3073
3074 wxPyEndAllowThreads(__tstate);
3075 if (PyErr_Occurred()) SWIG_fail;
3076 }
3077 {
3078 resultobj = SWIG_From_int((int)(result));
3079 }
3080 return resultobj;
3081 fail:
3082 return NULL;
3083 }
3084
3085
3086 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3087 PyObject *resultobj;
3088 wxSystemFeature arg1 ;
3089 bool result;
3090 PyObject * obj0 = 0 ;
3091 char *kwnames[] = {
3092 (char *) "index", NULL
3093 };
3094
3095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3096 {
3097 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3098 if (SWIG_arg_fail(1)) SWIG_fail;
3099 }
3100 {
3101 if (!wxPyCheckForApp()) SWIG_fail;
3102 PyThreadState* __tstate = wxPyBeginAllowThreads();
3103 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3104
3105 wxPyEndAllowThreads(__tstate);
3106 if (PyErr_Occurred()) SWIG_fail;
3107 }
3108 {
3109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3110 }
3111 return resultobj;
3112 fail:
3113 return NULL;
3114 }
3115
3116
3117 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3118 PyObject *resultobj;
3119 wxSystemScreenType result;
3120 char *kwnames[] = {
3121 NULL
3122 };
3123
3124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3125 {
3126 if (!wxPyCheckForApp()) SWIG_fail;
3127 PyThreadState* __tstate = wxPyBeginAllowThreads();
3128 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3129
3130 wxPyEndAllowThreads(__tstate);
3131 if (PyErr_Occurred()) SWIG_fail;
3132 }
3133 resultobj = SWIG_From_int((result));
3134 return resultobj;
3135 fail:
3136 return NULL;
3137 }
3138
3139
3140 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3141 PyObject *resultobj;
3142 wxSystemScreenType arg1 ;
3143 PyObject * obj0 = 0 ;
3144 char *kwnames[] = {
3145 (char *) "screen", NULL
3146 };
3147
3148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3149 {
3150 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3151 if (SWIG_arg_fail(1)) SWIG_fail;
3152 }
3153 {
3154 if (!wxPyCheckForApp()) SWIG_fail;
3155 PyThreadState* __tstate = wxPyBeginAllowThreads();
3156 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3157
3158 wxPyEndAllowThreads(__tstate);
3159 if (PyErr_Occurred()) SWIG_fail;
3160 }
3161 Py_INCREF(Py_None); resultobj = Py_None;
3162 return resultobj;
3163 fail:
3164 return NULL;
3165 }
3166
3167
3168 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3169 PyObject *obj;
3170 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3171 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3172 Py_INCREF(obj);
3173 return Py_BuildValue((char *)"");
3174 }
3175 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3176 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3177 return 1;
3178 }
3179
3180
3181 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3182 PyObject *pyobj;
3183
3184 {
3185 #if wxUSE_UNICODE
3186 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3187 #else
3188 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3189 #endif
3190 }
3191 return pyobj;
3192 }
3193
3194
3195 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3196 PyObject *resultobj;
3197 wxSystemOptions *result;
3198 char *kwnames[] = {
3199 NULL
3200 };
3201
3202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3203 {
3204 PyThreadState* __tstate = wxPyBeginAllowThreads();
3205 result = (wxSystemOptions *)new wxSystemOptions();
3206
3207 wxPyEndAllowThreads(__tstate);
3208 if (PyErr_Occurred()) SWIG_fail;
3209 }
3210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3211 return resultobj;
3212 fail:
3213 return NULL;
3214 }
3215
3216
3217 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3218 PyObject *resultobj;
3219 wxString *arg1 = 0 ;
3220 wxString *arg2 = 0 ;
3221 bool temp1 = false ;
3222 bool temp2 = false ;
3223 PyObject * obj0 = 0 ;
3224 PyObject * obj1 = 0 ;
3225 char *kwnames[] = {
3226 (char *) "name",(char *) "value", NULL
3227 };
3228
3229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3230 {
3231 arg1 = wxString_in_helper(obj0);
3232 if (arg1 == NULL) SWIG_fail;
3233 temp1 = true;
3234 }
3235 {
3236 arg2 = wxString_in_helper(obj1);
3237 if (arg2 == NULL) SWIG_fail;
3238 temp2 = true;
3239 }
3240 {
3241 PyThreadState* __tstate = wxPyBeginAllowThreads();
3242 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3243
3244 wxPyEndAllowThreads(__tstate);
3245 if (PyErr_Occurred()) SWIG_fail;
3246 }
3247 Py_INCREF(Py_None); resultobj = Py_None;
3248 {
3249 if (temp1)
3250 delete arg1;
3251 }
3252 {
3253 if (temp2)
3254 delete arg2;
3255 }
3256 return resultobj;
3257 fail:
3258 {
3259 if (temp1)
3260 delete arg1;
3261 }
3262 {
3263 if (temp2)
3264 delete arg2;
3265 }
3266 return NULL;
3267 }
3268
3269
3270 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3271 PyObject *resultobj;
3272 wxString *arg1 = 0 ;
3273 int arg2 ;
3274 bool temp1 = false ;
3275 PyObject * obj0 = 0 ;
3276 PyObject * obj1 = 0 ;
3277 char *kwnames[] = {
3278 (char *) "name",(char *) "value", NULL
3279 };
3280
3281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3282 {
3283 arg1 = wxString_in_helper(obj0);
3284 if (arg1 == NULL) SWIG_fail;
3285 temp1 = true;
3286 }
3287 {
3288 arg2 = (int)(SWIG_As_int(obj1));
3289 if (SWIG_arg_fail(2)) SWIG_fail;
3290 }
3291 {
3292 PyThreadState* __tstate = wxPyBeginAllowThreads();
3293 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3294
3295 wxPyEndAllowThreads(__tstate);
3296 if (PyErr_Occurred()) SWIG_fail;
3297 }
3298 Py_INCREF(Py_None); resultobj = Py_None;
3299 {
3300 if (temp1)
3301 delete arg1;
3302 }
3303 return resultobj;
3304 fail:
3305 {
3306 if (temp1)
3307 delete arg1;
3308 }
3309 return NULL;
3310 }
3311
3312
3313 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3314 PyObject *resultobj;
3315 wxString *arg1 = 0 ;
3316 wxString result;
3317 bool temp1 = false ;
3318 PyObject * obj0 = 0 ;
3319 char *kwnames[] = {
3320 (char *) "name", NULL
3321 };
3322
3323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3324 {
3325 arg1 = wxString_in_helper(obj0);
3326 if (arg1 == NULL) SWIG_fail;
3327 temp1 = true;
3328 }
3329 {
3330 PyThreadState* __tstate = wxPyBeginAllowThreads();
3331 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3332
3333 wxPyEndAllowThreads(__tstate);
3334 if (PyErr_Occurred()) SWIG_fail;
3335 }
3336 {
3337 #if wxUSE_UNICODE
3338 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3339 #else
3340 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3341 #endif
3342 }
3343 {
3344 if (temp1)
3345 delete arg1;
3346 }
3347 return resultobj;
3348 fail:
3349 {
3350 if (temp1)
3351 delete arg1;
3352 }
3353 return NULL;
3354 }
3355
3356
3357 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3358 PyObject *resultobj;
3359 wxString *arg1 = 0 ;
3360 int result;
3361 bool temp1 = false ;
3362 PyObject * obj0 = 0 ;
3363 char *kwnames[] = {
3364 (char *) "name", NULL
3365 };
3366
3367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3368 {
3369 arg1 = wxString_in_helper(obj0);
3370 if (arg1 == NULL) SWIG_fail;
3371 temp1 = true;
3372 }
3373 {
3374 PyThreadState* __tstate = wxPyBeginAllowThreads();
3375 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3376
3377 wxPyEndAllowThreads(__tstate);
3378 if (PyErr_Occurred()) SWIG_fail;
3379 }
3380 {
3381 resultobj = SWIG_From_int((int)(result));
3382 }
3383 {
3384 if (temp1)
3385 delete arg1;
3386 }
3387 return resultobj;
3388 fail:
3389 {
3390 if (temp1)
3391 delete arg1;
3392 }
3393 return NULL;
3394 }
3395
3396
3397 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3398 PyObject *resultobj;
3399 wxString *arg1 = 0 ;
3400 bool result;
3401 bool temp1 = false ;
3402 PyObject * obj0 = 0 ;
3403 char *kwnames[] = {
3404 (char *) "name", NULL
3405 };
3406
3407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3408 {
3409 arg1 = wxString_in_helper(obj0);
3410 if (arg1 == NULL) SWIG_fail;
3411 temp1 = true;
3412 }
3413 {
3414 PyThreadState* __tstate = wxPyBeginAllowThreads();
3415 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3416
3417 wxPyEndAllowThreads(__tstate);
3418 if (PyErr_Occurred()) SWIG_fail;
3419 }
3420 {
3421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3422 }
3423 {
3424 if (temp1)
3425 delete arg1;
3426 }
3427 return resultobj;
3428 fail:
3429 {
3430 if (temp1)
3431 delete arg1;
3432 }
3433 return NULL;
3434 }
3435
3436
3437 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3438 PyObject *resultobj;
3439 wxString *arg1 = 0 ;
3440 bool result;
3441 bool temp1 = false ;
3442 PyObject * obj0 = 0 ;
3443 char *kwnames[] = {
3444 (char *) "name", NULL
3445 };
3446
3447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3448 {
3449 arg1 = wxString_in_helper(obj0);
3450 if (arg1 == NULL) SWIG_fail;
3451 temp1 = true;
3452 }
3453 {
3454 PyThreadState* __tstate = wxPyBeginAllowThreads();
3455 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3456
3457 wxPyEndAllowThreads(__tstate);
3458 if (PyErr_Occurred()) SWIG_fail;
3459 }
3460 {
3461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3462 }
3463 {
3464 if (temp1)
3465 delete arg1;
3466 }
3467 return resultobj;
3468 fail:
3469 {
3470 if (temp1)
3471 delete arg1;
3472 }
3473 return NULL;
3474 }
3475
3476
3477 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3478 PyObject *obj;
3479 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3480 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3481 Py_INCREF(obj);
3482 return Py_BuildValue((char *)"");
3483 }
3484 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3485 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3486 return 1;
3487 }
3488
3489
3490 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3491 PyObject *pyobj;
3492
3493 {
3494 #if wxUSE_UNICODE
3495 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3496 #else
3497 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3498 #endif
3499 }
3500 return pyobj;
3501 }
3502
3503
3504 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3505 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3506 return 1;
3507 }
3508
3509
3510 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3511 PyObject *pyobj;
3512
3513 {
3514 #if wxUSE_UNICODE
3515 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3516 #else
3517 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3518 #endif
3519 }
3520 return pyobj;
3521 }
3522
3523
3524 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3525 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3526 return 1;
3527 }
3528
3529
3530 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3531 PyObject *pyobj;
3532
3533 {
3534 #if wxUSE_UNICODE
3535 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3536 #else
3537 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3538 #endif
3539 }
3540 return pyobj;
3541 }
3542
3543
3544 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3545 PyObject *resultobj;
3546 long result;
3547 char *kwnames[] = {
3548 NULL
3549 };
3550
3551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3552 {
3553 PyThreadState* __tstate = wxPyBeginAllowThreads();
3554 result = (long)wxNewId();
3555
3556 wxPyEndAllowThreads(__tstate);
3557 if (PyErr_Occurred()) SWIG_fail;
3558 }
3559 {
3560 resultobj = SWIG_From_long((long)(result));
3561 }
3562 return resultobj;
3563 fail:
3564 return NULL;
3565 }
3566
3567
3568 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3569 PyObject *resultobj;
3570 long arg1 ;
3571 PyObject * obj0 = 0 ;
3572 char *kwnames[] = {
3573 (char *) "id", NULL
3574 };
3575
3576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3577 {
3578 arg1 = (long)(SWIG_As_long(obj0));
3579 if (SWIG_arg_fail(1)) SWIG_fail;
3580 }
3581 {
3582 PyThreadState* __tstate = wxPyBeginAllowThreads();
3583 wxRegisterId(arg1);
3584
3585 wxPyEndAllowThreads(__tstate);
3586 if (PyErr_Occurred()) SWIG_fail;
3587 }
3588 Py_INCREF(Py_None); resultobj = Py_None;
3589 return resultobj;
3590 fail:
3591 return NULL;
3592 }
3593
3594
3595 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3596 PyObject *resultobj;
3597 long result;
3598 char *kwnames[] = {
3599 NULL
3600 };
3601
3602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3603 {
3604 PyThreadState* __tstate = wxPyBeginAllowThreads();
3605 result = (long)wxGetCurrentId();
3606
3607 wxPyEndAllowThreads(__tstate);
3608 if (PyErr_Occurred()) SWIG_fail;
3609 }
3610 {
3611 resultobj = SWIG_From_long((long)(result));
3612 }
3613 return resultobj;
3614 fail:
3615 return NULL;
3616 }
3617
3618
3619 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3620 PyObject *resultobj;
3621 int arg1 ;
3622 bool result;
3623 PyObject * obj0 = 0 ;
3624 char *kwnames[] = {
3625 (char *) "id", NULL
3626 };
3627
3628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3629 {
3630 arg1 = (int)(SWIG_As_int(obj0));
3631 if (SWIG_arg_fail(1)) SWIG_fail;
3632 }
3633 {
3634 PyThreadState* __tstate = wxPyBeginAllowThreads();
3635 result = (bool)wxIsStockID(arg1);
3636
3637 wxPyEndAllowThreads(__tstate);
3638 if (PyErr_Occurred()) SWIG_fail;
3639 }
3640 {
3641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3642 }
3643 return resultobj;
3644 fail:
3645 return NULL;
3646 }
3647
3648
3649 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3650 PyObject *resultobj;
3651 int arg1 ;
3652 wxString *arg2 = 0 ;
3653 bool result;
3654 bool temp2 = false ;
3655 PyObject * obj0 = 0 ;
3656 PyObject * obj1 = 0 ;
3657 char *kwnames[] = {
3658 (char *) "id",(char *) "label", NULL
3659 };
3660
3661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3662 {
3663 arg1 = (int)(SWIG_As_int(obj0));
3664 if (SWIG_arg_fail(1)) SWIG_fail;
3665 }
3666 {
3667 arg2 = wxString_in_helper(obj1);
3668 if (arg2 == NULL) SWIG_fail;
3669 temp2 = true;
3670 }
3671 {
3672 PyThreadState* __tstate = wxPyBeginAllowThreads();
3673 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3674
3675 wxPyEndAllowThreads(__tstate);
3676 if (PyErr_Occurred()) SWIG_fail;
3677 }
3678 {
3679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3680 }
3681 {
3682 if (temp2)
3683 delete arg2;
3684 }
3685 return resultobj;
3686 fail:
3687 {
3688 if (temp2)
3689 delete arg2;
3690 }
3691 return NULL;
3692 }
3693
3694
3695 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3696 PyObject *resultobj;
3697 int arg1 ;
3698 bool arg2 = (bool) true ;
3699 wxString arg3 = (wxString) wxPyEmptyString ;
3700 wxString result;
3701 PyObject * obj0 = 0 ;
3702 PyObject * obj1 = 0 ;
3703 PyObject * obj2 = 0 ;
3704 char *kwnames[] = {
3705 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3706 };
3707
3708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3709 {
3710 arg1 = (int)(SWIG_As_int(obj0));
3711 if (SWIG_arg_fail(1)) SWIG_fail;
3712 }
3713 if (obj1) {
3714 {
3715 arg2 = (bool)(SWIG_As_bool(obj1));
3716 if (SWIG_arg_fail(2)) SWIG_fail;
3717 }
3718 }
3719 if (obj2) {
3720 {
3721 wxString* sptr = wxString_in_helper(obj2);
3722 if (sptr == NULL) SWIG_fail;
3723 arg3 = *sptr;
3724 delete sptr;
3725 }
3726 }
3727 {
3728 PyThreadState* __tstate = wxPyBeginAllowThreads();
3729 result = wxGetStockLabel(arg1,arg2,arg3);
3730
3731 wxPyEndAllowThreads(__tstate);
3732 if (PyErr_Occurred()) SWIG_fail;
3733 }
3734 {
3735 #if wxUSE_UNICODE
3736 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3737 #else
3738 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3739 #endif
3740 }
3741 return resultobj;
3742 fail:
3743 return NULL;
3744 }
3745
3746
3747 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3748 PyObject *resultobj;
3749 char *kwnames[] = {
3750 NULL
3751 };
3752
3753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3754 {
3755 if (!wxPyCheckForApp()) SWIG_fail;
3756 PyThreadState* __tstate = wxPyBeginAllowThreads();
3757 wxBell();
3758
3759 wxPyEndAllowThreads(__tstate);
3760 if (PyErr_Occurred()) SWIG_fail;
3761 }
3762 Py_INCREF(Py_None); resultobj = Py_None;
3763 return resultobj;
3764 fail:
3765 return NULL;
3766 }
3767
3768
3769 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3770 PyObject *resultobj;
3771 char *kwnames[] = {
3772 NULL
3773 };
3774
3775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3776 {
3777 if (!wxPyCheckForApp()) SWIG_fail;
3778 PyThreadState* __tstate = wxPyBeginAllowThreads();
3779 wxEndBusyCursor();
3780
3781 wxPyEndAllowThreads(__tstate);
3782 if (PyErr_Occurred()) SWIG_fail;
3783 }
3784 Py_INCREF(Py_None); resultobj = Py_None;
3785 return resultobj;
3786 fail:
3787 return NULL;
3788 }
3789
3790
3791 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3792 PyObject *resultobj;
3793 bool arg1 = (bool) true ;
3794 long result;
3795 PyObject * obj0 = 0 ;
3796 char *kwnames[] = {
3797 (char *) "resetTimer", NULL
3798 };
3799
3800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3801 if (obj0) {
3802 {
3803 arg1 = (bool)(SWIG_As_bool(obj0));
3804 if (SWIG_arg_fail(1)) SWIG_fail;
3805 }
3806 }
3807 {
3808 PyThreadState* __tstate = wxPyBeginAllowThreads();
3809 result = (long)wxGetElapsedTime(arg1);
3810
3811 wxPyEndAllowThreads(__tstate);
3812 if (PyErr_Occurred()) SWIG_fail;
3813 }
3814 {
3815 resultobj = SWIG_From_long((long)(result));
3816 }
3817 return resultobj;
3818 fail:
3819 return NULL;
3820 }
3821
3822
3823 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3824 PyObject *resultobj;
3825 int *arg1 = (int *) 0 ;
3826 int *arg2 = (int *) 0 ;
3827 int temp1 ;
3828 int res1 = 0 ;
3829 int temp2 ;
3830 int res2 = 0 ;
3831 char *kwnames[] = {
3832 NULL
3833 };
3834
3835 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3836 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3838 {
3839 if (!wxPyCheckForApp()) SWIG_fail;
3840 PyThreadState* __tstate = wxPyBeginAllowThreads();
3841 wxGetMousePosition(arg1,arg2);
3842
3843 wxPyEndAllowThreads(__tstate);
3844 if (PyErr_Occurred()) SWIG_fail;
3845 }
3846 Py_INCREF(Py_None); resultobj = Py_None;
3847 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3848 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3849 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3850 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3851 return resultobj;
3852 fail:
3853 return NULL;
3854 }
3855
3856
3857 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3858 PyObject *resultobj;
3859 bool result;
3860 char *kwnames[] = {
3861 NULL
3862 };
3863
3864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3865 {
3866 PyThreadState* __tstate = wxPyBeginAllowThreads();
3867 result = (bool)wxIsBusy();
3868
3869 wxPyEndAllowThreads(__tstate);
3870 if (PyErr_Occurred()) SWIG_fail;
3871 }
3872 {
3873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3874 }
3875 return resultobj;
3876 fail:
3877 return NULL;
3878 }
3879
3880
3881 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3882 PyObject *resultobj;
3883 wxString result;
3884 char *kwnames[] = {
3885 NULL
3886 };
3887
3888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3889 {
3890 PyThreadState* __tstate = wxPyBeginAllowThreads();
3891 result = wxNow();
3892
3893 wxPyEndAllowThreads(__tstate);
3894 if (PyErr_Occurred()) SWIG_fail;
3895 }
3896 {
3897 #if wxUSE_UNICODE
3898 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3899 #else
3900 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3901 #endif
3902 }
3903 return resultobj;
3904 fail:
3905 return NULL;
3906 }
3907
3908
3909 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3910 PyObject *resultobj;
3911 wxString const &arg1_defvalue = wxPyEmptyString ;
3912 wxString *arg1 = (wxString *) &arg1_defvalue ;
3913 bool result;
3914 bool temp1 = false ;
3915 PyObject * obj0 = 0 ;
3916 char *kwnames[] = {
3917 (char *) "command", NULL
3918 };
3919
3920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3921 if (obj0) {
3922 {
3923 arg1 = wxString_in_helper(obj0);
3924 if (arg1 == NULL) SWIG_fail;
3925 temp1 = true;
3926 }
3927 }
3928 {
3929 PyThreadState* __tstate = wxPyBeginAllowThreads();
3930 result = (bool)wxShell((wxString const &)*arg1);
3931
3932 wxPyEndAllowThreads(__tstate);
3933 if (PyErr_Occurred()) SWIG_fail;
3934 }
3935 {
3936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3937 }
3938 {
3939 if (temp1)
3940 delete arg1;
3941 }
3942 return resultobj;
3943 fail:
3944 {
3945 if (temp1)
3946 delete arg1;
3947 }
3948 return NULL;
3949 }
3950
3951
3952 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3953 PyObject *resultobj;
3954 char *kwnames[] = {
3955 NULL
3956 };
3957
3958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3959 {
3960 PyThreadState* __tstate = wxPyBeginAllowThreads();
3961 wxStartTimer();
3962
3963 wxPyEndAllowThreads(__tstate);
3964 if (PyErr_Occurred()) SWIG_fail;
3965 }
3966 Py_INCREF(Py_None); resultobj = Py_None;
3967 return resultobj;
3968 fail:
3969 return NULL;
3970 }
3971
3972
3973 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3974 PyObject *resultobj;
3975 int *arg1 = (int *) 0 ;
3976 int *arg2 = (int *) 0 ;
3977 int result;
3978 int temp1 ;
3979 int res1 = 0 ;
3980 int temp2 ;
3981 int res2 = 0 ;
3982 char *kwnames[] = {
3983 NULL
3984 };
3985
3986 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3987 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3989 {
3990 PyThreadState* __tstate = wxPyBeginAllowThreads();
3991 result = (int)wxGetOsVersion(arg1,arg2);
3992
3993 wxPyEndAllowThreads(__tstate);
3994 if (PyErr_Occurred()) SWIG_fail;
3995 }
3996 {
3997 resultobj = SWIG_From_int((int)(result));
3998 }
3999 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4000 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4001 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4002 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4003 return resultobj;
4004 fail:
4005 return NULL;
4006 }
4007
4008
4009 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4010 PyObject *resultobj;
4011 wxString result;
4012 char *kwnames[] = {
4013 NULL
4014 };
4015
4016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4017 {
4018 PyThreadState* __tstate = wxPyBeginAllowThreads();
4019 result = wxGetOsDescription();
4020
4021 wxPyEndAllowThreads(__tstate);
4022 if (PyErr_Occurred()) SWIG_fail;
4023 }
4024 {
4025 #if wxUSE_UNICODE
4026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4027 #else
4028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4029 #endif
4030 }
4031 return resultobj;
4032 fail:
4033 return NULL;
4034 }
4035
4036
4037 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4038 PyObject *resultobj;
4039 long result;
4040 char *kwnames[] = {
4041 NULL
4042 };
4043
4044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4045 {
4046 PyThreadState* __tstate = wxPyBeginAllowThreads();
4047 result = (long)wxGetFreeMemory();
4048
4049 wxPyEndAllowThreads(__tstate);
4050 if (PyErr_Occurred()) SWIG_fail;
4051 }
4052 {
4053 resultobj = SWIG_From_long((long)(result));
4054 }
4055 return resultobj;
4056 fail:
4057 return NULL;
4058 }
4059
4060
4061 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4062 PyObject *resultobj;
4063 wxShutdownFlags arg1 ;
4064 bool result;
4065 PyObject * obj0 = 0 ;
4066 char *kwnames[] = {
4067 (char *) "wFlags", NULL
4068 };
4069
4070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4071 {
4072 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4073 if (SWIG_arg_fail(1)) SWIG_fail;
4074 }
4075 {
4076 if (!wxPyCheckForApp()) SWIG_fail;
4077 PyThreadState* __tstate = wxPyBeginAllowThreads();
4078 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4079
4080 wxPyEndAllowThreads(__tstate);
4081 if (PyErr_Occurred()) SWIG_fail;
4082 }
4083 {
4084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4085 }
4086 return resultobj;
4087 fail:
4088 return NULL;
4089 }
4090
4091
4092 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4093 PyObject *resultobj;
4094 int arg1 ;
4095 PyObject * obj0 = 0 ;
4096 char *kwnames[] = {
4097 (char *) "secs", NULL
4098 };
4099
4100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4101 {
4102 arg1 = (int)(SWIG_As_int(obj0));
4103 if (SWIG_arg_fail(1)) SWIG_fail;
4104 }
4105 {
4106 PyThreadState* __tstate = wxPyBeginAllowThreads();
4107 wxSleep(arg1);
4108
4109 wxPyEndAllowThreads(__tstate);
4110 if (PyErr_Occurred()) SWIG_fail;
4111 }
4112 Py_INCREF(Py_None); resultobj = Py_None;
4113 return resultobj;
4114 fail:
4115 return NULL;
4116 }
4117
4118
4119 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4120 PyObject *resultobj;
4121 unsigned long arg1 ;
4122 PyObject * obj0 = 0 ;
4123 char *kwnames[] = {
4124 (char *) "milliseconds", NULL
4125 };
4126
4127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4128 {
4129 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4130 if (SWIG_arg_fail(1)) SWIG_fail;
4131 }
4132 {
4133 PyThreadState* __tstate = wxPyBeginAllowThreads();
4134 wxMilliSleep(arg1);
4135
4136 wxPyEndAllowThreads(__tstate);
4137 if (PyErr_Occurred()) SWIG_fail;
4138 }
4139 Py_INCREF(Py_None); resultobj = Py_None;
4140 return resultobj;
4141 fail:
4142 return NULL;
4143 }
4144
4145
4146 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4147 PyObject *resultobj;
4148 unsigned long arg1 ;
4149 PyObject * obj0 = 0 ;
4150 char *kwnames[] = {
4151 (char *) "microseconds", NULL
4152 };
4153
4154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4155 {
4156 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4157 if (SWIG_arg_fail(1)) SWIG_fail;
4158 }
4159 {
4160 PyThreadState* __tstate = wxPyBeginAllowThreads();
4161 wxMicroSleep(arg1);
4162
4163 wxPyEndAllowThreads(__tstate);
4164 if (PyErr_Occurred()) SWIG_fail;
4165 }
4166 Py_INCREF(Py_None); resultobj = Py_None;
4167 return resultobj;
4168 fail:
4169 return NULL;
4170 }
4171
4172
4173 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4174 PyObject *resultobj;
4175 bool arg1 ;
4176 PyObject * obj0 = 0 ;
4177 char *kwnames[] = {
4178 (char *) "enable", NULL
4179 };
4180
4181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4182 {
4183 arg1 = (bool)(SWIG_As_bool(obj0));
4184 if (SWIG_arg_fail(1)) SWIG_fail;
4185 }
4186 {
4187 PyThreadState* __tstate = wxPyBeginAllowThreads();
4188 wxEnableTopLevelWindows(arg1);
4189
4190 wxPyEndAllowThreads(__tstate);
4191 if (PyErr_Occurred()) SWIG_fail;
4192 }
4193 Py_INCREF(Py_None); resultobj = Py_None;
4194 return resultobj;
4195 fail:
4196 return NULL;
4197 }
4198
4199
4200 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4201 PyObject *resultobj;
4202 wxString *arg1 = 0 ;
4203 wxString result;
4204 bool temp1 = false ;
4205 PyObject * obj0 = 0 ;
4206 char *kwnames[] = {
4207 (char *) "in", NULL
4208 };
4209
4210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4211 {
4212 arg1 = wxString_in_helper(obj0);
4213 if (arg1 == NULL) SWIG_fail;
4214 temp1 = true;
4215 }
4216 {
4217 PyThreadState* __tstate = wxPyBeginAllowThreads();
4218 result = wxStripMenuCodes((wxString const &)*arg1);
4219
4220 wxPyEndAllowThreads(__tstate);
4221 if (PyErr_Occurred()) SWIG_fail;
4222 }
4223 {
4224 #if wxUSE_UNICODE
4225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4226 #else
4227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4228 #endif
4229 }
4230 {
4231 if (temp1)
4232 delete arg1;
4233 }
4234 return resultobj;
4235 fail:
4236 {
4237 if (temp1)
4238 delete arg1;
4239 }
4240 return NULL;
4241 }
4242
4243
4244 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4245 PyObject *resultobj;
4246 wxString result;
4247 char *kwnames[] = {
4248 NULL
4249 };
4250
4251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4252 {
4253 PyThreadState* __tstate = wxPyBeginAllowThreads();
4254 result = wxGetEmailAddress();
4255
4256 wxPyEndAllowThreads(__tstate);
4257 if (PyErr_Occurred()) SWIG_fail;
4258 }
4259 {
4260 #if wxUSE_UNICODE
4261 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4262 #else
4263 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4264 #endif
4265 }
4266 return resultobj;
4267 fail:
4268 return NULL;
4269 }
4270
4271
4272 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4273 PyObject *resultobj;
4274 wxString result;
4275 char *kwnames[] = {
4276 NULL
4277 };
4278
4279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4280 {
4281 PyThreadState* __tstate = wxPyBeginAllowThreads();
4282 result = wxGetHostName();
4283
4284 wxPyEndAllowThreads(__tstate);
4285 if (PyErr_Occurred()) SWIG_fail;
4286 }
4287 {
4288 #if wxUSE_UNICODE
4289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4290 #else
4291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4292 #endif
4293 }
4294 return resultobj;
4295 fail:
4296 return NULL;
4297 }
4298
4299
4300 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4301 PyObject *resultobj;
4302 wxString result;
4303 char *kwnames[] = {
4304 NULL
4305 };
4306
4307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4308 {
4309 PyThreadState* __tstate = wxPyBeginAllowThreads();
4310 result = wxGetFullHostName();
4311
4312 wxPyEndAllowThreads(__tstate);
4313 if (PyErr_Occurred()) SWIG_fail;
4314 }
4315 {
4316 #if wxUSE_UNICODE
4317 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4318 #else
4319 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4320 #endif
4321 }
4322 return resultobj;
4323 fail:
4324 return NULL;
4325 }
4326
4327
4328 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4329 PyObject *resultobj;
4330 wxString result;
4331 char *kwnames[] = {
4332 NULL
4333 };
4334
4335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4336 {
4337 PyThreadState* __tstate = wxPyBeginAllowThreads();
4338 result = wxGetUserId();
4339
4340 wxPyEndAllowThreads(__tstate);
4341 if (PyErr_Occurred()) SWIG_fail;
4342 }
4343 {
4344 #if wxUSE_UNICODE
4345 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4346 #else
4347 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4348 #endif
4349 }
4350 return resultobj;
4351 fail:
4352 return NULL;
4353 }
4354
4355
4356 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4357 PyObject *resultobj;
4358 wxString result;
4359 char *kwnames[] = {
4360 NULL
4361 };
4362
4363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4364 {
4365 PyThreadState* __tstate = wxPyBeginAllowThreads();
4366 result = wxGetUserName();
4367
4368 wxPyEndAllowThreads(__tstate);
4369 if (PyErr_Occurred()) SWIG_fail;
4370 }
4371 {
4372 #if wxUSE_UNICODE
4373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4374 #else
4375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4376 #endif
4377 }
4378 return resultobj;
4379 fail:
4380 return NULL;
4381 }
4382
4383
4384 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4385 PyObject *resultobj;
4386 wxString result;
4387 char *kwnames[] = {
4388 NULL
4389 };
4390
4391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4392 {
4393 PyThreadState* __tstate = wxPyBeginAllowThreads();
4394 result = wxGetHomeDir();
4395
4396 wxPyEndAllowThreads(__tstate);
4397 if (PyErr_Occurred()) SWIG_fail;
4398 }
4399 {
4400 #if wxUSE_UNICODE
4401 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4402 #else
4403 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4404 #endif
4405 }
4406 return resultobj;
4407 fail:
4408 return NULL;
4409 }
4410
4411
4412 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4413 PyObject *resultobj;
4414 wxString const &arg1_defvalue = wxPyEmptyString ;
4415 wxString *arg1 = (wxString *) &arg1_defvalue ;
4416 wxString result;
4417 bool temp1 = false ;
4418 PyObject * obj0 = 0 ;
4419 char *kwnames[] = {
4420 (char *) "user", NULL
4421 };
4422
4423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4424 if (obj0) {
4425 {
4426 arg1 = wxString_in_helper(obj0);
4427 if (arg1 == NULL) SWIG_fail;
4428 temp1 = true;
4429 }
4430 }
4431 {
4432 PyThreadState* __tstate = wxPyBeginAllowThreads();
4433 result = wxGetUserHome((wxString const &)*arg1);
4434
4435 wxPyEndAllowThreads(__tstate);
4436 if (PyErr_Occurred()) SWIG_fail;
4437 }
4438 {
4439 #if wxUSE_UNICODE
4440 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4441 #else
4442 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4443 #endif
4444 }
4445 {
4446 if (temp1)
4447 delete arg1;
4448 }
4449 return resultobj;
4450 fail:
4451 {
4452 if (temp1)
4453 delete arg1;
4454 }
4455 return NULL;
4456 }
4457
4458
4459 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4460 PyObject *resultobj;
4461 unsigned long result;
4462 char *kwnames[] = {
4463 NULL
4464 };
4465
4466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4467 {
4468 PyThreadState* __tstate = wxPyBeginAllowThreads();
4469 result = (unsigned long)wxGetProcessId();
4470
4471 wxPyEndAllowThreads(__tstate);
4472 if (PyErr_Occurred()) SWIG_fail;
4473 }
4474 {
4475 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4476 }
4477 return resultobj;
4478 fail:
4479 return NULL;
4480 }
4481
4482
4483 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4484 PyObject *resultobj;
4485 char *kwnames[] = {
4486 NULL
4487 };
4488
4489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4490 {
4491 PyThreadState* __tstate = wxPyBeginAllowThreads();
4492 wxTrap();
4493
4494 wxPyEndAllowThreads(__tstate);
4495 if (PyErr_Occurred()) SWIG_fail;
4496 }
4497 Py_INCREF(Py_None); resultobj = Py_None;
4498 return resultobj;
4499 fail:
4500 return NULL;
4501 }
4502
4503
4504 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4505 PyObject *resultobj;
4506 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4507 wxString *arg1 = (wxString *) &arg1_defvalue ;
4508 wxString const &arg2_defvalue = wxPyEmptyString ;
4509 wxString *arg2 = (wxString *) &arg2_defvalue ;
4510 wxString const &arg3_defvalue = wxPyEmptyString ;
4511 wxString *arg3 = (wxString *) &arg3_defvalue ;
4512 wxString const &arg4_defvalue = wxPyEmptyString ;
4513 wxString *arg4 = (wxString *) &arg4_defvalue ;
4514 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4515 wxString *arg5 = (wxString *) &arg5_defvalue ;
4516 int arg6 = (int) 0 ;
4517 wxWindow *arg7 = (wxWindow *) NULL ;
4518 int arg8 = (int) -1 ;
4519 int arg9 = (int) -1 ;
4520 wxString result;
4521 bool temp1 = false ;
4522 bool temp2 = false ;
4523 bool temp3 = false ;
4524 bool temp4 = false ;
4525 bool temp5 = false ;
4526 PyObject * obj0 = 0 ;
4527 PyObject * obj1 = 0 ;
4528 PyObject * obj2 = 0 ;
4529 PyObject * obj3 = 0 ;
4530 PyObject * obj4 = 0 ;
4531 PyObject * obj5 = 0 ;
4532 PyObject * obj6 = 0 ;
4533 PyObject * obj7 = 0 ;
4534 PyObject * obj8 = 0 ;
4535 char *kwnames[] = {
4536 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4537 };
4538
4539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4540 if (obj0) {
4541 {
4542 arg1 = wxString_in_helper(obj0);
4543 if (arg1 == NULL) SWIG_fail;
4544 temp1 = true;
4545 }
4546 }
4547 if (obj1) {
4548 {
4549 arg2 = wxString_in_helper(obj1);
4550 if (arg2 == NULL) SWIG_fail;
4551 temp2 = true;
4552 }
4553 }
4554 if (obj2) {
4555 {
4556 arg3 = wxString_in_helper(obj2);
4557 if (arg3 == NULL) SWIG_fail;
4558 temp3 = true;
4559 }
4560 }
4561 if (obj3) {
4562 {
4563 arg4 = wxString_in_helper(obj3);
4564 if (arg4 == NULL) SWIG_fail;
4565 temp4 = true;
4566 }
4567 }
4568 if (obj4) {
4569 {
4570 arg5 = wxString_in_helper(obj4);
4571 if (arg5 == NULL) SWIG_fail;
4572 temp5 = true;
4573 }
4574 }
4575 if (obj5) {
4576 {
4577 arg6 = (int)(SWIG_As_int(obj5));
4578 if (SWIG_arg_fail(6)) SWIG_fail;
4579 }
4580 }
4581 if (obj6) {
4582 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4583 if (SWIG_arg_fail(7)) SWIG_fail;
4584 }
4585 if (obj7) {
4586 {
4587 arg8 = (int)(SWIG_As_int(obj7));
4588 if (SWIG_arg_fail(8)) SWIG_fail;
4589 }
4590 }
4591 if (obj8) {
4592 {
4593 arg9 = (int)(SWIG_As_int(obj8));
4594 if (SWIG_arg_fail(9)) SWIG_fail;
4595 }
4596 }
4597 {
4598 if (!wxPyCheckForApp()) SWIG_fail;
4599 PyThreadState* __tstate = wxPyBeginAllowThreads();
4600 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4601
4602 wxPyEndAllowThreads(__tstate);
4603 if (PyErr_Occurred()) SWIG_fail;
4604 }
4605 {
4606 #if wxUSE_UNICODE
4607 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4608 #else
4609 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4610 #endif
4611 }
4612 {
4613 if (temp1)
4614 delete arg1;
4615 }
4616 {
4617 if (temp2)
4618 delete arg2;
4619 }
4620 {
4621 if (temp3)
4622 delete arg3;
4623 }
4624 {
4625 if (temp4)
4626 delete arg4;
4627 }
4628 {
4629 if (temp5)
4630 delete arg5;
4631 }
4632 return resultobj;
4633 fail:
4634 {
4635 if (temp1)
4636 delete arg1;
4637 }
4638 {
4639 if (temp2)
4640 delete arg2;
4641 }
4642 {
4643 if (temp3)
4644 delete arg3;
4645 }
4646 {
4647 if (temp4)
4648 delete arg4;
4649 }
4650 {
4651 if (temp5)
4652 delete arg5;
4653 }
4654 return NULL;
4655 }
4656
4657
4658 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4659 PyObject *resultobj;
4660 wxString *arg1 = 0 ;
4661 wxString *arg2 = 0 ;
4662 wxString const &arg3_defvalue = wxPyEmptyString ;
4663 wxString *arg3 = (wxString *) &arg3_defvalue ;
4664 wxWindow *arg4 = (wxWindow *) NULL ;
4665 wxString result;
4666 bool temp1 = false ;
4667 bool temp2 = false ;
4668 bool temp3 = false ;
4669 PyObject * obj0 = 0 ;
4670 PyObject * obj1 = 0 ;
4671 PyObject * obj2 = 0 ;
4672 PyObject * obj3 = 0 ;
4673 char *kwnames[] = {
4674 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4675 };
4676
4677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4678 {
4679 arg1 = wxString_in_helper(obj0);
4680 if (arg1 == NULL) SWIG_fail;
4681 temp1 = true;
4682 }
4683 {
4684 arg2 = wxString_in_helper(obj1);
4685 if (arg2 == NULL) SWIG_fail;
4686 temp2 = true;
4687 }
4688 if (obj2) {
4689 {
4690 arg3 = wxString_in_helper(obj2);
4691 if (arg3 == NULL) SWIG_fail;
4692 temp3 = true;
4693 }
4694 }
4695 if (obj3) {
4696 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4697 if (SWIG_arg_fail(4)) SWIG_fail;
4698 }
4699 {
4700 if (!wxPyCheckForApp()) SWIG_fail;
4701 PyThreadState* __tstate = wxPyBeginAllowThreads();
4702 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4703
4704 wxPyEndAllowThreads(__tstate);
4705 if (PyErr_Occurred()) SWIG_fail;
4706 }
4707 {
4708 #if wxUSE_UNICODE
4709 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4710 #else
4711 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4712 #endif
4713 }
4714 {
4715 if (temp1)
4716 delete arg1;
4717 }
4718 {
4719 if (temp2)
4720 delete arg2;
4721 }
4722 {
4723 if (temp3)
4724 delete arg3;
4725 }
4726 return resultobj;
4727 fail:
4728 {
4729 if (temp1)
4730 delete arg1;
4731 }
4732 {
4733 if (temp2)
4734 delete arg2;
4735 }
4736 {
4737 if (temp3)
4738 delete arg3;
4739 }
4740 return NULL;
4741 }
4742
4743
4744 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4745 PyObject *resultobj;
4746 wxString *arg1 = 0 ;
4747 wxString *arg2 = 0 ;
4748 wxString const &arg3_defvalue = wxPyEmptyString ;
4749 wxString *arg3 = (wxString *) &arg3_defvalue ;
4750 wxWindow *arg4 = (wxWindow *) NULL ;
4751 wxString result;
4752 bool temp1 = false ;
4753 bool temp2 = false ;
4754 bool temp3 = false ;
4755 PyObject * obj0 = 0 ;
4756 PyObject * obj1 = 0 ;
4757 PyObject * obj2 = 0 ;
4758 PyObject * obj3 = 0 ;
4759 char *kwnames[] = {
4760 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4761 };
4762
4763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4764 {
4765 arg1 = wxString_in_helper(obj0);
4766 if (arg1 == NULL) SWIG_fail;
4767 temp1 = true;
4768 }
4769 {
4770 arg2 = wxString_in_helper(obj1);
4771 if (arg2 == NULL) SWIG_fail;
4772 temp2 = true;
4773 }
4774 if (obj2) {
4775 {
4776 arg3 = wxString_in_helper(obj2);
4777 if (arg3 == NULL) SWIG_fail;
4778 temp3 = true;
4779 }
4780 }
4781 if (obj3) {
4782 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4783 if (SWIG_arg_fail(4)) SWIG_fail;
4784 }
4785 {
4786 if (!wxPyCheckForApp()) SWIG_fail;
4787 PyThreadState* __tstate = wxPyBeginAllowThreads();
4788 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4789
4790 wxPyEndAllowThreads(__tstate);
4791 if (PyErr_Occurred()) SWIG_fail;
4792 }
4793 {
4794 #if wxUSE_UNICODE
4795 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4796 #else
4797 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4798 #endif
4799 }
4800 {
4801 if (temp1)
4802 delete arg1;
4803 }
4804 {
4805 if (temp2)
4806 delete arg2;
4807 }
4808 {
4809 if (temp3)
4810 delete arg3;
4811 }
4812 return resultobj;
4813 fail:
4814 {
4815 if (temp1)
4816 delete arg1;
4817 }
4818 {
4819 if (temp2)
4820 delete arg2;
4821 }
4822 {
4823 if (temp3)
4824 delete arg3;
4825 }
4826 return NULL;
4827 }
4828
4829
4830 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4831 PyObject *resultobj;
4832 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4833 wxString *arg1 = (wxString *) &arg1_defvalue ;
4834 wxString const &arg2_defvalue = wxPyEmptyString ;
4835 wxString *arg2 = (wxString *) &arg2_defvalue ;
4836 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4837 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4838 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4839 wxWindow *arg5 = (wxWindow *) NULL ;
4840 wxString result;
4841 bool temp1 = false ;
4842 bool temp2 = false ;
4843 wxPoint temp4 ;
4844 PyObject * obj0 = 0 ;
4845 PyObject * obj1 = 0 ;
4846 PyObject * obj2 = 0 ;
4847 PyObject * obj3 = 0 ;
4848 PyObject * obj4 = 0 ;
4849 char *kwnames[] = {
4850 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4851 };
4852
4853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4854 if (obj0) {
4855 {
4856 arg1 = wxString_in_helper(obj0);
4857 if (arg1 == NULL) SWIG_fail;
4858 temp1 = true;
4859 }
4860 }
4861 if (obj1) {
4862 {
4863 arg2 = wxString_in_helper(obj1);
4864 if (arg2 == NULL) SWIG_fail;
4865 temp2 = true;
4866 }
4867 }
4868 if (obj2) {
4869 {
4870 arg3 = (long)(SWIG_As_long(obj2));
4871 if (SWIG_arg_fail(3)) SWIG_fail;
4872 }
4873 }
4874 if (obj3) {
4875 {
4876 arg4 = &temp4;
4877 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4878 }
4879 }
4880 if (obj4) {
4881 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4882 if (SWIG_arg_fail(5)) SWIG_fail;
4883 }
4884 {
4885 if (!wxPyCheckForApp()) SWIG_fail;
4886 PyThreadState* __tstate = wxPyBeginAllowThreads();
4887 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4888
4889 wxPyEndAllowThreads(__tstate);
4890 if (PyErr_Occurred()) SWIG_fail;
4891 }
4892 {
4893 #if wxUSE_UNICODE
4894 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4895 #else
4896 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4897 #endif
4898 }
4899 {
4900 if (temp1)
4901 delete arg1;
4902 }
4903 {
4904 if (temp2)
4905 delete arg2;
4906 }
4907 return resultobj;
4908 fail:
4909 {
4910 if (temp1)
4911 delete arg1;
4912 }
4913 {
4914 if (temp2)
4915 delete arg2;
4916 }
4917 return NULL;
4918 }
4919
4920
4921 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4922 PyObject *resultobj;
4923 wxString *arg1 = 0 ;
4924 wxString const &arg2_defvalue = wxPyEmptyString ;
4925 wxString *arg2 = (wxString *) &arg2_defvalue ;
4926 wxString const &arg3_defvalue = wxPyEmptyString ;
4927 wxString *arg3 = (wxString *) &arg3_defvalue ;
4928 wxWindow *arg4 = (wxWindow *) NULL ;
4929 int arg5 = (int) -1 ;
4930 int arg6 = (int) -1 ;
4931 bool arg7 = (bool) true ;
4932 wxString result;
4933 bool temp1 = false ;
4934 bool temp2 = false ;
4935 bool temp3 = false ;
4936 PyObject * obj0 = 0 ;
4937 PyObject * obj1 = 0 ;
4938 PyObject * obj2 = 0 ;
4939 PyObject * obj3 = 0 ;
4940 PyObject * obj4 = 0 ;
4941 PyObject * obj5 = 0 ;
4942 PyObject * obj6 = 0 ;
4943 char *kwnames[] = {
4944 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4945 };
4946
4947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4948 {
4949 arg1 = wxString_in_helper(obj0);
4950 if (arg1 == NULL) SWIG_fail;
4951 temp1 = true;
4952 }
4953 if (obj1) {
4954 {
4955 arg2 = wxString_in_helper(obj1);
4956 if (arg2 == NULL) SWIG_fail;
4957 temp2 = true;
4958 }
4959 }
4960 if (obj2) {
4961 {
4962 arg3 = wxString_in_helper(obj2);
4963 if (arg3 == NULL) SWIG_fail;
4964 temp3 = true;
4965 }
4966 }
4967 if (obj3) {
4968 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4969 if (SWIG_arg_fail(4)) SWIG_fail;
4970 }
4971 if (obj4) {
4972 {
4973 arg5 = (int)(SWIG_As_int(obj4));
4974 if (SWIG_arg_fail(5)) SWIG_fail;
4975 }
4976 }
4977 if (obj5) {
4978 {
4979 arg6 = (int)(SWIG_As_int(obj5));
4980 if (SWIG_arg_fail(6)) SWIG_fail;
4981 }
4982 }
4983 if (obj6) {
4984 {
4985 arg7 = (bool)(SWIG_As_bool(obj6));
4986 if (SWIG_arg_fail(7)) SWIG_fail;
4987 }
4988 }
4989 {
4990 if (!wxPyCheckForApp()) SWIG_fail;
4991 PyThreadState* __tstate = wxPyBeginAllowThreads();
4992 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4993
4994 wxPyEndAllowThreads(__tstate);
4995 if (PyErr_Occurred()) SWIG_fail;
4996 }
4997 {
4998 #if wxUSE_UNICODE
4999 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5000 #else
5001 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5002 #endif
5003 }
5004 {
5005 if (temp1)
5006 delete arg1;
5007 }
5008 {
5009 if (temp2)
5010 delete arg2;
5011 }
5012 {
5013 if (temp3)
5014 delete arg3;
5015 }
5016 return resultobj;
5017 fail:
5018 {
5019 if (temp1)
5020 delete arg1;
5021 }
5022 {
5023 if (temp2)
5024 delete arg2;
5025 }
5026 {
5027 if (temp3)
5028 delete arg3;
5029 }
5030 return NULL;
5031 }
5032
5033
5034 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5035 PyObject *resultobj;
5036 wxString *arg1 = 0 ;
5037 wxString const &arg2_defvalue = wxPyEmptyString ;
5038 wxString *arg2 = (wxString *) &arg2_defvalue ;
5039 wxString const &arg3_defvalue = wxPyEmptyString ;
5040 wxString *arg3 = (wxString *) &arg3_defvalue ;
5041 wxWindow *arg4 = (wxWindow *) NULL ;
5042 wxString result;
5043 bool temp1 = false ;
5044 bool temp2 = false ;
5045 bool temp3 = false ;
5046 PyObject * obj0 = 0 ;
5047 PyObject * obj1 = 0 ;
5048 PyObject * obj2 = 0 ;
5049 PyObject * obj3 = 0 ;
5050 char *kwnames[] = {
5051 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5052 };
5053
5054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5055 {
5056 arg1 = wxString_in_helper(obj0);
5057 if (arg1 == NULL) SWIG_fail;
5058 temp1 = true;
5059 }
5060 if (obj1) {
5061 {
5062 arg2 = wxString_in_helper(obj1);
5063 if (arg2 == NULL) SWIG_fail;
5064 temp2 = true;
5065 }
5066 }
5067 if (obj2) {
5068 {
5069 arg3 = wxString_in_helper(obj2);
5070 if (arg3 == NULL) SWIG_fail;
5071 temp3 = true;
5072 }
5073 }
5074 if (obj3) {
5075 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5076 if (SWIG_arg_fail(4)) SWIG_fail;
5077 }
5078 {
5079 if (!wxPyCheckForApp()) SWIG_fail;
5080 PyThreadState* __tstate = wxPyBeginAllowThreads();
5081 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5082
5083 wxPyEndAllowThreads(__tstate);
5084 if (PyErr_Occurred()) SWIG_fail;
5085 }
5086 {
5087 #if wxUSE_UNICODE
5088 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5089 #else
5090 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5091 #endif
5092 }
5093 {
5094 if (temp1)
5095 delete arg1;
5096 }
5097 {
5098 if (temp2)
5099 delete arg2;
5100 }
5101 {
5102 if (temp3)
5103 delete arg3;
5104 }
5105 return resultobj;
5106 fail:
5107 {
5108 if (temp1)
5109 delete arg1;
5110 }
5111 {
5112 if (temp2)
5113 delete arg2;
5114 }
5115 {
5116 if (temp3)
5117 delete arg3;
5118 }
5119 return NULL;
5120 }
5121
5122
5123 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5124 PyObject *resultobj;
5125 wxString *arg1 = 0 ;
5126 wxString *arg2 = 0 ;
5127 int arg3 ;
5128 wxString *arg4 = (wxString *) 0 ;
5129 wxWindow *arg5 = (wxWindow *) NULL ;
5130 int arg6 = (int) -1 ;
5131 int arg7 = (int) -1 ;
5132 bool arg8 = (bool) true ;
5133 int arg9 = (int) 150 ;
5134 int arg10 = (int) 200 ;
5135 wxString result;
5136 bool temp1 = false ;
5137 bool temp2 = false ;
5138 PyObject * obj0 = 0 ;
5139 PyObject * obj1 = 0 ;
5140 PyObject * obj2 = 0 ;
5141 PyObject * obj3 = 0 ;
5142 PyObject * obj4 = 0 ;
5143 PyObject * obj5 = 0 ;
5144 PyObject * obj6 = 0 ;
5145 PyObject * obj7 = 0 ;
5146 PyObject * obj8 = 0 ;
5147 char *kwnames[] = {
5148 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5149 };
5150
5151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5152 {
5153 arg1 = wxString_in_helper(obj0);
5154 if (arg1 == NULL) SWIG_fail;
5155 temp1 = true;
5156 }
5157 {
5158 arg2 = wxString_in_helper(obj1);
5159 if (arg2 == NULL) SWIG_fail;
5160 temp2 = true;
5161 }
5162 {
5163 arg3 = PyList_Size(obj2);
5164 arg4 = wxString_LIST_helper(obj2);
5165 if (arg4 == NULL) SWIG_fail;
5166 }
5167 if (obj3) {
5168 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5169 if (SWIG_arg_fail(5)) SWIG_fail;
5170 }
5171 if (obj4) {
5172 {
5173 arg6 = (int)(SWIG_As_int(obj4));
5174 if (SWIG_arg_fail(6)) SWIG_fail;
5175 }
5176 }
5177 if (obj5) {
5178 {
5179 arg7 = (int)(SWIG_As_int(obj5));
5180 if (SWIG_arg_fail(7)) SWIG_fail;
5181 }
5182 }
5183 if (obj6) {
5184 {
5185 arg8 = (bool)(SWIG_As_bool(obj6));
5186 if (SWIG_arg_fail(8)) SWIG_fail;
5187 }
5188 }
5189 if (obj7) {
5190 {
5191 arg9 = (int)(SWIG_As_int(obj7));
5192 if (SWIG_arg_fail(9)) SWIG_fail;
5193 }
5194 }
5195 if (obj8) {
5196 {
5197 arg10 = (int)(SWIG_As_int(obj8));
5198 if (SWIG_arg_fail(10)) SWIG_fail;
5199 }
5200 }
5201 {
5202 if (!wxPyCheckForApp()) SWIG_fail;
5203 PyThreadState* __tstate = wxPyBeginAllowThreads();
5204 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5205
5206 wxPyEndAllowThreads(__tstate);
5207 if (PyErr_Occurred()) SWIG_fail;
5208 }
5209 {
5210 #if wxUSE_UNICODE
5211 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5212 #else
5213 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5214 #endif
5215 }
5216 {
5217 if (temp1)
5218 delete arg1;
5219 }
5220 {
5221 if (temp2)
5222 delete arg2;
5223 }
5224 {
5225 if (arg4) delete [] arg4;
5226 }
5227 return resultobj;
5228 fail:
5229 {
5230 if (temp1)
5231 delete arg1;
5232 }
5233 {
5234 if (temp2)
5235 delete arg2;
5236 }
5237 {
5238 if (arg4) delete [] arg4;
5239 }
5240 return NULL;
5241 }
5242
5243
5244 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5245 PyObject *resultobj;
5246 wxString *arg1 = 0 ;
5247 wxString *arg2 = 0 ;
5248 int arg3 ;
5249 wxString *arg4 = (wxString *) 0 ;
5250 wxWindow *arg5 = (wxWindow *) NULL ;
5251 int arg6 = (int) -1 ;
5252 int arg7 = (int) -1 ;
5253 bool arg8 = (bool) true ;
5254 int arg9 = (int) 150 ;
5255 int arg10 = (int) 200 ;
5256 int result;
5257 bool temp1 = false ;
5258 bool temp2 = false ;
5259 PyObject * obj0 = 0 ;
5260 PyObject * obj1 = 0 ;
5261 PyObject * obj2 = 0 ;
5262 PyObject * obj3 = 0 ;
5263 PyObject * obj4 = 0 ;
5264 PyObject * obj5 = 0 ;
5265 PyObject * obj6 = 0 ;
5266 PyObject * obj7 = 0 ;
5267 PyObject * obj8 = 0 ;
5268 char *kwnames[] = {
5269 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5270 };
5271
5272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5273 {
5274 arg1 = wxString_in_helper(obj0);
5275 if (arg1 == NULL) SWIG_fail;
5276 temp1 = true;
5277 }
5278 {
5279 arg2 = wxString_in_helper(obj1);
5280 if (arg2 == NULL) SWIG_fail;
5281 temp2 = true;
5282 }
5283 {
5284 arg3 = PyList_Size(obj2);
5285 arg4 = wxString_LIST_helper(obj2);
5286 if (arg4 == NULL) SWIG_fail;
5287 }
5288 if (obj3) {
5289 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5290 if (SWIG_arg_fail(5)) SWIG_fail;
5291 }
5292 if (obj4) {
5293 {
5294 arg6 = (int)(SWIG_As_int(obj4));
5295 if (SWIG_arg_fail(6)) SWIG_fail;
5296 }
5297 }
5298 if (obj5) {
5299 {
5300 arg7 = (int)(SWIG_As_int(obj5));
5301 if (SWIG_arg_fail(7)) SWIG_fail;
5302 }
5303 }
5304 if (obj6) {
5305 {
5306 arg8 = (bool)(SWIG_As_bool(obj6));
5307 if (SWIG_arg_fail(8)) SWIG_fail;
5308 }
5309 }
5310 if (obj7) {
5311 {
5312 arg9 = (int)(SWIG_As_int(obj7));
5313 if (SWIG_arg_fail(9)) SWIG_fail;
5314 }
5315 }
5316 if (obj8) {
5317 {
5318 arg10 = (int)(SWIG_As_int(obj8));
5319 if (SWIG_arg_fail(10)) SWIG_fail;
5320 }
5321 }
5322 {
5323 if (!wxPyCheckForApp()) SWIG_fail;
5324 PyThreadState* __tstate = wxPyBeginAllowThreads();
5325 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5326
5327 wxPyEndAllowThreads(__tstate);
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 {
5331 resultobj = SWIG_From_int((int)(result));
5332 }
5333 {
5334 if (temp1)
5335 delete arg1;
5336 }
5337 {
5338 if (temp2)
5339 delete arg2;
5340 }
5341 {
5342 if (arg4) delete [] arg4;
5343 }
5344 return resultobj;
5345 fail:
5346 {
5347 if (temp1)
5348 delete arg1;
5349 }
5350 {
5351 if (temp2)
5352 delete arg2;
5353 }
5354 {
5355 if (arg4) delete [] arg4;
5356 }
5357 return NULL;
5358 }
5359
5360
5361 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5362 PyObject *resultobj;
5363 wxString *arg1 = 0 ;
5364 wxString const &arg2_defvalue = wxPyEmptyString ;
5365 wxString *arg2 = (wxString *) &arg2_defvalue ;
5366 int arg3 = (int) wxOK|wxCENTRE ;
5367 wxWindow *arg4 = (wxWindow *) NULL ;
5368 int arg5 = (int) -1 ;
5369 int arg6 = (int) -1 ;
5370 int result;
5371 bool temp1 = false ;
5372 bool temp2 = false ;
5373 PyObject * obj0 = 0 ;
5374 PyObject * obj1 = 0 ;
5375 PyObject * obj2 = 0 ;
5376 PyObject * obj3 = 0 ;
5377 PyObject * obj4 = 0 ;
5378 PyObject * obj5 = 0 ;
5379 char *kwnames[] = {
5380 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5381 };
5382
5383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5384 {
5385 arg1 = wxString_in_helper(obj0);
5386 if (arg1 == NULL) SWIG_fail;
5387 temp1 = true;
5388 }
5389 if (obj1) {
5390 {
5391 arg2 = wxString_in_helper(obj1);
5392 if (arg2 == NULL) SWIG_fail;
5393 temp2 = true;
5394 }
5395 }
5396 if (obj2) {
5397 {
5398 arg3 = (int)(SWIG_As_int(obj2));
5399 if (SWIG_arg_fail(3)) SWIG_fail;
5400 }
5401 }
5402 if (obj3) {
5403 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5404 if (SWIG_arg_fail(4)) SWIG_fail;
5405 }
5406 if (obj4) {
5407 {
5408 arg5 = (int)(SWIG_As_int(obj4));
5409 if (SWIG_arg_fail(5)) SWIG_fail;
5410 }
5411 }
5412 if (obj5) {
5413 {
5414 arg6 = (int)(SWIG_As_int(obj5));
5415 if (SWIG_arg_fail(6)) SWIG_fail;
5416 }
5417 }
5418 {
5419 if (!wxPyCheckForApp()) SWIG_fail;
5420 PyThreadState* __tstate = wxPyBeginAllowThreads();
5421 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5422
5423 wxPyEndAllowThreads(__tstate);
5424 if (PyErr_Occurred()) SWIG_fail;
5425 }
5426 {
5427 resultobj = SWIG_From_int((int)(result));
5428 }
5429 {
5430 if (temp1)
5431 delete arg1;
5432 }
5433 {
5434 if (temp2)
5435 delete arg2;
5436 }
5437 return resultobj;
5438 fail:
5439 {
5440 if (temp1)
5441 delete arg1;
5442 }
5443 {
5444 if (temp2)
5445 delete arg2;
5446 }
5447 return NULL;
5448 }
5449
5450
5451 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5452 PyObject *resultobj;
5453 wxString *arg1 = 0 ;
5454 wxString *arg2 = 0 ;
5455 wxString *arg3 = 0 ;
5456 long arg4 ;
5457 long arg5 = (long) 0 ;
5458 long arg6 = (long) 100 ;
5459 wxWindow *arg7 = (wxWindow *) NULL ;
5460 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5461 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5462 long result;
5463 bool temp1 = false ;
5464 bool temp2 = false ;
5465 bool temp3 = false ;
5466 wxPoint temp8 ;
5467 PyObject * obj0 = 0 ;
5468 PyObject * obj1 = 0 ;
5469 PyObject * obj2 = 0 ;
5470 PyObject * obj3 = 0 ;
5471 PyObject * obj4 = 0 ;
5472 PyObject * obj5 = 0 ;
5473 PyObject * obj6 = 0 ;
5474 PyObject * obj7 = 0 ;
5475 char *kwnames[] = {
5476 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5477 };
5478
5479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5480 {
5481 arg1 = wxString_in_helper(obj0);
5482 if (arg1 == NULL) SWIG_fail;
5483 temp1 = true;
5484 }
5485 {
5486 arg2 = wxString_in_helper(obj1);
5487 if (arg2 == NULL) SWIG_fail;
5488 temp2 = true;
5489 }
5490 {
5491 arg3 = wxString_in_helper(obj2);
5492 if (arg3 == NULL) SWIG_fail;
5493 temp3 = true;
5494 }
5495 {
5496 arg4 = (long)(SWIG_As_long(obj3));
5497 if (SWIG_arg_fail(4)) SWIG_fail;
5498 }
5499 if (obj4) {
5500 {
5501 arg5 = (long)(SWIG_As_long(obj4));
5502 if (SWIG_arg_fail(5)) SWIG_fail;
5503 }
5504 }
5505 if (obj5) {
5506 {
5507 arg6 = (long)(SWIG_As_long(obj5));
5508 if (SWIG_arg_fail(6)) SWIG_fail;
5509 }
5510 }
5511 if (obj6) {
5512 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5513 if (SWIG_arg_fail(7)) SWIG_fail;
5514 }
5515 if (obj7) {
5516 {
5517 arg8 = &temp8;
5518 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5519 }
5520 }
5521 {
5522 if (!wxPyCheckForApp()) SWIG_fail;
5523 PyThreadState* __tstate = wxPyBeginAllowThreads();
5524 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5525
5526 wxPyEndAllowThreads(__tstate);
5527 if (PyErr_Occurred()) SWIG_fail;
5528 }
5529 {
5530 resultobj = SWIG_From_long((long)(result));
5531 }
5532 {
5533 if (temp1)
5534 delete arg1;
5535 }
5536 {
5537 if (temp2)
5538 delete arg2;
5539 }
5540 {
5541 if (temp3)
5542 delete arg3;
5543 }
5544 return resultobj;
5545 fail:
5546 {
5547 if (temp1)
5548 delete arg1;
5549 }
5550 {
5551 if (temp2)
5552 delete arg2;
5553 }
5554 {
5555 if (temp3)
5556 delete arg3;
5557 }
5558 return NULL;
5559 }
5560
5561
5562 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5563 PyObject *resultobj;
5564 bool result;
5565 char *kwnames[] = {
5566 NULL
5567 };
5568
5569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5570 {
5571 if (!wxPyCheckForApp()) SWIG_fail;
5572 PyThreadState* __tstate = wxPyBeginAllowThreads();
5573 result = (bool)wxColourDisplay();
5574
5575 wxPyEndAllowThreads(__tstate);
5576 if (PyErr_Occurred()) SWIG_fail;
5577 }
5578 {
5579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5580 }
5581 return resultobj;
5582 fail:
5583 return NULL;
5584 }
5585
5586
5587 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5588 PyObject *resultobj;
5589 int result;
5590 char *kwnames[] = {
5591 NULL
5592 };
5593
5594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5595 {
5596 if (!wxPyCheckForApp()) SWIG_fail;
5597 PyThreadState* __tstate = wxPyBeginAllowThreads();
5598 result = (int)wxDisplayDepth();
5599
5600 wxPyEndAllowThreads(__tstate);
5601 if (PyErr_Occurred()) SWIG_fail;
5602 }
5603 {
5604 resultobj = SWIG_From_int((int)(result));
5605 }
5606 return resultobj;
5607 fail:
5608 return NULL;
5609 }
5610
5611
5612 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5613 PyObject *resultobj;
5614 int result;
5615 char *kwnames[] = {
5616 NULL
5617 };
5618
5619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5620 {
5621 if (!wxPyCheckForApp()) SWIG_fail;
5622 PyThreadState* __tstate = wxPyBeginAllowThreads();
5623 result = (int)wxGetDisplayDepth();
5624
5625 wxPyEndAllowThreads(__tstate);
5626 if (PyErr_Occurred()) SWIG_fail;
5627 }
5628 {
5629 resultobj = SWIG_From_int((int)(result));
5630 }
5631 return resultobj;
5632 fail:
5633 return NULL;
5634 }
5635
5636
5637 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5638 PyObject *resultobj;
5639 int *arg1 = (int *) 0 ;
5640 int *arg2 = (int *) 0 ;
5641 int temp1 ;
5642 int res1 = 0 ;
5643 int temp2 ;
5644 int res2 = 0 ;
5645 char *kwnames[] = {
5646 NULL
5647 };
5648
5649 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5650 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5652 {
5653 if (!wxPyCheckForApp()) SWIG_fail;
5654 PyThreadState* __tstate = wxPyBeginAllowThreads();
5655 wxDisplaySize(arg1,arg2);
5656
5657 wxPyEndAllowThreads(__tstate);
5658 if (PyErr_Occurred()) SWIG_fail;
5659 }
5660 Py_INCREF(Py_None); resultobj = Py_None;
5661 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5662 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5663 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5664 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5665 return resultobj;
5666 fail:
5667 return NULL;
5668 }
5669
5670
5671 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5672 PyObject *resultobj;
5673 wxSize result;
5674 char *kwnames[] = {
5675 NULL
5676 };
5677
5678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5679 {
5680 if (!wxPyCheckForApp()) SWIG_fail;
5681 PyThreadState* __tstate = wxPyBeginAllowThreads();
5682 result = wxGetDisplaySize();
5683
5684 wxPyEndAllowThreads(__tstate);
5685 if (PyErr_Occurred()) SWIG_fail;
5686 }
5687 {
5688 wxSize * resultptr;
5689 resultptr = new wxSize((wxSize &)(result));
5690 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5691 }
5692 return resultobj;
5693 fail:
5694 return NULL;
5695 }
5696
5697
5698 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5699 PyObject *resultobj;
5700 int *arg1 = (int *) 0 ;
5701 int *arg2 = (int *) 0 ;
5702 int temp1 ;
5703 int res1 = 0 ;
5704 int temp2 ;
5705 int res2 = 0 ;
5706 char *kwnames[] = {
5707 NULL
5708 };
5709
5710 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5711 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5713 {
5714 if (!wxPyCheckForApp()) SWIG_fail;
5715 PyThreadState* __tstate = wxPyBeginAllowThreads();
5716 wxDisplaySizeMM(arg1,arg2);
5717
5718 wxPyEndAllowThreads(__tstate);
5719 if (PyErr_Occurred()) SWIG_fail;
5720 }
5721 Py_INCREF(Py_None); resultobj = Py_None;
5722 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5723 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5724 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5725 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5726 return resultobj;
5727 fail:
5728 return NULL;
5729 }
5730
5731
5732 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5733 PyObject *resultobj;
5734 wxSize result;
5735 char *kwnames[] = {
5736 NULL
5737 };
5738
5739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5740 {
5741 if (!wxPyCheckForApp()) SWIG_fail;
5742 PyThreadState* __tstate = wxPyBeginAllowThreads();
5743 result = wxGetDisplaySizeMM();
5744
5745 wxPyEndAllowThreads(__tstate);
5746 if (PyErr_Occurred()) SWIG_fail;
5747 }
5748 {
5749 wxSize * resultptr;
5750 resultptr = new wxSize((wxSize &)(result));
5751 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5752 }
5753 return resultobj;
5754 fail:
5755 return NULL;
5756 }
5757
5758
5759 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5760 PyObject *resultobj;
5761 int *arg1 = (int *) 0 ;
5762 int *arg2 = (int *) 0 ;
5763 int *arg3 = (int *) 0 ;
5764 int *arg4 = (int *) 0 ;
5765 int temp1 ;
5766 int res1 = 0 ;
5767 int temp2 ;
5768 int res2 = 0 ;
5769 int temp3 ;
5770 int res3 = 0 ;
5771 int temp4 ;
5772 int res4 = 0 ;
5773 char *kwnames[] = {
5774 NULL
5775 };
5776
5777 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5778 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5779 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5780 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5782 {
5783 if (!wxPyCheckForApp()) SWIG_fail;
5784 PyThreadState* __tstate = wxPyBeginAllowThreads();
5785 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5786
5787 wxPyEndAllowThreads(__tstate);
5788 if (PyErr_Occurred()) SWIG_fail;
5789 }
5790 Py_INCREF(Py_None); resultobj = Py_None;
5791 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5792 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5793 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5794 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5795 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5796 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5797 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5798 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5799 return resultobj;
5800 fail:
5801 return NULL;
5802 }
5803
5804
5805 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5806 PyObject *resultobj;
5807 wxRect result;
5808 char *kwnames[] = {
5809 NULL
5810 };
5811
5812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5813 {
5814 if (!wxPyCheckForApp()) SWIG_fail;
5815 PyThreadState* __tstate = wxPyBeginAllowThreads();
5816 result = wxGetClientDisplayRect();
5817
5818 wxPyEndAllowThreads(__tstate);
5819 if (PyErr_Occurred()) SWIG_fail;
5820 }
5821 {
5822 wxRect * resultptr;
5823 resultptr = new wxRect((wxRect &)(result));
5824 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5825 }
5826 return resultobj;
5827 fail:
5828 return NULL;
5829 }
5830
5831
5832 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5833 PyObject *resultobj;
5834 wxCursor *arg1 = 0 ;
5835 PyObject * obj0 = 0 ;
5836 char *kwnames[] = {
5837 (char *) "cursor", NULL
5838 };
5839
5840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5841 {
5842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5843 if (SWIG_arg_fail(1)) SWIG_fail;
5844 if (arg1 == NULL) {
5845 SWIG_null_ref("wxCursor");
5846 }
5847 if (SWIG_arg_fail(1)) SWIG_fail;
5848 }
5849 {
5850 if (!wxPyCheckForApp()) SWIG_fail;
5851 PyThreadState* __tstate = wxPyBeginAllowThreads();
5852 wxSetCursor(*arg1);
5853
5854 wxPyEndAllowThreads(__tstate);
5855 if (PyErr_Occurred()) SWIG_fail;
5856 }
5857 Py_INCREF(Py_None); resultobj = Py_None;
5858 return resultobj;
5859 fail:
5860 return NULL;
5861 }
5862
5863
5864 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5865 PyObject *resultobj;
5866 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5867 PyObject * obj0 = 0 ;
5868 char *kwnames[] = {
5869 (char *) "cursor", NULL
5870 };
5871
5872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5873 if (obj0) {
5874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5875 if (SWIG_arg_fail(1)) SWIG_fail;
5876 }
5877 {
5878 if (!wxPyCheckForApp()) SWIG_fail;
5879 PyThreadState* __tstate = wxPyBeginAllowThreads();
5880 wxBeginBusyCursor(arg1);
5881
5882 wxPyEndAllowThreads(__tstate);
5883 if (PyErr_Occurred()) SWIG_fail;
5884 }
5885 Py_INCREF(Py_None); resultobj = Py_None;
5886 return resultobj;
5887 fail:
5888 return NULL;
5889 }
5890
5891
5892 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5893 PyObject *resultobj;
5894 wxWindow *result;
5895 char *kwnames[] = {
5896 NULL
5897 };
5898
5899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5900 {
5901 if (!wxPyCheckForApp()) SWIG_fail;
5902 PyThreadState* __tstate = wxPyBeginAllowThreads();
5903 result = (wxWindow *)wxGetActiveWindow();
5904
5905 wxPyEndAllowThreads(__tstate);
5906 if (PyErr_Occurred()) SWIG_fail;
5907 }
5908 {
5909 resultobj = wxPyMake_wxObject(result, 0);
5910 }
5911 return resultobj;
5912 fail:
5913 return NULL;
5914 }
5915
5916
5917 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5918 PyObject *resultobj;
5919 wxPoint *arg1 = 0 ;
5920 wxWindow *result;
5921 wxPoint temp1 ;
5922 PyObject * obj0 = 0 ;
5923 char *kwnames[] = {
5924 (char *) "pt", NULL
5925 };
5926
5927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5928 {
5929 arg1 = &temp1;
5930 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5931 }
5932 {
5933 if (!wxPyCheckForApp()) SWIG_fail;
5934 PyThreadState* __tstate = wxPyBeginAllowThreads();
5935 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5936
5937 wxPyEndAllowThreads(__tstate);
5938 if (PyErr_Occurred()) SWIG_fail;
5939 }
5940 {
5941 resultobj = wxPyMake_wxObject(result, 0);
5942 }
5943 return resultobj;
5944 fail:
5945 return NULL;
5946 }
5947
5948
5949 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5950 PyObject *resultobj;
5951 wxPoint *arg1 = 0 ;
5952 wxWindow *result;
5953 wxPoint temp1 ;
5954 PyObject * obj0 = 0 ;
5955 char *kwnames[] = {
5956 (char *) "pt", NULL
5957 };
5958
5959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5960 {
5961 arg1 = &temp1;
5962 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5963 }
5964 {
5965 if (!wxPyCheckForApp()) SWIG_fail;
5966 PyThreadState* __tstate = wxPyBeginAllowThreads();
5967 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5968
5969 wxPyEndAllowThreads(__tstate);
5970 if (PyErr_Occurred()) SWIG_fail;
5971 }
5972 {
5973 resultobj = wxPyMake_wxObject(result, 0);
5974 }
5975 return resultobj;
5976 fail:
5977 return NULL;
5978 }
5979
5980
5981 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5982 PyObject *resultobj;
5983 wxWindow *arg1 = (wxWindow *) 0 ;
5984 wxWindow *result;
5985 PyObject * obj0 = 0 ;
5986 char *kwnames[] = {
5987 (char *) "win", NULL
5988 };
5989
5990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5992 if (SWIG_arg_fail(1)) SWIG_fail;
5993 {
5994 if (!wxPyCheckForApp()) SWIG_fail;
5995 PyThreadState* __tstate = wxPyBeginAllowThreads();
5996 result = (wxWindow *)wxGetTopLevelParent(arg1);
5997
5998 wxPyEndAllowThreads(__tstate);
5999 if (PyErr_Occurred()) SWIG_fail;
6000 }
6001 {
6002 resultobj = wxPyMake_wxObject(result, 0);
6003 }
6004 return resultobj;
6005 fail:
6006 return NULL;
6007 }
6008
6009
6010 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
6011 PyObject *resultobj;
6012 wxString *arg1 = 0 ;
6013 bool result;
6014 bool temp1 = false ;
6015 PyObject * obj0 = 0 ;
6016 char *kwnames[] = {
6017 (char *) "url", NULL
6018 };
6019
6020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
6021 {
6022 arg1 = wxString_in_helper(obj0);
6023 if (arg1 == NULL) SWIG_fail;
6024 temp1 = true;
6025 }
6026 {
6027 PyThreadState* __tstate = wxPyBeginAllowThreads();
6028 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
6029
6030 wxPyEndAllowThreads(__tstate);
6031 if (PyErr_Occurred()) SWIG_fail;
6032 }
6033 {
6034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6035 }
6036 {
6037 if (temp1)
6038 delete arg1;
6039 }
6040 return resultobj;
6041 fail:
6042 {
6043 if (temp1)
6044 delete arg1;
6045 }
6046 return NULL;
6047 }
6048
6049
6050 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6051 PyObject *resultobj;
6052 wxKeyCode arg1 ;
6053 bool result;
6054 PyObject * obj0 = 0 ;
6055 char *kwnames[] = {
6056 (char *) "key", NULL
6057 };
6058
6059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6060 {
6061 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6062 if (SWIG_arg_fail(1)) SWIG_fail;
6063 }
6064 {
6065 if (!wxPyCheckForApp()) SWIG_fail;
6066 PyThreadState* __tstate = wxPyBeginAllowThreads();
6067 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6068
6069 wxPyEndAllowThreads(__tstate);
6070 if (PyErr_Occurred()) SWIG_fail;
6071 }
6072 {
6073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6074 }
6075 return resultobj;
6076 fail:
6077 return NULL;
6078 }
6079
6080
6081 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6082 PyObject *resultobj;
6083 char *kwnames[] = {
6084 NULL
6085 };
6086
6087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6088 {
6089 if (!wxPyCheckForApp()) SWIG_fail;
6090 PyThreadState* __tstate = wxPyBeginAllowThreads();
6091 wxWakeUpMainThread();
6092
6093 wxPyEndAllowThreads(__tstate);
6094 if (PyErr_Occurred()) SWIG_fail;
6095 }
6096 Py_INCREF(Py_None); resultobj = Py_None;
6097 return resultobj;
6098 fail:
6099 return NULL;
6100 }
6101
6102
6103 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6104 PyObject *resultobj;
6105 char *kwnames[] = {
6106 NULL
6107 };
6108
6109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6110 {
6111 if (!wxPyCheckForApp()) SWIG_fail;
6112 PyThreadState* __tstate = wxPyBeginAllowThreads();
6113 wxMutexGuiEnter();
6114
6115 wxPyEndAllowThreads(__tstate);
6116 if (PyErr_Occurred()) SWIG_fail;
6117 }
6118 Py_INCREF(Py_None); resultobj = Py_None;
6119 return resultobj;
6120 fail:
6121 return NULL;
6122 }
6123
6124
6125 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6126 PyObject *resultobj;
6127 char *kwnames[] = {
6128 NULL
6129 };
6130
6131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6132 {
6133 if (!wxPyCheckForApp()) SWIG_fail;
6134 PyThreadState* __tstate = wxPyBeginAllowThreads();
6135 wxMutexGuiLeave();
6136
6137 wxPyEndAllowThreads(__tstate);
6138 if (PyErr_Occurred()) SWIG_fail;
6139 }
6140 Py_INCREF(Py_None); resultobj = Py_None;
6141 return resultobj;
6142 fail:
6143 return NULL;
6144 }
6145
6146
6147 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6148 PyObject *resultobj;
6149 wxMutexGuiLocker *result;
6150 char *kwnames[] = {
6151 NULL
6152 };
6153
6154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6155 {
6156 if (!wxPyCheckForApp()) SWIG_fail;
6157 PyThreadState* __tstate = wxPyBeginAllowThreads();
6158 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6159
6160 wxPyEndAllowThreads(__tstate);
6161 if (PyErr_Occurred()) SWIG_fail;
6162 }
6163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6164 return resultobj;
6165 fail:
6166 return NULL;
6167 }
6168
6169
6170 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6171 PyObject *resultobj;
6172 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6173 PyObject * obj0 = 0 ;
6174 char *kwnames[] = {
6175 (char *) "self", NULL
6176 };
6177
6178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6180 if (SWIG_arg_fail(1)) SWIG_fail;
6181 {
6182 PyThreadState* __tstate = wxPyBeginAllowThreads();
6183 delete arg1;
6184
6185 wxPyEndAllowThreads(__tstate);
6186 if (PyErr_Occurred()) SWIG_fail;
6187 }
6188 Py_INCREF(Py_None); resultobj = Py_None;
6189 return resultobj;
6190 fail:
6191 return NULL;
6192 }
6193
6194
6195 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6196 PyObject *obj;
6197 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6198 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6199 Py_INCREF(obj);
6200 return Py_BuildValue((char *)"");
6201 }
6202 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6203 PyObject *resultobj;
6204 bool result;
6205 char *kwnames[] = {
6206 NULL
6207 };
6208
6209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6210 {
6211 PyThreadState* __tstate = wxPyBeginAllowThreads();
6212 result = (bool)wxThread_IsMain();
6213
6214 wxPyEndAllowThreads(__tstate);
6215 if (PyErr_Occurred()) SWIG_fail;
6216 }
6217 {
6218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6219 }
6220 return resultobj;
6221 fail:
6222 return NULL;
6223 }
6224
6225
6226 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6227 PyObject *resultobj;
6228 wxString *arg1 = 0 ;
6229 wxToolTip *result;
6230 bool temp1 = false ;
6231 PyObject * obj0 = 0 ;
6232 char *kwnames[] = {
6233 (char *) "tip", NULL
6234 };
6235
6236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6237 {
6238 arg1 = wxString_in_helper(obj0);
6239 if (arg1 == NULL) SWIG_fail;
6240 temp1 = true;
6241 }
6242 {
6243 if (!wxPyCheckForApp()) SWIG_fail;
6244 PyThreadState* __tstate = wxPyBeginAllowThreads();
6245 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6246
6247 wxPyEndAllowThreads(__tstate);
6248 if (PyErr_Occurred()) SWIG_fail;
6249 }
6250 {
6251 resultobj = wxPyMake_wxObject(result, 1);
6252 }
6253 {
6254 if (temp1)
6255 delete arg1;
6256 }
6257 return resultobj;
6258 fail:
6259 {
6260 if (temp1)
6261 delete arg1;
6262 }
6263 return NULL;
6264 }
6265
6266
6267 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6268 PyObject *resultobj;
6269 wxToolTip *arg1 = (wxToolTip *) 0 ;
6270 wxString *arg2 = 0 ;
6271 bool temp2 = false ;
6272 PyObject * obj0 = 0 ;
6273 PyObject * obj1 = 0 ;
6274 char *kwnames[] = {
6275 (char *) "self",(char *) "tip", NULL
6276 };
6277
6278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6280 if (SWIG_arg_fail(1)) SWIG_fail;
6281 {
6282 arg2 = wxString_in_helper(obj1);
6283 if (arg2 == NULL) SWIG_fail;
6284 temp2 = true;
6285 }
6286 {
6287 PyThreadState* __tstate = wxPyBeginAllowThreads();
6288 (arg1)->SetTip((wxString const &)*arg2);
6289
6290 wxPyEndAllowThreads(__tstate);
6291 if (PyErr_Occurred()) SWIG_fail;
6292 }
6293 Py_INCREF(Py_None); resultobj = Py_None;
6294 {
6295 if (temp2)
6296 delete arg2;
6297 }
6298 return resultobj;
6299 fail:
6300 {
6301 if (temp2)
6302 delete arg2;
6303 }
6304 return NULL;
6305 }
6306
6307
6308 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6309 PyObject *resultobj;
6310 wxToolTip *arg1 = (wxToolTip *) 0 ;
6311 wxString result;
6312 PyObject * obj0 = 0 ;
6313 char *kwnames[] = {
6314 (char *) "self", NULL
6315 };
6316
6317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6319 if (SWIG_arg_fail(1)) SWIG_fail;
6320 {
6321 PyThreadState* __tstate = wxPyBeginAllowThreads();
6322 result = (arg1)->GetTip();
6323
6324 wxPyEndAllowThreads(__tstate);
6325 if (PyErr_Occurred()) SWIG_fail;
6326 }
6327 {
6328 #if wxUSE_UNICODE
6329 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6330 #else
6331 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6332 #endif
6333 }
6334 return resultobj;
6335 fail:
6336 return NULL;
6337 }
6338
6339
6340 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6341 PyObject *resultobj;
6342 wxToolTip *arg1 = (wxToolTip *) 0 ;
6343 wxWindow *result;
6344 PyObject * obj0 = 0 ;
6345 char *kwnames[] = {
6346 (char *) "self", NULL
6347 };
6348
6349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6351 if (SWIG_arg_fail(1)) SWIG_fail;
6352 {
6353 PyThreadState* __tstate = wxPyBeginAllowThreads();
6354 result = (wxWindow *)(arg1)->GetWindow();
6355
6356 wxPyEndAllowThreads(__tstate);
6357 if (PyErr_Occurred()) SWIG_fail;
6358 }
6359 {
6360 resultobj = wxPyMake_wxObject(result, 0);
6361 }
6362 return resultobj;
6363 fail:
6364 return NULL;
6365 }
6366
6367
6368 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6369 PyObject *resultobj;
6370 bool arg1 ;
6371 PyObject * obj0 = 0 ;
6372 char *kwnames[] = {
6373 (char *) "flag", NULL
6374 };
6375
6376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6377 {
6378 arg1 = (bool)(SWIG_As_bool(obj0));
6379 if (SWIG_arg_fail(1)) SWIG_fail;
6380 }
6381 {
6382 PyThreadState* __tstate = wxPyBeginAllowThreads();
6383 wxToolTip::Enable(arg1);
6384
6385 wxPyEndAllowThreads(__tstate);
6386 if (PyErr_Occurred()) SWIG_fail;
6387 }
6388 Py_INCREF(Py_None); resultobj = Py_None;
6389 return resultobj;
6390 fail:
6391 return NULL;
6392 }
6393
6394
6395 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6396 PyObject *resultobj;
6397 long arg1 ;
6398 PyObject * obj0 = 0 ;
6399 char *kwnames[] = {
6400 (char *) "milliseconds", NULL
6401 };
6402
6403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6404 {
6405 arg1 = (long)(SWIG_As_long(obj0));
6406 if (SWIG_arg_fail(1)) SWIG_fail;
6407 }
6408 {
6409 PyThreadState* __tstate = wxPyBeginAllowThreads();
6410 wxToolTip::SetDelay(arg1);
6411
6412 wxPyEndAllowThreads(__tstate);
6413 if (PyErr_Occurred()) SWIG_fail;
6414 }
6415 Py_INCREF(Py_None); resultobj = Py_None;
6416 return resultobj;
6417 fail:
6418 return NULL;
6419 }
6420
6421
6422 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6423 PyObject *obj;
6424 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6425 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6426 Py_INCREF(obj);
6427 return Py_BuildValue((char *)"");
6428 }
6429 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6430 PyObject *resultobj;
6431 wxWindow *arg1 = (wxWindow *) 0 ;
6432 wxSize *arg2 = 0 ;
6433 wxCaret *result;
6434 wxSize temp2 ;
6435 PyObject * obj0 = 0 ;
6436 PyObject * obj1 = 0 ;
6437 char *kwnames[] = {
6438 (char *) "window",(char *) "size", NULL
6439 };
6440
6441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6443 if (SWIG_arg_fail(1)) SWIG_fail;
6444 {
6445 arg2 = &temp2;
6446 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6447 }
6448 {
6449 if (!wxPyCheckForApp()) SWIG_fail;
6450 PyThreadState* __tstate = wxPyBeginAllowThreads();
6451 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6452
6453 wxPyEndAllowThreads(__tstate);
6454 if (PyErr_Occurred()) SWIG_fail;
6455 }
6456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6457 return resultobj;
6458 fail:
6459 return NULL;
6460 }
6461
6462
6463 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6464 PyObject *resultobj;
6465 wxCaret *arg1 = (wxCaret *) 0 ;
6466 PyObject * obj0 = 0 ;
6467 char *kwnames[] = {
6468 (char *) "self", NULL
6469 };
6470
6471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6473 if (SWIG_arg_fail(1)) SWIG_fail;
6474 {
6475 PyThreadState* __tstate = wxPyBeginAllowThreads();
6476 wxCaret_Destroy(arg1);
6477
6478 wxPyEndAllowThreads(__tstate);
6479 if (PyErr_Occurred()) SWIG_fail;
6480 }
6481 Py_INCREF(Py_None); resultobj = Py_None;
6482 return resultobj;
6483 fail:
6484 return NULL;
6485 }
6486
6487
6488 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6489 PyObject *resultobj;
6490 wxCaret *arg1 = (wxCaret *) 0 ;
6491 bool result;
6492 PyObject * obj0 = 0 ;
6493 char *kwnames[] = {
6494 (char *) "self", NULL
6495 };
6496
6497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6499 if (SWIG_arg_fail(1)) SWIG_fail;
6500 {
6501 PyThreadState* __tstate = wxPyBeginAllowThreads();
6502 result = (bool)(arg1)->IsOk();
6503
6504 wxPyEndAllowThreads(__tstate);
6505 if (PyErr_Occurred()) SWIG_fail;
6506 }
6507 {
6508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6509 }
6510 return resultobj;
6511 fail:
6512 return NULL;
6513 }
6514
6515
6516 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6517 PyObject *resultobj;
6518 wxCaret *arg1 = (wxCaret *) 0 ;
6519 bool result;
6520 PyObject * obj0 = 0 ;
6521 char *kwnames[] = {
6522 (char *) "self", NULL
6523 };
6524
6525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6527 if (SWIG_arg_fail(1)) SWIG_fail;
6528 {
6529 PyThreadState* __tstate = wxPyBeginAllowThreads();
6530 result = (bool)(arg1)->IsVisible();
6531
6532 wxPyEndAllowThreads(__tstate);
6533 if (PyErr_Occurred()) SWIG_fail;
6534 }
6535 {
6536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6537 }
6538 return resultobj;
6539 fail:
6540 return NULL;
6541 }
6542
6543
6544 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6545 PyObject *resultobj;
6546 wxCaret *arg1 = (wxCaret *) 0 ;
6547 wxPoint result;
6548 PyObject * obj0 = 0 ;
6549 char *kwnames[] = {
6550 (char *) "self", NULL
6551 };
6552
6553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6555 if (SWIG_arg_fail(1)) SWIG_fail;
6556 {
6557 PyThreadState* __tstate = wxPyBeginAllowThreads();
6558 result = (arg1)->GetPosition();
6559
6560 wxPyEndAllowThreads(__tstate);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 {
6564 wxPoint * resultptr;
6565 resultptr = new wxPoint((wxPoint &)(result));
6566 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6567 }
6568 return resultobj;
6569 fail:
6570 return NULL;
6571 }
6572
6573
6574 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6575 PyObject *resultobj;
6576 wxCaret *arg1 = (wxCaret *) 0 ;
6577 int *arg2 = (int *) 0 ;
6578 int *arg3 = (int *) 0 ;
6579 int temp2 ;
6580 int res2 = 0 ;
6581 int temp3 ;
6582 int res3 = 0 ;
6583 PyObject * obj0 = 0 ;
6584 char *kwnames[] = {
6585 (char *) "self", NULL
6586 };
6587
6588 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6589 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6592 if (SWIG_arg_fail(1)) SWIG_fail;
6593 {
6594 PyThreadState* __tstate = wxPyBeginAllowThreads();
6595 (arg1)->GetPosition(arg2,arg3);
6596
6597 wxPyEndAllowThreads(__tstate);
6598 if (PyErr_Occurred()) SWIG_fail;
6599 }
6600 Py_INCREF(Py_None); resultobj = Py_None;
6601 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6602 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6603 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6604 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6605 return resultobj;
6606 fail:
6607 return NULL;
6608 }
6609
6610
6611 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6612 PyObject *resultobj;
6613 wxCaret *arg1 = (wxCaret *) 0 ;
6614 wxSize result;
6615 PyObject * obj0 = 0 ;
6616 char *kwnames[] = {
6617 (char *) "self", NULL
6618 };
6619
6620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6622 if (SWIG_arg_fail(1)) SWIG_fail;
6623 {
6624 PyThreadState* __tstate = wxPyBeginAllowThreads();
6625 result = (arg1)->GetSize();
6626
6627 wxPyEndAllowThreads(__tstate);
6628 if (PyErr_Occurred()) SWIG_fail;
6629 }
6630 {
6631 wxSize * resultptr;
6632 resultptr = new wxSize((wxSize &)(result));
6633 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6634 }
6635 return resultobj;
6636 fail:
6637 return NULL;
6638 }
6639
6640
6641 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6642 PyObject *resultobj;
6643 wxCaret *arg1 = (wxCaret *) 0 ;
6644 int *arg2 = (int *) 0 ;
6645 int *arg3 = (int *) 0 ;
6646 int temp2 ;
6647 int res2 = 0 ;
6648 int temp3 ;
6649 int res3 = 0 ;
6650 PyObject * obj0 = 0 ;
6651 char *kwnames[] = {
6652 (char *) "self", NULL
6653 };
6654
6655 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6656 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6659 if (SWIG_arg_fail(1)) SWIG_fail;
6660 {
6661 PyThreadState* __tstate = wxPyBeginAllowThreads();
6662 (arg1)->GetSize(arg2,arg3);
6663
6664 wxPyEndAllowThreads(__tstate);
6665 if (PyErr_Occurred()) SWIG_fail;
6666 }
6667 Py_INCREF(Py_None); resultobj = Py_None;
6668 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6669 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6670 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6671 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6672 return resultobj;
6673 fail:
6674 return NULL;
6675 }
6676
6677
6678 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6679 PyObject *resultobj;
6680 wxCaret *arg1 = (wxCaret *) 0 ;
6681 wxWindow *result;
6682 PyObject * obj0 = 0 ;
6683 char *kwnames[] = {
6684 (char *) "self", NULL
6685 };
6686
6687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6689 if (SWIG_arg_fail(1)) SWIG_fail;
6690 {
6691 PyThreadState* __tstate = wxPyBeginAllowThreads();
6692 result = (wxWindow *)(arg1)->GetWindow();
6693
6694 wxPyEndAllowThreads(__tstate);
6695 if (PyErr_Occurred()) SWIG_fail;
6696 }
6697 {
6698 resultobj = wxPyMake_wxObject(result, 0);
6699 }
6700 return resultobj;
6701 fail:
6702 return NULL;
6703 }
6704
6705
6706 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6707 PyObject *resultobj;
6708 wxCaret *arg1 = (wxCaret *) 0 ;
6709 int arg2 ;
6710 int arg3 ;
6711 PyObject * obj0 = 0 ;
6712 PyObject * obj1 = 0 ;
6713 PyObject * obj2 = 0 ;
6714 char *kwnames[] = {
6715 (char *) "self",(char *) "x",(char *) "y", NULL
6716 };
6717
6718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6720 if (SWIG_arg_fail(1)) SWIG_fail;
6721 {
6722 arg2 = (int)(SWIG_As_int(obj1));
6723 if (SWIG_arg_fail(2)) SWIG_fail;
6724 }
6725 {
6726 arg3 = (int)(SWIG_As_int(obj2));
6727 if (SWIG_arg_fail(3)) SWIG_fail;
6728 }
6729 {
6730 PyThreadState* __tstate = wxPyBeginAllowThreads();
6731 (arg1)->Move(arg2,arg3);
6732
6733 wxPyEndAllowThreads(__tstate);
6734 if (PyErr_Occurred()) SWIG_fail;
6735 }
6736 Py_INCREF(Py_None); resultobj = Py_None;
6737 return resultobj;
6738 fail:
6739 return NULL;
6740 }
6741
6742
6743 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6744 PyObject *resultobj;
6745 wxCaret *arg1 = (wxCaret *) 0 ;
6746 wxPoint *arg2 = 0 ;
6747 wxPoint temp2 ;
6748 PyObject * obj0 = 0 ;
6749 PyObject * obj1 = 0 ;
6750 char *kwnames[] = {
6751 (char *) "self",(char *) "pt", NULL
6752 };
6753
6754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6756 if (SWIG_arg_fail(1)) SWIG_fail;
6757 {
6758 arg2 = &temp2;
6759 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6760 }
6761 {
6762 PyThreadState* __tstate = wxPyBeginAllowThreads();
6763 (arg1)->Move((wxPoint const &)*arg2);
6764
6765 wxPyEndAllowThreads(__tstate);
6766 if (PyErr_Occurred()) SWIG_fail;
6767 }
6768 Py_INCREF(Py_None); resultobj = Py_None;
6769 return resultobj;
6770 fail:
6771 return NULL;
6772 }
6773
6774
6775 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6776 PyObject *resultobj;
6777 wxCaret *arg1 = (wxCaret *) 0 ;
6778 int arg2 ;
6779 int arg3 ;
6780 PyObject * obj0 = 0 ;
6781 PyObject * obj1 = 0 ;
6782 PyObject * obj2 = 0 ;
6783 char *kwnames[] = {
6784 (char *) "self",(char *) "width",(char *) "height", NULL
6785 };
6786
6787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6789 if (SWIG_arg_fail(1)) SWIG_fail;
6790 {
6791 arg2 = (int)(SWIG_As_int(obj1));
6792 if (SWIG_arg_fail(2)) SWIG_fail;
6793 }
6794 {
6795 arg3 = (int)(SWIG_As_int(obj2));
6796 if (SWIG_arg_fail(3)) SWIG_fail;
6797 }
6798 {
6799 PyThreadState* __tstate = wxPyBeginAllowThreads();
6800 (arg1)->SetSize(arg2,arg3);
6801
6802 wxPyEndAllowThreads(__tstate);
6803 if (PyErr_Occurred()) SWIG_fail;
6804 }
6805 Py_INCREF(Py_None); resultobj = Py_None;
6806 return resultobj;
6807 fail:
6808 return NULL;
6809 }
6810
6811
6812 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6813 PyObject *resultobj;
6814 wxCaret *arg1 = (wxCaret *) 0 ;
6815 wxSize *arg2 = 0 ;
6816 wxSize temp2 ;
6817 PyObject * obj0 = 0 ;
6818 PyObject * obj1 = 0 ;
6819 char *kwnames[] = {
6820 (char *) "self",(char *) "size", NULL
6821 };
6822
6823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6825 if (SWIG_arg_fail(1)) SWIG_fail;
6826 {
6827 arg2 = &temp2;
6828 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6829 }
6830 {
6831 PyThreadState* __tstate = wxPyBeginAllowThreads();
6832 (arg1)->SetSize((wxSize const &)*arg2);
6833
6834 wxPyEndAllowThreads(__tstate);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 Py_INCREF(Py_None); resultobj = Py_None;
6838 return resultobj;
6839 fail:
6840 return NULL;
6841 }
6842
6843
6844 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6845 PyObject *resultobj;
6846 wxCaret *arg1 = (wxCaret *) 0 ;
6847 int arg2 = (int) true ;
6848 PyObject * obj0 = 0 ;
6849 PyObject * obj1 = 0 ;
6850 char *kwnames[] = {
6851 (char *) "self",(char *) "show", NULL
6852 };
6853
6854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6856 if (SWIG_arg_fail(1)) SWIG_fail;
6857 if (obj1) {
6858 {
6859 arg2 = (int)(SWIG_As_int(obj1));
6860 if (SWIG_arg_fail(2)) SWIG_fail;
6861 }
6862 }
6863 {
6864 PyThreadState* __tstate = wxPyBeginAllowThreads();
6865 (arg1)->Show(arg2);
6866
6867 wxPyEndAllowThreads(__tstate);
6868 if (PyErr_Occurred()) SWIG_fail;
6869 }
6870 Py_INCREF(Py_None); resultobj = Py_None;
6871 return resultobj;
6872 fail:
6873 return NULL;
6874 }
6875
6876
6877 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6878 PyObject *resultobj;
6879 wxCaret *arg1 = (wxCaret *) 0 ;
6880 PyObject * obj0 = 0 ;
6881 char *kwnames[] = {
6882 (char *) "self", NULL
6883 };
6884
6885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6887 if (SWIG_arg_fail(1)) SWIG_fail;
6888 {
6889 PyThreadState* __tstate = wxPyBeginAllowThreads();
6890 (arg1)->Hide();
6891
6892 wxPyEndAllowThreads(__tstate);
6893 if (PyErr_Occurred()) SWIG_fail;
6894 }
6895 Py_INCREF(Py_None); resultobj = Py_None;
6896 return resultobj;
6897 fail:
6898 return NULL;
6899 }
6900
6901
6902 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6903 PyObject *resultobj;
6904 int result;
6905 char *kwnames[] = {
6906 NULL
6907 };
6908
6909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6910 {
6911 PyThreadState* __tstate = wxPyBeginAllowThreads();
6912 result = (int)wxCaret::GetBlinkTime();
6913
6914 wxPyEndAllowThreads(__tstate);
6915 if (PyErr_Occurred()) SWIG_fail;
6916 }
6917 {
6918 resultobj = SWIG_From_int((int)(result));
6919 }
6920 return resultobj;
6921 fail:
6922 return NULL;
6923 }
6924
6925
6926 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6927 PyObject *resultobj;
6928 int arg1 ;
6929 PyObject * obj0 = 0 ;
6930 char *kwnames[] = {
6931 (char *) "milliseconds", NULL
6932 };
6933
6934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6935 {
6936 arg1 = (int)(SWIG_As_int(obj0));
6937 if (SWIG_arg_fail(1)) SWIG_fail;
6938 }
6939 {
6940 PyThreadState* __tstate = wxPyBeginAllowThreads();
6941 wxCaret::SetBlinkTime(arg1);
6942
6943 wxPyEndAllowThreads(__tstate);
6944 if (PyErr_Occurred()) SWIG_fail;
6945 }
6946 Py_INCREF(Py_None); resultobj = Py_None;
6947 return resultobj;
6948 fail:
6949 return NULL;
6950 }
6951
6952
6953 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6954 PyObject *obj;
6955 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6956 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6957 Py_INCREF(obj);
6958 return Py_BuildValue((char *)"");
6959 }
6960 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6961 PyObject *resultobj;
6962 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6963 wxBusyCursor *result;
6964 PyObject * obj0 = 0 ;
6965 char *kwnames[] = {
6966 (char *) "cursor", NULL
6967 };
6968
6969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6970 if (obj0) {
6971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6972 if (SWIG_arg_fail(1)) SWIG_fail;
6973 }
6974 {
6975 if (!wxPyCheckForApp()) SWIG_fail;
6976 PyThreadState* __tstate = wxPyBeginAllowThreads();
6977 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6978
6979 wxPyEndAllowThreads(__tstate);
6980 if (PyErr_Occurred()) SWIG_fail;
6981 }
6982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6983 return resultobj;
6984 fail:
6985 return NULL;
6986 }
6987
6988
6989 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6990 PyObject *resultobj;
6991 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6992 PyObject * obj0 = 0 ;
6993 char *kwnames[] = {
6994 (char *) "self", NULL
6995 };
6996
6997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6999 if (SWIG_arg_fail(1)) SWIG_fail;
7000 {
7001 PyThreadState* __tstate = wxPyBeginAllowThreads();
7002 delete arg1;
7003
7004 wxPyEndAllowThreads(__tstate);
7005 if (PyErr_Occurred()) SWIG_fail;
7006 }
7007 Py_INCREF(Py_None); resultobj = Py_None;
7008 return resultobj;
7009 fail:
7010 return NULL;
7011 }
7012
7013
7014 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
7015 PyObject *obj;
7016 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7017 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
7018 Py_INCREF(obj);
7019 return Py_BuildValue((char *)"");
7020 }
7021 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7022 PyObject *resultobj;
7023 wxWindow *arg1 = (wxWindow *) NULL ;
7024 wxWindowDisabler *result;
7025 PyObject * obj0 = 0 ;
7026 char *kwnames[] = {
7027 (char *) "winToSkip", NULL
7028 };
7029
7030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7031 if (obj0) {
7032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7033 if (SWIG_arg_fail(1)) SWIG_fail;
7034 }
7035 {
7036 if (!wxPyCheckForApp()) SWIG_fail;
7037 PyThreadState* __tstate = wxPyBeginAllowThreads();
7038 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7039
7040 wxPyEndAllowThreads(__tstate);
7041 if (PyErr_Occurred()) SWIG_fail;
7042 }
7043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7044 return resultobj;
7045 fail:
7046 return NULL;
7047 }
7048
7049
7050 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7051 PyObject *resultobj;
7052 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7053 PyObject * obj0 = 0 ;
7054 char *kwnames[] = {
7055 (char *) "self", NULL
7056 };
7057
7058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7060 if (SWIG_arg_fail(1)) SWIG_fail;
7061 {
7062 PyThreadState* __tstate = wxPyBeginAllowThreads();
7063 delete arg1;
7064
7065 wxPyEndAllowThreads(__tstate);
7066 if (PyErr_Occurred()) SWIG_fail;
7067 }
7068 Py_INCREF(Py_None); resultobj = Py_None;
7069 return resultobj;
7070 fail:
7071 return NULL;
7072 }
7073
7074
7075 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7076 PyObject *obj;
7077 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7078 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7079 Py_INCREF(obj);
7080 return Py_BuildValue((char *)"");
7081 }
7082 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7083 PyObject *resultobj;
7084 wxString *arg1 = 0 ;
7085 wxBusyInfo *result;
7086 bool temp1 = false ;
7087 PyObject * obj0 = 0 ;
7088 char *kwnames[] = {
7089 (char *) "message", NULL
7090 };
7091
7092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7093 {
7094 arg1 = wxString_in_helper(obj0);
7095 if (arg1 == NULL) SWIG_fail;
7096 temp1 = true;
7097 }
7098 {
7099 if (!wxPyCheckForApp()) SWIG_fail;
7100 PyThreadState* __tstate = wxPyBeginAllowThreads();
7101 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7102
7103 wxPyEndAllowThreads(__tstate);
7104 if (PyErr_Occurred()) SWIG_fail;
7105 }
7106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7107 {
7108 if (temp1)
7109 delete arg1;
7110 }
7111 return resultobj;
7112 fail:
7113 {
7114 if (temp1)
7115 delete arg1;
7116 }
7117 return NULL;
7118 }
7119
7120
7121 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7122 PyObject *resultobj;
7123 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7124 PyObject * obj0 = 0 ;
7125 char *kwnames[] = {
7126 (char *) "self", NULL
7127 };
7128
7129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7131 if (SWIG_arg_fail(1)) SWIG_fail;
7132 {
7133 PyThreadState* __tstate = wxPyBeginAllowThreads();
7134 delete arg1;
7135
7136 wxPyEndAllowThreads(__tstate);
7137 if (PyErr_Occurred()) SWIG_fail;
7138 }
7139 Py_INCREF(Py_None); resultobj = Py_None;
7140 return resultobj;
7141 fail:
7142 return NULL;
7143 }
7144
7145
7146 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7147 PyObject *obj;
7148 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7149 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7150 Py_INCREF(obj);
7151 return Py_BuildValue((char *)"");
7152 }
7153 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7154 PyObject *resultobj;
7155 wxStopWatch *result;
7156 char *kwnames[] = {
7157 NULL
7158 };
7159
7160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7161 {
7162 PyThreadState* __tstate = wxPyBeginAllowThreads();
7163 result = (wxStopWatch *)new wxStopWatch();
7164
7165 wxPyEndAllowThreads(__tstate);
7166 if (PyErr_Occurred()) SWIG_fail;
7167 }
7168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7169 return resultobj;
7170 fail:
7171 return NULL;
7172 }
7173
7174
7175 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7176 PyObject *resultobj;
7177 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7178 long arg2 = (long) 0 ;
7179 PyObject * obj0 = 0 ;
7180 PyObject * obj1 = 0 ;
7181 char *kwnames[] = {
7182 (char *) "self",(char *) "t0", NULL
7183 };
7184
7185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7187 if (SWIG_arg_fail(1)) SWIG_fail;
7188 if (obj1) {
7189 {
7190 arg2 = (long)(SWIG_As_long(obj1));
7191 if (SWIG_arg_fail(2)) SWIG_fail;
7192 }
7193 }
7194 {
7195 PyThreadState* __tstate = wxPyBeginAllowThreads();
7196 (arg1)->Start(arg2);
7197
7198 wxPyEndAllowThreads(__tstate);
7199 if (PyErr_Occurred()) SWIG_fail;
7200 }
7201 Py_INCREF(Py_None); resultobj = Py_None;
7202 return resultobj;
7203 fail:
7204 return NULL;
7205 }
7206
7207
7208 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7209 PyObject *resultobj;
7210 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7211 PyObject * obj0 = 0 ;
7212 char *kwnames[] = {
7213 (char *) "self", NULL
7214 };
7215
7216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7218 if (SWIG_arg_fail(1)) SWIG_fail;
7219 {
7220 PyThreadState* __tstate = wxPyBeginAllowThreads();
7221 (arg1)->Pause();
7222
7223 wxPyEndAllowThreads(__tstate);
7224 if (PyErr_Occurred()) SWIG_fail;
7225 }
7226 Py_INCREF(Py_None); resultobj = Py_None;
7227 return resultobj;
7228 fail:
7229 return NULL;
7230 }
7231
7232
7233 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7234 PyObject *resultobj;
7235 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7236 PyObject * obj0 = 0 ;
7237 char *kwnames[] = {
7238 (char *) "self", NULL
7239 };
7240
7241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7243 if (SWIG_arg_fail(1)) SWIG_fail;
7244 {
7245 PyThreadState* __tstate = wxPyBeginAllowThreads();
7246 (arg1)->Resume();
7247
7248 wxPyEndAllowThreads(__tstate);
7249 if (PyErr_Occurred()) SWIG_fail;
7250 }
7251 Py_INCREF(Py_None); resultobj = Py_None;
7252 return resultobj;
7253 fail:
7254 return NULL;
7255 }
7256
7257
7258 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7259 PyObject *resultobj;
7260 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7261 long result;
7262 PyObject * obj0 = 0 ;
7263 char *kwnames[] = {
7264 (char *) "self", NULL
7265 };
7266
7267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7269 if (SWIG_arg_fail(1)) SWIG_fail;
7270 {
7271 PyThreadState* __tstate = wxPyBeginAllowThreads();
7272 result = (long)((wxStopWatch const *)arg1)->Time();
7273
7274 wxPyEndAllowThreads(__tstate);
7275 if (PyErr_Occurred()) SWIG_fail;
7276 }
7277 {
7278 resultobj = SWIG_From_long((long)(result));
7279 }
7280 return resultobj;
7281 fail:
7282 return NULL;
7283 }
7284
7285
7286 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7287 PyObject *obj;
7288 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7289 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7290 Py_INCREF(obj);
7291 return Py_BuildValue((char *)"");
7292 }
7293 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7294 PyObject *resultobj;
7295 int arg1 = (int) 9 ;
7296 int arg2 = (int) wxID_FILE1 ;
7297 wxFileHistory *result;
7298 PyObject * obj0 = 0 ;
7299 PyObject * obj1 = 0 ;
7300 char *kwnames[] = {
7301 (char *) "maxFiles",(char *) "idBase", NULL
7302 };
7303
7304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7305 if (obj0) {
7306 {
7307 arg1 = (int)(SWIG_As_int(obj0));
7308 if (SWIG_arg_fail(1)) SWIG_fail;
7309 }
7310 }
7311 if (obj1) {
7312 {
7313 arg2 = (int)(SWIG_As_int(obj1));
7314 if (SWIG_arg_fail(2)) SWIG_fail;
7315 }
7316 }
7317 {
7318 PyThreadState* __tstate = wxPyBeginAllowThreads();
7319 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7320
7321 wxPyEndAllowThreads(__tstate);
7322 if (PyErr_Occurred()) SWIG_fail;
7323 }
7324 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7325 return resultobj;
7326 fail:
7327 return NULL;
7328 }
7329
7330
7331 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7332 PyObject *resultobj;
7333 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7334 PyObject * obj0 = 0 ;
7335 char *kwnames[] = {
7336 (char *) "self", NULL
7337 };
7338
7339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7341 if (SWIG_arg_fail(1)) SWIG_fail;
7342 {
7343 PyThreadState* __tstate = wxPyBeginAllowThreads();
7344 delete arg1;
7345
7346 wxPyEndAllowThreads(__tstate);
7347 if (PyErr_Occurred()) SWIG_fail;
7348 }
7349 Py_INCREF(Py_None); resultobj = Py_None;
7350 return resultobj;
7351 fail:
7352 return NULL;
7353 }
7354
7355
7356 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7357 PyObject *resultobj;
7358 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7359 wxString *arg2 = 0 ;
7360 bool temp2 = false ;
7361 PyObject * obj0 = 0 ;
7362 PyObject * obj1 = 0 ;
7363 char *kwnames[] = {
7364 (char *) "self",(char *) "file", NULL
7365 };
7366
7367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7369 if (SWIG_arg_fail(1)) SWIG_fail;
7370 {
7371 arg2 = wxString_in_helper(obj1);
7372 if (arg2 == NULL) SWIG_fail;
7373 temp2 = true;
7374 }
7375 {
7376 PyThreadState* __tstate = wxPyBeginAllowThreads();
7377 (arg1)->AddFileToHistory((wxString const &)*arg2);
7378
7379 wxPyEndAllowThreads(__tstate);
7380 if (PyErr_Occurred()) SWIG_fail;
7381 }
7382 Py_INCREF(Py_None); resultobj = Py_None;
7383 {
7384 if (temp2)
7385 delete arg2;
7386 }
7387 return resultobj;
7388 fail:
7389 {
7390 if (temp2)
7391 delete arg2;
7392 }
7393 return NULL;
7394 }
7395
7396
7397 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7398 PyObject *resultobj;
7399 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7400 int arg2 ;
7401 PyObject * obj0 = 0 ;
7402 PyObject * obj1 = 0 ;
7403 char *kwnames[] = {
7404 (char *) "self",(char *) "i", NULL
7405 };
7406
7407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7409 if (SWIG_arg_fail(1)) SWIG_fail;
7410 {
7411 arg2 = (int)(SWIG_As_int(obj1));
7412 if (SWIG_arg_fail(2)) SWIG_fail;
7413 }
7414 {
7415 PyThreadState* __tstate = wxPyBeginAllowThreads();
7416 (arg1)->RemoveFileFromHistory(arg2);
7417
7418 wxPyEndAllowThreads(__tstate);
7419 if (PyErr_Occurred()) SWIG_fail;
7420 }
7421 Py_INCREF(Py_None); resultobj = Py_None;
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7429 PyObject *resultobj;
7430 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7431 int result;
7432 PyObject * obj0 = 0 ;
7433 char *kwnames[] = {
7434 (char *) "self", NULL
7435 };
7436
7437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7439 if (SWIG_arg_fail(1)) SWIG_fail;
7440 {
7441 PyThreadState* __tstate = wxPyBeginAllowThreads();
7442 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7443
7444 wxPyEndAllowThreads(__tstate);
7445 if (PyErr_Occurred()) SWIG_fail;
7446 }
7447 {
7448 resultobj = SWIG_From_int((int)(result));
7449 }
7450 return resultobj;
7451 fail:
7452 return NULL;
7453 }
7454
7455
7456 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7457 PyObject *resultobj;
7458 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7459 wxMenu *arg2 = (wxMenu *) 0 ;
7460 PyObject * obj0 = 0 ;
7461 PyObject * obj1 = 0 ;
7462 char *kwnames[] = {
7463 (char *) "self",(char *) "menu", NULL
7464 };
7465
7466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7468 if (SWIG_arg_fail(1)) SWIG_fail;
7469 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7470 if (SWIG_arg_fail(2)) SWIG_fail;
7471 {
7472 PyThreadState* __tstate = wxPyBeginAllowThreads();
7473 (arg1)->UseMenu(arg2);
7474
7475 wxPyEndAllowThreads(__tstate);
7476 if (PyErr_Occurred()) SWIG_fail;
7477 }
7478 Py_INCREF(Py_None); resultobj = Py_None;
7479 return resultobj;
7480 fail:
7481 return NULL;
7482 }
7483
7484
7485 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7486 PyObject *resultobj;
7487 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7488 wxMenu *arg2 = (wxMenu *) 0 ;
7489 PyObject * obj0 = 0 ;
7490 PyObject * obj1 = 0 ;
7491 char *kwnames[] = {
7492 (char *) "self",(char *) "menu", NULL
7493 };
7494
7495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7497 if (SWIG_arg_fail(1)) SWIG_fail;
7498 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7499 if (SWIG_arg_fail(2)) SWIG_fail;
7500 {
7501 PyThreadState* __tstate = wxPyBeginAllowThreads();
7502 (arg1)->RemoveMenu(arg2);
7503
7504 wxPyEndAllowThreads(__tstate);
7505 if (PyErr_Occurred()) SWIG_fail;
7506 }
7507 Py_INCREF(Py_None); resultobj = Py_None;
7508 return resultobj;
7509 fail:
7510 return NULL;
7511 }
7512
7513
7514 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7515 PyObject *resultobj;
7516 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7517 wxConfigBase *arg2 = 0 ;
7518 PyObject * obj0 = 0 ;
7519 PyObject * obj1 = 0 ;
7520 char *kwnames[] = {
7521 (char *) "self",(char *) "config", NULL
7522 };
7523
7524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7526 if (SWIG_arg_fail(1)) SWIG_fail;
7527 {
7528 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7529 if (SWIG_arg_fail(2)) SWIG_fail;
7530 if (arg2 == NULL) {
7531 SWIG_null_ref("wxConfigBase");
7532 }
7533 if (SWIG_arg_fail(2)) SWIG_fail;
7534 }
7535 {
7536 PyThreadState* __tstate = wxPyBeginAllowThreads();
7537 (arg1)->Load(*arg2);
7538
7539 wxPyEndAllowThreads(__tstate);
7540 if (PyErr_Occurred()) SWIG_fail;
7541 }
7542 Py_INCREF(Py_None); resultobj = Py_None;
7543 return resultobj;
7544 fail:
7545 return NULL;
7546 }
7547
7548
7549 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7550 PyObject *resultobj;
7551 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7552 wxConfigBase *arg2 = 0 ;
7553 PyObject * obj0 = 0 ;
7554 PyObject * obj1 = 0 ;
7555 char *kwnames[] = {
7556 (char *) "self",(char *) "config", NULL
7557 };
7558
7559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7561 if (SWIG_arg_fail(1)) SWIG_fail;
7562 {
7563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7564 if (SWIG_arg_fail(2)) SWIG_fail;
7565 if (arg2 == NULL) {
7566 SWIG_null_ref("wxConfigBase");
7567 }
7568 if (SWIG_arg_fail(2)) SWIG_fail;
7569 }
7570 {
7571 PyThreadState* __tstate = wxPyBeginAllowThreads();
7572 (arg1)->Save(*arg2);
7573
7574 wxPyEndAllowThreads(__tstate);
7575 if (PyErr_Occurred()) SWIG_fail;
7576 }
7577 Py_INCREF(Py_None); resultobj = Py_None;
7578 return resultobj;
7579 fail:
7580 return NULL;
7581 }
7582
7583
7584 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7585 PyObject *resultobj;
7586 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7587 PyObject * obj0 = 0 ;
7588 char *kwnames[] = {
7589 (char *) "self", NULL
7590 };
7591
7592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7594 if (SWIG_arg_fail(1)) SWIG_fail;
7595 {
7596 PyThreadState* __tstate = wxPyBeginAllowThreads();
7597 (arg1)->AddFilesToMenu();
7598
7599 wxPyEndAllowThreads(__tstate);
7600 if (PyErr_Occurred()) SWIG_fail;
7601 }
7602 Py_INCREF(Py_None); resultobj = Py_None;
7603 return resultobj;
7604 fail:
7605 return NULL;
7606 }
7607
7608
7609 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7610 PyObject *resultobj;
7611 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7612 wxMenu *arg2 = (wxMenu *) 0 ;
7613 PyObject * obj0 = 0 ;
7614 PyObject * obj1 = 0 ;
7615 char *kwnames[] = {
7616 (char *) "self",(char *) "menu", NULL
7617 };
7618
7619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7621 if (SWIG_arg_fail(1)) SWIG_fail;
7622 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7623 if (SWIG_arg_fail(2)) SWIG_fail;
7624 {
7625 PyThreadState* __tstate = wxPyBeginAllowThreads();
7626 (arg1)->AddFilesToMenu(arg2);
7627
7628 wxPyEndAllowThreads(__tstate);
7629 if (PyErr_Occurred()) SWIG_fail;
7630 }
7631 Py_INCREF(Py_None); resultobj = Py_None;
7632 return resultobj;
7633 fail:
7634 return NULL;
7635 }
7636
7637
7638 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7639 PyObject *resultobj;
7640 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7641 int arg2 ;
7642 wxString result;
7643 PyObject * obj0 = 0 ;
7644 PyObject * obj1 = 0 ;
7645 char *kwnames[] = {
7646 (char *) "self",(char *) "i", NULL
7647 };
7648
7649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7651 if (SWIG_arg_fail(1)) SWIG_fail;
7652 {
7653 arg2 = (int)(SWIG_As_int(obj1));
7654 if (SWIG_arg_fail(2)) SWIG_fail;
7655 }
7656 {
7657 PyThreadState* __tstate = wxPyBeginAllowThreads();
7658 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7659
7660 wxPyEndAllowThreads(__tstate);
7661 if (PyErr_Occurred()) SWIG_fail;
7662 }
7663 {
7664 #if wxUSE_UNICODE
7665 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7666 #else
7667 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7668 #endif
7669 }
7670 return resultobj;
7671 fail:
7672 return NULL;
7673 }
7674
7675
7676 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7677 PyObject *resultobj;
7678 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7679 int result;
7680 PyObject * obj0 = 0 ;
7681 char *kwnames[] = {
7682 (char *) "self", NULL
7683 };
7684
7685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7687 if (SWIG_arg_fail(1)) SWIG_fail;
7688 {
7689 PyThreadState* __tstate = wxPyBeginAllowThreads();
7690 result = (int)((wxFileHistory const *)arg1)->GetCount();
7691
7692 wxPyEndAllowThreads(__tstate);
7693 if (PyErr_Occurred()) SWIG_fail;
7694 }
7695 {
7696 resultobj = SWIG_From_int((int)(result));
7697 }
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7705 PyObject *obj;
7706 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7707 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7708 Py_INCREF(obj);
7709 return Py_BuildValue((char *)"");
7710 }
7711 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7712 PyObject *resultobj;
7713 wxString *arg1 = 0 ;
7714 wxString const &arg2_defvalue = wxPyEmptyString ;
7715 wxString *arg2 = (wxString *) &arg2_defvalue ;
7716 wxSingleInstanceChecker *result;
7717 bool temp1 = false ;
7718 bool temp2 = false ;
7719 PyObject * obj0 = 0 ;
7720 PyObject * obj1 = 0 ;
7721 char *kwnames[] = {
7722 (char *) "name",(char *) "path", NULL
7723 };
7724
7725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7726 {
7727 arg1 = wxString_in_helper(obj0);
7728 if (arg1 == NULL) SWIG_fail;
7729 temp1 = true;
7730 }
7731 if (obj1) {
7732 {
7733 arg2 = wxString_in_helper(obj1);
7734 if (arg2 == NULL) SWIG_fail;
7735 temp2 = true;
7736 }
7737 }
7738 {
7739 PyThreadState* __tstate = wxPyBeginAllowThreads();
7740 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7741
7742 wxPyEndAllowThreads(__tstate);
7743 if (PyErr_Occurred()) SWIG_fail;
7744 }
7745 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7746 {
7747 if (temp1)
7748 delete arg1;
7749 }
7750 {
7751 if (temp2)
7752 delete arg2;
7753 }
7754 return resultobj;
7755 fail:
7756 {
7757 if (temp1)
7758 delete arg1;
7759 }
7760 {
7761 if (temp2)
7762 delete arg2;
7763 }
7764 return NULL;
7765 }
7766
7767
7768 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7769 PyObject *resultobj;
7770 wxSingleInstanceChecker *result;
7771 char *kwnames[] = {
7772 NULL
7773 };
7774
7775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7776 {
7777 PyThreadState* __tstate = wxPyBeginAllowThreads();
7778 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7779
7780 wxPyEndAllowThreads(__tstate);
7781 if (PyErr_Occurred()) SWIG_fail;
7782 }
7783 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7784 return resultobj;
7785 fail:
7786 return NULL;
7787 }
7788
7789
7790 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7791 PyObject *resultobj;
7792 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7793 PyObject * obj0 = 0 ;
7794 char *kwnames[] = {
7795 (char *) "self", NULL
7796 };
7797
7798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7800 if (SWIG_arg_fail(1)) SWIG_fail;
7801 {
7802 PyThreadState* __tstate = wxPyBeginAllowThreads();
7803 delete arg1;
7804
7805 wxPyEndAllowThreads(__tstate);
7806 if (PyErr_Occurred()) SWIG_fail;
7807 }
7808 Py_INCREF(Py_None); resultobj = Py_None;
7809 return resultobj;
7810 fail:
7811 return NULL;
7812 }
7813
7814
7815 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7816 PyObject *resultobj;
7817 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7818 wxString *arg2 = 0 ;
7819 wxString const &arg3_defvalue = wxPyEmptyString ;
7820 wxString *arg3 = (wxString *) &arg3_defvalue ;
7821 bool result;
7822 bool temp2 = false ;
7823 bool temp3 = false ;
7824 PyObject * obj0 = 0 ;
7825 PyObject * obj1 = 0 ;
7826 PyObject * obj2 = 0 ;
7827 char *kwnames[] = {
7828 (char *) "self",(char *) "name",(char *) "path", NULL
7829 };
7830
7831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7833 if (SWIG_arg_fail(1)) SWIG_fail;
7834 {
7835 arg2 = wxString_in_helper(obj1);
7836 if (arg2 == NULL) SWIG_fail;
7837 temp2 = true;
7838 }
7839 if (obj2) {
7840 {
7841 arg3 = wxString_in_helper(obj2);
7842 if (arg3 == NULL) SWIG_fail;
7843 temp3 = true;
7844 }
7845 }
7846 {
7847 PyThreadState* __tstate = wxPyBeginAllowThreads();
7848 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7849
7850 wxPyEndAllowThreads(__tstate);
7851 if (PyErr_Occurred()) SWIG_fail;
7852 }
7853 {
7854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7855 }
7856 {
7857 if (temp2)
7858 delete arg2;
7859 }
7860 {
7861 if (temp3)
7862 delete arg3;
7863 }
7864 return resultobj;
7865 fail:
7866 {
7867 if (temp2)
7868 delete arg2;
7869 }
7870 {
7871 if (temp3)
7872 delete arg3;
7873 }
7874 return NULL;
7875 }
7876
7877
7878 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7879 PyObject *resultobj;
7880 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7881 bool result;
7882 PyObject * obj0 = 0 ;
7883 char *kwnames[] = {
7884 (char *) "self", NULL
7885 };
7886
7887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7889 if (SWIG_arg_fail(1)) SWIG_fail;
7890 {
7891 PyThreadState* __tstate = wxPyBeginAllowThreads();
7892 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7893
7894 wxPyEndAllowThreads(__tstate);
7895 if (PyErr_Occurred()) SWIG_fail;
7896 }
7897 {
7898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7899 }
7900 return resultobj;
7901 fail:
7902 return NULL;
7903 }
7904
7905
7906 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7907 PyObject *obj;
7908 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7909 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7910 Py_INCREF(obj);
7911 return Py_BuildValue((char *)"");
7912 }
7913 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7914 PyObject *resultobj;
7915 wxWindow *arg1 = (wxWindow *) 0 ;
7916 wxDC *arg2 = 0 ;
7917 bool result;
7918 PyObject * obj0 = 0 ;
7919 PyObject * obj1 = 0 ;
7920 char *kwnames[] = {
7921 (char *) "window",(char *) "dc", NULL
7922 };
7923
7924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7926 if (SWIG_arg_fail(1)) SWIG_fail;
7927 {
7928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7929 if (SWIG_arg_fail(2)) SWIG_fail;
7930 if (arg2 == NULL) {
7931 SWIG_null_ref("wxDC");
7932 }
7933 if (SWIG_arg_fail(2)) SWIG_fail;
7934 }
7935 {
7936 PyThreadState* __tstate = wxPyBeginAllowThreads();
7937 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7938
7939 wxPyEndAllowThreads(__tstate);
7940 if (PyErr_Occurred()) SWIG_fail;
7941 }
7942 {
7943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7944 }
7945 return resultobj;
7946 fail:
7947 return NULL;
7948 }
7949
7950
7951 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7952 PyObject *resultobj;
7953 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7954 PyObject * obj0 = 0 ;
7955 char *kwnames[] = {
7956 (char *) "self", NULL
7957 };
7958
7959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7961 if (SWIG_arg_fail(1)) SWIG_fail;
7962 {
7963 PyThreadState* __tstate = wxPyBeginAllowThreads();
7964 delete arg1;
7965
7966 wxPyEndAllowThreads(__tstate);
7967 if (PyErr_Occurred()) SWIG_fail;
7968 }
7969 Py_INCREF(Py_None); resultobj = Py_None;
7970 return resultobj;
7971 fail:
7972 return NULL;
7973 }
7974
7975
7976 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7977 PyObject *resultobj;
7978 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7979 wxString result;
7980 PyObject * obj0 = 0 ;
7981 char *kwnames[] = {
7982 (char *) "self", NULL
7983 };
7984
7985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7987 if (SWIG_arg_fail(1)) SWIG_fail;
7988 {
7989 PyThreadState* __tstate = wxPyBeginAllowThreads();
7990 result = (arg1)->GetTip();
7991
7992 wxPyEndAllowThreads(__tstate);
7993 if (PyErr_Occurred()) SWIG_fail;
7994 }
7995 {
7996 #if wxUSE_UNICODE
7997 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7998 #else
7999 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8000 #endif
8001 }
8002 return resultobj;
8003 fail:
8004 return NULL;
8005 }
8006
8007
8008 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
8009 PyObject *resultobj;
8010 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8011 size_t result;
8012 PyObject * obj0 = 0 ;
8013 char *kwnames[] = {
8014 (char *) "self", NULL
8015 };
8016
8017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
8018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8019 if (SWIG_arg_fail(1)) SWIG_fail;
8020 {
8021 PyThreadState* __tstate = wxPyBeginAllowThreads();
8022 result = (size_t)(arg1)->GetCurrentTip();
8023
8024 wxPyEndAllowThreads(__tstate);
8025 if (PyErr_Occurred()) SWIG_fail;
8026 }
8027 {
8028 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8029 }
8030 return resultobj;
8031 fail:
8032 return NULL;
8033 }
8034
8035
8036 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8037 PyObject *resultobj;
8038 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8039 wxString *arg2 = 0 ;
8040 wxString result;
8041 bool temp2 = false ;
8042 PyObject * obj0 = 0 ;
8043 PyObject * obj1 = 0 ;
8044 char *kwnames[] = {
8045 (char *) "self",(char *) "tip", NULL
8046 };
8047
8048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8050 if (SWIG_arg_fail(1)) SWIG_fail;
8051 {
8052 arg2 = wxString_in_helper(obj1);
8053 if (arg2 == NULL) SWIG_fail;
8054 temp2 = true;
8055 }
8056 {
8057 PyThreadState* __tstate = wxPyBeginAllowThreads();
8058 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8059
8060 wxPyEndAllowThreads(__tstate);
8061 if (PyErr_Occurred()) SWIG_fail;
8062 }
8063 {
8064 #if wxUSE_UNICODE
8065 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8066 #else
8067 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8068 #endif
8069 }
8070 {
8071 if (temp2)
8072 delete arg2;
8073 }
8074 return resultobj;
8075 fail:
8076 {
8077 if (temp2)
8078 delete arg2;
8079 }
8080 return NULL;
8081 }
8082
8083
8084 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8085 PyObject *obj;
8086 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8087 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8088 Py_INCREF(obj);
8089 return Py_BuildValue((char *)"");
8090 }
8091 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8092 PyObject *resultobj;
8093 size_t arg1 ;
8094 wxPyTipProvider *result;
8095 PyObject * obj0 = 0 ;
8096 char *kwnames[] = {
8097 (char *) "currentTip", NULL
8098 };
8099
8100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8101 {
8102 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8103 if (SWIG_arg_fail(1)) SWIG_fail;
8104 }
8105 {
8106 PyThreadState* __tstate = wxPyBeginAllowThreads();
8107 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8108
8109 wxPyEndAllowThreads(__tstate);
8110 if (PyErr_Occurred()) SWIG_fail;
8111 }
8112 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8113 return resultobj;
8114 fail:
8115 return NULL;
8116 }
8117
8118
8119 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8120 PyObject *resultobj;
8121 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8122 PyObject *arg2 = (PyObject *) 0 ;
8123 PyObject *arg3 = (PyObject *) 0 ;
8124 PyObject * obj0 = 0 ;
8125 PyObject * obj1 = 0 ;
8126 PyObject * obj2 = 0 ;
8127 char *kwnames[] = {
8128 (char *) "self",(char *) "self",(char *) "_class", NULL
8129 };
8130
8131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8133 if (SWIG_arg_fail(1)) SWIG_fail;
8134 arg2 = obj1;
8135 arg3 = obj2;
8136 {
8137 PyThreadState* __tstate = wxPyBeginAllowThreads();
8138 (arg1)->_setCallbackInfo(arg2,arg3);
8139
8140 wxPyEndAllowThreads(__tstate);
8141 if (PyErr_Occurred()) SWIG_fail;
8142 }
8143 Py_INCREF(Py_None); resultobj = Py_None;
8144 return resultobj;
8145 fail:
8146 return NULL;
8147 }
8148
8149
8150 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8151 PyObject *obj;
8152 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8153 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8154 Py_INCREF(obj);
8155 return Py_BuildValue((char *)"");
8156 }
8157 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8158 PyObject *resultobj;
8159 wxWindow *arg1 = (wxWindow *) 0 ;
8160 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8161 bool arg3 = (bool) true ;
8162 bool result;
8163 PyObject * obj0 = 0 ;
8164 PyObject * obj1 = 0 ;
8165 PyObject * obj2 = 0 ;
8166 char *kwnames[] = {
8167 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8168 };
8169
8170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8172 if (SWIG_arg_fail(1)) SWIG_fail;
8173 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8174 if (SWIG_arg_fail(2)) SWIG_fail;
8175 if (obj2) {
8176 {
8177 arg3 = (bool)(SWIG_As_bool(obj2));
8178 if (SWIG_arg_fail(3)) SWIG_fail;
8179 }
8180 }
8181 {
8182 if (!wxPyCheckForApp()) SWIG_fail;
8183 PyThreadState* __tstate = wxPyBeginAllowThreads();
8184 result = (bool)wxShowTip(arg1,arg2,arg3);
8185
8186 wxPyEndAllowThreads(__tstate);
8187 if (PyErr_Occurred()) SWIG_fail;
8188 }
8189 {
8190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8191 }
8192 return resultobj;
8193 fail:
8194 return NULL;
8195 }
8196
8197
8198 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8199 PyObject *resultobj;
8200 wxString *arg1 = 0 ;
8201 size_t arg2 ;
8202 wxTipProvider *result;
8203 bool temp1 = false ;
8204 PyObject * obj0 = 0 ;
8205 PyObject * obj1 = 0 ;
8206 char *kwnames[] = {
8207 (char *) "filename",(char *) "currentTip", NULL
8208 };
8209
8210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8211 {
8212 arg1 = wxString_in_helper(obj0);
8213 if (arg1 == NULL) SWIG_fail;
8214 temp1 = true;
8215 }
8216 {
8217 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8218 if (SWIG_arg_fail(2)) SWIG_fail;
8219 }
8220 {
8221 if (!wxPyCheckForApp()) SWIG_fail;
8222 PyThreadState* __tstate = wxPyBeginAllowThreads();
8223 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8224
8225 wxPyEndAllowThreads(__tstate);
8226 if (PyErr_Occurred()) SWIG_fail;
8227 }
8228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8229 {
8230 if (temp1)
8231 delete arg1;
8232 }
8233 return resultobj;
8234 fail:
8235 {
8236 if (temp1)
8237 delete arg1;
8238 }
8239 return NULL;
8240 }
8241
8242
8243 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8244 PyObject *resultobj;
8245 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8246 int arg2 = (int) -1 ;
8247 wxPyTimer *result;
8248 PyObject * obj0 = 0 ;
8249 PyObject * obj1 = 0 ;
8250 char *kwnames[] = {
8251 (char *) "owner",(char *) "id", NULL
8252 };
8253
8254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8255 if (obj0) {
8256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8257 if (SWIG_arg_fail(1)) SWIG_fail;
8258 }
8259 if (obj1) {
8260 {
8261 arg2 = (int)(SWIG_As_int(obj1));
8262 if (SWIG_arg_fail(2)) SWIG_fail;
8263 }
8264 }
8265 {
8266 if (!wxPyCheckForApp()) SWIG_fail;
8267 PyThreadState* __tstate = wxPyBeginAllowThreads();
8268 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8269
8270 wxPyEndAllowThreads(__tstate);
8271 if (PyErr_Occurred()) SWIG_fail;
8272 }
8273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8274 return resultobj;
8275 fail:
8276 return NULL;
8277 }
8278
8279
8280 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8281 PyObject *resultobj;
8282 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8283 PyObject * obj0 = 0 ;
8284 char *kwnames[] = {
8285 (char *) "self", NULL
8286 };
8287
8288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8290 if (SWIG_arg_fail(1)) SWIG_fail;
8291 {
8292 PyThreadState* __tstate = wxPyBeginAllowThreads();
8293 delete arg1;
8294
8295 wxPyEndAllowThreads(__tstate);
8296 if (PyErr_Occurred()) SWIG_fail;
8297 }
8298 Py_INCREF(Py_None); resultobj = Py_None;
8299 return resultobj;
8300 fail:
8301 return NULL;
8302 }
8303
8304
8305 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8306 PyObject *resultobj;
8307 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8308 PyObject *arg2 = (PyObject *) 0 ;
8309 PyObject *arg3 = (PyObject *) 0 ;
8310 int arg4 = (int) 1 ;
8311 PyObject * obj0 = 0 ;
8312 PyObject * obj1 = 0 ;
8313 PyObject * obj2 = 0 ;
8314 PyObject * obj3 = 0 ;
8315 char *kwnames[] = {
8316 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8317 };
8318
8319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8321 if (SWIG_arg_fail(1)) SWIG_fail;
8322 arg2 = obj1;
8323 arg3 = obj2;
8324 if (obj3) {
8325 {
8326 arg4 = (int)(SWIG_As_int(obj3));
8327 if (SWIG_arg_fail(4)) SWIG_fail;
8328 }
8329 }
8330 {
8331 PyThreadState* __tstate = wxPyBeginAllowThreads();
8332 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8333
8334 wxPyEndAllowThreads(__tstate);
8335 if (PyErr_Occurred()) SWIG_fail;
8336 }
8337 Py_INCREF(Py_None); resultobj = Py_None;
8338 return resultobj;
8339 fail:
8340 return NULL;
8341 }
8342
8343
8344 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8345 PyObject *resultobj;
8346 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8347 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8348 int arg3 = (int) -1 ;
8349 PyObject * obj0 = 0 ;
8350 PyObject * obj1 = 0 ;
8351 PyObject * obj2 = 0 ;
8352 char *kwnames[] = {
8353 (char *) "self",(char *) "owner",(char *) "id", NULL
8354 };
8355
8356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8358 if (SWIG_arg_fail(1)) SWIG_fail;
8359 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8360 if (SWIG_arg_fail(2)) SWIG_fail;
8361 if (obj2) {
8362 {
8363 arg3 = (int)(SWIG_As_int(obj2));
8364 if (SWIG_arg_fail(3)) SWIG_fail;
8365 }
8366 }
8367 {
8368 PyThreadState* __tstate = wxPyBeginAllowThreads();
8369 (arg1)->SetOwner(arg2,arg3);
8370
8371 wxPyEndAllowThreads(__tstate);
8372 if (PyErr_Occurred()) SWIG_fail;
8373 }
8374 Py_INCREF(Py_None); resultobj = Py_None;
8375 return resultobj;
8376 fail:
8377 return NULL;
8378 }
8379
8380
8381 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8382 PyObject *resultobj;
8383 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8384 wxEvtHandler *result;
8385 PyObject * obj0 = 0 ;
8386 char *kwnames[] = {
8387 (char *) "self", NULL
8388 };
8389
8390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8392 if (SWIG_arg_fail(1)) SWIG_fail;
8393 {
8394 PyThreadState* __tstate = wxPyBeginAllowThreads();
8395 result = (wxEvtHandler *)(arg1)->GetOwner();
8396
8397 wxPyEndAllowThreads(__tstate);
8398 if (PyErr_Occurred()) SWIG_fail;
8399 }
8400 {
8401 resultobj = wxPyMake_wxObject(result, 0);
8402 }
8403 return resultobj;
8404 fail:
8405 return NULL;
8406 }
8407
8408
8409 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8410 PyObject *resultobj;
8411 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8412 int arg2 = (int) -1 ;
8413 bool arg3 = (bool) false ;
8414 bool result;
8415 PyObject * obj0 = 0 ;
8416 PyObject * obj1 = 0 ;
8417 PyObject * obj2 = 0 ;
8418 char *kwnames[] = {
8419 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8420 };
8421
8422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8424 if (SWIG_arg_fail(1)) SWIG_fail;
8425 if (obj1) {
8426 {
8427 arg2 = (int)(SWIG_As_int(obj1));
8428 if (SWIG_arg_fail(2)) SWIG_fail;
8429 }
8430 }
8431 if (obj2) {
8432 {
8433 arg3 = (bool)(SWIG_As_bool(obj2));
8434 if (SWIG_arg_fail(3)) SWIG_fail;
8435 }
8436 }
8437 {
8438 PyThreadState* __tstate = wxPyBeginAllowThreads();
8439 result = (bool)(arg1)->Start(arg2,arg3);
8440
8441 wxPyEndAllowThreads(__tstate);
8442 if (PyErr_Occurred()) SWIG_fail;
8443 }
8444 {
8445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8446 }
8447 return resultobj;
8448 fail:
8449 return NULL;
8450 }
8451
8452
8453 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8454 PyObject *resultobj;
8455 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8456 PyObject * obj0 = 0 ;
8457 char *kwnames[] = {
8458 (char *) "self", NULL
8459 };
8460
8461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8463 if (SWIG_arg_fail(1)) SWIG_fail;
8464 {
8465 PyThreadState* __tstate = wxPyBeginAllowThreads();
8466 (arg1)->Stop();
8467
8468 wxPyEndAllowThreads(__tstate);
8469 if (PyErr_Occurred()) SWIG_fail;
8470 }
8471 Py_INCREF(Py_None); resultobj = Py_None;
8472 return resultobj;
8473 fail:
8474 return NULL;
8475 }
8476
8477
8478 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8479 PyObject *resultobj;
8480 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8481 bool result;
8482 PyObject * obj0 = 0 ;
8483 char *kwnames[] = {
8484 (char *) "self", NULL
8485 };
8486
8487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8489 if (SWIG_arg_fail(1)) SWIG_fail;
8490 {
8491 PyThreadState* __tstate = wxPyBeginAllowThreads();
8492 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8493
8494 wxPyEndAllowThreads(__tstate);
8495 if (PyErr_Occurred()) SWIG_fail;
8496 }
8497 {
8498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8499 }
8500 return resultobj;
8501 fail:
8502 return NULL;
8503 }
8504
8505
8506 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8507 PyObject *resultobj;
8508 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8509 int result;
8510 PyObject * obj0 = 0 ;
8511 char *kwnames[] = {
8512 (char *) "self", NULL
8513 };
8514
8515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8517 if (SWIG_arg_fail(1)) SWIG_fail;
8518 {
8519 PyThreadState* __tstate = wxPyBeginAllowThreads();
8520 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8521
8522 wxPyEndAllowThreads(__tstate);
8523 if (PyErr_Occurred()) SWIG_fail;
8524 }
8525 {
8526 resultobj = SWIG_From_int((int)(result));
8527 }
8528 return resultobj;
8529 fail:
8530 return NULL;
8531 }
8532
8533
8534 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8535 PyObject *resultobj;
8536 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8537 bool result;
8538 PyObject * obj0 = 0 ;
8539 char *kwnames[] = {
8540 (char *) "self", NULL
8541 };
8542
8543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8545 if (SWIG_arg_fail(1)) SWIG_fail;
8546 {
8547 PyThreadState* __tstate = wxPyBeginAllowThreads();
8548 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8549
8550 wxPyEndAllowThreads(__tstate);
8551 if (PyErr_Occurred()) SWIG_fail;
8552 }
8553 {
8554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8555 }
8556 return resultobj;
8557 fail:
8558 return NULL;
8559 }
8560
8561
8562 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8563 PyObject *resultobj;
8564 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8565 int result;
8566 PyObject * obj0 = 0 ;
8567 char *kwnames[] = {
8568 (char *) "self", NULL
8569 };
8570
8571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8573 if (SWIG_arg_fail(1)) SWIG_fail;
8574 {
8575 PyThreadState* __tstate = wxPyBeginAllowThreads();
8576 result = (int)((wxPyTimer const *)arg1)->GetId();
8577
8578 wxPyEndAllowThreads(__tstate);
8579 if (PyErr_Occurred()) SWIG_fail;
8580 }
8581 {
8582 resultobj = SWIG_From_int((int)(result));
8583 }
8584 return resultobj;
8585 fail:
8586 return NULL;
8587 }
8588
8589
8590 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8591 PyObject *obj;
8592 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8593 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8594 Py_INCREF(obj);
8595 return Py_BuildValue((char *)"");
8596 }
8597 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8598 PyObject *resultobj;
8599 int arg1 = (int) 0 ;
8600 int arg2 = (int) 0 ;
8601 wxTimerEvent *result;
8602 PyObject * obj0 = 0 ;
8603 PyObject * obj1 = 0 ;
8604 char *kwnames[] = {
8605 (char *) "timerid",(char *) "interval", NULL
8606 };
8607
8608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8609 if (obj0) {
8610 {
8611 arg1 = (int)(SWIG_As_int(obj0));
8612 if (SWIG_arg_fail(1)) SWIG_fail;
8613 }
8614 }
8615 if (obj1) {
8616 {
8617 arg2 = (int)(SWIG_As_int(obj1));
8618 if (SWIG_arg_fail(2)) SWIG_fail;
8619 }
8620 }
8621 {
8622 PyThreadState* __tstate = wxPyBeginAllowThreads();
8623 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8624
8625 wxPyEndAllowThreads(__tstate);
8626 if (PyErr_Occurred()) SWIG_fail;
8627 }
8628 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8629 return resultobj;
8630 fail:
8631 return NULL;
8632 }
8633
8634
8635 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8636 PyObject *resultobj;
8637 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8638 int result;
8639 PyObject * obj0 = 0 ;
8640 char *kwnames[] = {
8641 (char *) "self", NULL
8642 };
8643
8644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8646 if (SWIG_arg_fail(1)) SWIG_fail;
8647 {
8648 PyThreadState* __tstate = wxPyBeginAllowThreads();
8649 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8650
8651 wxPyEndAllowThreads(__tstate);
8652 if (PyErr_Occurred()) SWIG_fail;
8653 }
8654 {
8655 resultobj = SWIG_From_int((int)(result));
8656 }
8657 return resultobj;
8658 fail:
8659 return NULL;
8660 }
8661
8662
8663 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8664 PyObject *obj;
8665 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8666 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8667 Py_INCREF(obj);
8668 return Py_BuildValue((char *)"");
8669 }
8670 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8671 PyObject *resultobj;
8672 wxTimer *arg1 = 0 ;
8673 wxTimerRunner *result;
8674 PyObject * obj0 = 0 ;
8675
8676 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8677 {
8678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8679 if (SWIG_arg_fail(1)) SWIG_fail;
8680 if (arg1 == NULL) {
8681 SWIG_null_ref("wxTimer");
8682 }
8683 if (SWIG_arg_fail(1)) SWIG_fail;
8684 }
8685 {
8686 if (!wxPyCheckForApp()) SWIG_fail;
8687 PyThreadState* __tstate = wxPyBeginAllowThreads();
8688 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8689
8690 wxPyEndAllowThreads(__tstate);
8691 if (PyErr_Occurred()) SWIG_fail;
8692 }
8693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8694 return resultobj;
8695 fail:
8696 return NULL;
8697 }
8698
8699
8700 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8701 PyObject *resultobj;
8702 wxTimer *arg1 = 0 ;
8703 int arg2 ;
8704 bool arg3 = (bool) false ;
8705 wxTimerRunner *result;
8706 PyObject * obj0 = 0 ;
8707 PyObject * obj1 = 0 ;
8708 PyObject * obj2 = 0 ;
8709
8710 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8711 {
8712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8713 if (SWIG_arg_fail(1)) SWIG_fail;
8714 if (arg1 == NULL) {
8715 SWIG_null_ref("wxTimer");
8716 }
8717 if (SWIG_arg_fail(1)) SWIG_fail;
8718 }
8719 {
8720 arg2 = (int)(SWIG_As_int(obj1));
8721 if (SWIG_arg_fail(2)) SWIG_fail;
8722 }
8723 if (obj2) {
8724 {
8725 arg3 = (bool)(SWIG_As_bool(obj2));
8726 if (SWIG_arg_fail(3)) SWIG_fail;
8727 }
8728 }
8729 {
8730 if (!wxPyCheckForApp()) SWIG_fail;
8731 PyThreadState* __tstate = wxPyBeginAllowThreads();
8732 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8733
8734 wxPyEndAllowThreads(__tstate);
8735 if (PyErr_Occurred()) SWIG_fail;
8736 }
8737 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8738 return resultobj;
8739 fail:
8740 return NULL;
8741 }
8742
8743
8744 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8745 int argc;
8746 PyObject *argv[4];
8747 int ii;
8748
8749 argc = PyObject_Length(args);
8750 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8751 argv[ii] = PyTuple_GetItem(args,ii);
8752 }
8753 if (argc == 1) {
8754 int _v;
8755 {
8756 void *ptr = 0;
8757 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8758 _v = 0;
8759 PyErr_Clear();
8760 } else {
8761 _v = (ptr != 0);
8762 }
8763 }
8764 if (_v) {
8765 return _wrap_new_TimerRunner__SWIG_0(self,args);
8766 }
8767 }
8768 if ((argc >= 2) && (argc <= 3)) {
8769 int _v;
8770 {
8771 void *ptr = 0;
8772 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8773 _v = 0;
8774 PyErr_Clear();
8775 } else {
8776 _v = (ptr != 0);
8777 }
8778 }
8779 if (_v) {
8780 _v = SWIG_Check_int(argv[1]);
8781 if (_v) {
8782 if (argc <= 2) {
8783 return _wrap_new_TimerRunner__SWIG_1(self,args);
8784 }
8785 _v = SWIG_Check_bool(argv[2]);
8786 if (_v) {
8787 return _wrap_new_TimerRunner__SWIG_1(self,args);
8788 }
8789 }
8790 }
8791 }
8792
8793 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8794 return NULL;
8795 }
8796
8797
8798 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8799 PyObject *resultobj;
8800 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8801 PyObject * obj0 = 0 ;
8802 char *kwnames[] = {
8803 (char *) "self", NULL
8804 };
8805
8806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8808 if (SWIG_arg_fail(1)) SWIG_fail;
8809 {
8810 PyThreadState* __tstate = wxPyBeginAllowThreads();
8811 delete arg1;
8812
8813 wxPyEndAllowThreads(__tstate);
8814 if (PyErr_Occurred()) SWIG_fail;
8815 }
8816 Py_INCREF(Py_None); resultobj = Py_None;
8817 return resultobj;
8818 fail:
8819 return NULL;
8820 }
8821
8822
8823 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8824 PyObject *resultobj;
8825 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8826 int arg2 ;
8827 bool arg3 = (bool) false ;
8828 PyObject * obj0 = 0 ;
8829 PyObject * obj1 = 0 ;
8830 PyObject * obj2 = 0 ;
8831 char *kwnames[] = {
8832 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8833 };
8834
8835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8837 if (SWIG_arg_fail(1)) SWIG_fail;
8838 {
8839 arg2 = (int)(SWIG_As_int(obj1));
8840 if (SWIG_arg_fail(2)) SWIG_fail;
8841 }
8842 if (obj2) {
8843 {
8844 arg3 = (bool)(SWIG_As_bool(obj2));
8845 if (SWIG_arg_fail(3)) SWIG_fail;
8846 }
8847 }
8848 {
8849 PyThreadState* __tstate = wxPyBeginAllowThreads();
8850 (arg1)->Start(arg2,arg3);
8851
8852 wxPyEndAllowThreads(__tstate);
8853 if (PyErr_Occurred()) SWIG_fail;
8854 }
8855 Py_INCREF(Py_None); resultobj = Py_None;
8856 return resultobj;
8857 fail:
8858 return NULL;
8859 }
8860
8861
8862 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8863 PyObject *obj;
8864 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8865 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8866 Py_INCREF(obj);
8867 return Py_BuildValue((char *)"");
8868 }
8869 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8870 PyObject *resultobj;
8871 wxLog *result;
8872 char *kwnames[] = {
8873 NULL
8874 };
8875
8876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8877 {
8878 PyThreadState* __tstate = wxPyBeginAllowThreads();
8879 result = (wxLog *)new wxLog();
8880
8881 wxPyEndAllowThreads(__tstate);
8882 if (PyErr_Occurred()) SWIG_fail;
8883 }
8884 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8885 return resultobj;
8886 fail:
8887 return NULL;
8888 }
8889
8890
8891 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8892 PyObject *resultobj;
8893 bool result;
8894 char *kwnames[] = {
8895 NULL
8896 };
8897
8898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8899 {
8900 PyThreadState* __tstate = wxPyBeginAllowThreads();
8901 result = (bool)wxLog::IsEnabled();
8902
8903 wxPyEndAllowThreads(__tstate);
8904 if (PyErr_Occurred()) SWIG_fail;
8905 }
8906 {
8907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8908 }
8909 return resultobj;
8910 fail:
8911 return NULL;
8912 }
8913
8914
8915 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8916 PyObject *resultobj;
8917 bool arg1 = (bool) true ;
8918 bool result;
8919 PyObject * obj0 = 0 ;
8920 char *kwnames[] = {
8921 (char *) "doIt", NULL
8922 };
8923
8924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8925 if (obj0) {
8926 {
8927 arg1 = (bool)(SWIG_As_bool(obj0));
8928 if (SWIG_arg_fail(1)) SWIG_fail;
8929 }
8930 }
8931 {
8932 PyThreadState* __tstate = wxPyBeginAllowThreads();
8933 result = (bool)wxLog::EnableLogging(arg1);
8934
8935 wxPyEndAllowThreads(__tstate);
8936 if (PyErr_Occurred()) SWIG_fail;
8937 }
8938 {
8939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8940 }
8941 return resultobj;
8942 fail:
8943 return NULL;
8944 }
8945
8946
8947 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8948 PyObject *resultobj;
8949 wxLogLevel arg1 ;
8950 wxChar *arg2 = (wxChar *) 0 ;
8951 time_t arg3 ;
8952 PyObject * obj0 = 0 ;
8953 PyObject * obj1 = 0 ;
8954 PyObject * obj2 = 0 ;
8955 char *kwnames[] = {
8956 (char *) "level",(char *) "szString",(char *) "t", NULL
8957 };
8958
8959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8960 {
8961 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8962 if (SWIG_arg_fail(1)) SWIG_fail;
8963 }
8964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8965 if (SWIG_arg_fail(2)) SWIG_fail;
8966 {
8967 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8968 if (SWIG_arg_fail(3)) SWIG_fail;
8969 }
8970 {
8971 PyThreadState* __tstate = wxPyBeginAllowThreads();
8972 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8973
8974 wxPyEndAllowThreads(__tstate);
8975 if (PyErr_Occurred()) SWIG_fail;
8976 }
8977 Py_INCREF(Py_None); resultobj = Py_None;
8978 return resultobj;
8979 fail:
8980 return NULL;
8981 }
8982
8983
8984 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8985 PyObject *resultobj;
8986 wxLog *arg1 = (wxLog *) 0 ;
8987 PyObject * obj0 = 0 ;
8988 char *kwnames[] = {
8989 (char *) "self", NULL
8990 };
8991
8992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8994 if (SWIG_arg_fail(1)) SWIG_fail;
8995 {
8996 PyThreadState* __tstate = wxPyBeginAllowThreads();
8997 (arg1)->Flush();
8998
8999 wxPyEndAllowThreads(__tstate);
9000 if (PyErr_Occurred()) SWIG_fail;
9001 }
9002 Py_INCREF(Py_None); resultobj = Py_None;
9003 return resultobj;
9004 fail:
9005 return NULL;
9006 }
9007
9008
9009 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
9010 PyObject *resultobj;
9011 char *kwnames[] = {
9012 NULL
9013 };
9014
9015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
9016 {
9017 PyThreadState* __tstate = wxPyBeginAllowThreads();
9018 wxLog::FlushActive();
9019
9020 wxPyEndAllowThreads(__tstate);
9021 if (PyErr_Occurred()) SWIG_fail;
9022 }
9023 Py_INCREF(Py_None); resultobj = Py_None;
9024 return resultobj;
9025 fail:
9026 return NULL;
9027 }
9028
9029
9030 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9031 PyObject *resultobj;
9032 wxLog *result;
9033 char *kwnames[] = {
9034 NULL
9035 };
9036
9037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9038 {
9039 PyThreadState* __tstate = wxPyBeginAllowThreads();
9040 result = (wxLog *)wxLog::GetActiveTarget();
9041
9042 wxPyEndAllowThreads(__tstate);
9043 if (PyErr_Occurred()) SWIG_fail;
9044 }
9045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9046 return resultobj;
9047 fail:
9048 return NULL;
9049 }
9050
9051
9052 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9053 PyObject *resultobj;
9054 wxLog *arg1 = (wxLog *) 0 ;
9055 wxLog *result;
9056 PyObject * obj0 = 0 ;
9057 char *kwnames[] = {
9058 (char *) "pLogger", NULL
9059 };
9060
9061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9063 if (SWIG_arg_fail(1)) SWIG_fail;
9064 {
9065 PyThreadState* __tstate = wxPyBeginAllowThreads();
9066 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9067
9068 wxPyEndAllowThreads(__tstate);
9069 if (PyErr_Occurred()) SWIG_fail;
9070 }
9071 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9072 return resultobj;
9073 fail:
9074 return NULL;
9075 }
9076
9077
9078 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9079 PyObject *resultobj;
9080 char *kwnames[] = {
9081 NULL
9082 };
9083
9084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9085 {
9086 PyThreadState* __tstate = wxPyBeginAllowThreads();
9087 wxLog::Suspend();
9088
9089 wxPyEndAllowThreads(__tstate);
9090 if (PyErr_Occurred()) SWIG_fail;
9091 }
9092 Py_INCREF(Py_None); resultobj = Py_None;
9093 return resultobj;
9094 fail:
9095 return NULL;
9096 }
9097
9098
9099 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9100 PyObject *resultobj;
9101 char *kwnames[] = {
9102 NULL
9103 };
9104
9105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9106 {
9107 PyThreadState* __tstate = wxPyBeginAllowThreads();
9108 wxLog::Resume();
9109
9110 wxPyEndAllowThreads(__tstate);
9111 if (PyErr_Occurred()) SWIG_fail;
9112 }
9113 Py_INCREF(Py_None); resultobj = Py_None;
9114 return resultobj;
9115 fail:
9116 return NULL;
9117 }
9118
9119
9120 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9121 PyObject *resultobj;
9122 bool arg1 = (bool) true ;
9123 PyObject * obj0 = 0 ;
9124 char *kwnames[] = {
9125 (char *) "bVerbose", NULL
9126 };
9127
9128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9129 if (obj0) {
9130 {
9131 arg1 = (bool)(SWIG_As_bool(obj0));
9132 if (SWIG_arg_fail(1)) SWIG_fail;
9133 }
9134 }
9135 {
9136 PyThreadState* __tstate = wxPyBeginAllowThreads();
9137 wxLog::SetVerbose(arg1);
9138
9139 wxPyEndAllowThreads(__tstate);
9140 if (PyErr_Occurred()) SWIG_fail;
9141 }
9142 Py_INCREF(Py_None); resultobj = Py_None;
9143 return resultobj;
9144 fail:
9145 return NULL;
9146 }
9147
9148
9149 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9150 PyObject *resultobj;
9151 wxLogLevel arg1 ;
9152 PyObject * obj0 = 0 ;
9153 char *kwnames[] = {
9154 (char *) "logLevel", NULL
9155 };
9156
9157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9158 {
9159 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9160 if (SWIG_arg_fail(1)) SWIG_fail;
9161 }
9162 {
9163 PyThreadState* __tstate = wxPyBeginAllowThreads();
9164 wxLog::SetLogLevel(arg1);
9165
9166 wxPyEndAllowThreads(__tstate);
9167 if (PyErr_Occurred()) SWIG_fail;
9168 }
9169 Py_INCREF(Py_None); resultobj = Py_None;
9170 return resultobj;
9171 fail:
9172 return NULL;
9173 }
9174
9175
9176 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9177 PyObject *resultobj;
9178 char *kwnames[] = {
9179 NULL
9180 };
9181
9182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9183 {
9184 PyThreadState* __tstate = wxPyBeginAllowThreads();
9185 wxLog::DontCreateOnDemand();
9186
9187 wxPyEndAllowThreads(__tstate);
9188 if (PyErr_Occurred()) SWIG_fail;
9189 }
9190 Py_INCREF(Py_None); resultobj = Py_None;
9191 return resultobj;
9192 fail:
9193 return NULL;
9194 }
9195
9196
9197 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9198 PyObject *resultobj;
9199 wxTraceMask arg1 ;
9200 PyObject * obj0 = 0 ;
9201 char *kwnames[] = {
9202 (char *) "ulMask", NULL
9203 };
9204
9205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9206 {
9207 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9208 if (SWIG_arg_fail(1)) SWIG_fail;
9209 }
9210 {
9211 PyThreadState* __tstate = wxPyBeginAllowThreads();
9212 wxLog::SetTraceMask(arg1);
9213
9214 wxPyEndAllowThreads(__tstate);
9215 if (PyErr_Occurred()) SWIG_fail;
9216 }
9217 Py_INCREF(Py_None); resultobj = Py_None;
9218 return resultobj;
9219 fail:
9220 return NULL;
9221 }
9222
9223
9224 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9225 PyObject *resultobj;
9226 wxString *arg1 = 0 ;
9227 bool temp1 = false ;
9228 PyObject * obj0 = 0 ;
9229 char *kwnames[] = {
9230 (char *) "str", NULL
9231 };
9232
9233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9234 {
9235 arg1 = wxString_in_helper(obj0);
9236 if (arg1 == NULL) SWIG_fail;
9237 temp1 = true;
9238 }
9239 {
9240 PyThreadState* __tstate = wxPyBeginAllowThreads();
9241 wxLog::AddTraceMask((wxString const &)*arg1);
9242
9243 wxPyEndAllowThreads(__tstate);
9244 if (PyErr_Occurred()) SWIG_fail;
9245 }
9246 Py_INCREF(Py_None); resultobj = Py_None;
9247 {
9248 if (temp1)
9249 delete arg1;
9250 }
9251 return resultobj;
9252 fail:
9253 {
9254 if (temp1)
9255 delete arg1;
9256 }
9257 return NULL;
9258 }
9259
9260
9261 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9262 PyObject *resultobj;
9263 wxString *arg1 = 0 ;
9264 bool temp1 = false ;
9265 PyObject * obj0 = 0 ;
9266 char *kwnames[] = {
9267 (char *) "str", NULL
9268 };
9269
9270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9271 {
9272 arg1 = wxString_in_helper(obj0);
9273 if (arg1 == NULL) SWIG_fail;
9274 temp1 = true;
9275 }
9276 {
9277 PyThreadState* __tstate = wxPyBeginAllowThreads();
9278 wxLog::RemoveTraceMask((wxString const &)*arg1);
9279
9280 wxPyEndAllowThreads(__tstate);
9281 if (PyErr_Occurred()) SWIG_fail;
9282 }
9283 Py_INCREF(Py_None); resultobj = Py_None;
9284 {
9285 if (temp1)
9286 delete arg1;
9287 }
9288 return resultobj;
9289 fail:
9290 {
9291 if (temp1)
9292 delete arg1;
9293 }
9294 return NULL;
9295 }
9296
9297
9298 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9299 PyObject *resultobj;
9300 char *kwnames[] = {
9301 NULL
9302 };
9303
9304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9305 {
9306 PyThreadState* __tstate = wxPyBeginAllowThreads();
9307 wxLog::ClearTraceMasks();
9308
9309 wxPyEndAllowThreads(__tstate);
9310 if (PyErr_Occurred()) SWIG_fail;
9311 }
9312 Py_INCREF(Py_None); resultobj = Py_None;
9313 return resultobj;
9314 fail:
9315 return NULL;
9316 }
9317
9318
9319 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9320 PyObject *resultobj;
9321 wxArrayString *result;
9322 char *kwnames[] = {
9323 NULL
9324 };
9325
9326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9327 {
9328 PyThreadState* __tstate = wxPyBeginAllowThreads();
9329 {
9330 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9331 result = (wxArrayString *) &_result_ref;
9332 }
9333
9334 wxPyEndAllowThreads(__tstate);
9335 if (PyErr_Occurred()) SWIG_fail;
9336 }
9337 {
9338 resultobj = wxArrayString2PyList_helper(*result);
9339 }
9340 return resultobj;
9341 fail:
9342 return NULL;
9343 }
9344
9345
9346 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9347 PyObject *resultobj;
9348 wxChar *arg1 = (wxChar *) 0 ;
9349 PyObject * obj0 = 0 ;
9350 char *kwnames[] = {
9351 (char *) "ts", NULL
9352 };
9353
9354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9356 if (SWIG_arg_fail(1)) SWIG_fail;
9357 {
9358 PyThreadState* __tstate = wxPyBeginAllowThreads();
9359 wxLog::SetTimestamp((wxChar const *)arg1);
9360
9361 wxPyEndAllowThreads(__tstate);
9362 if (PyErr_Occurred()) SWIG_fail;
9363 }
9364 Py_INCREF(Py_None); resultobj = Py_None;
9365 return resultobj;
9366 fail:
9367 return NULL;
9368 }
9369
9370
9371 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9372 PyObject *resultobj;
9373 bool result;
9374 char *kwnames[] = {
9375 NULL
9376 };
9377
9378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9379 {
9380 PyThreadState* __tstate = wxPyBeginAllowThreads();
9381 result = (bool)wxLog::GetVerbose();
9382
9383 wxPyEndAllowThreads(__tstate);
9384 if (PyErr_Occurred()) SWIG_fail;
9385 }
9386 {
9387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9388 }
9389 return resultobj;
9390 fail:
9391 return NULL;
9392 }
9393
9394
9395 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9396 PyObject *resultobj;
9397 wxTraceMask result;
9398 char *kwnames[] = {
9399 NULL
9400 };
9401
9402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9403 {
9404 PyThreadState* __tstate = wxPyBeginAllowThreads();
9405 result = (wxTraceMask)wxLog::GetTraceMask();
9406
9407 wxPyEndAllowThreads(__tstate);
9408 if (PyErr_Occurred()) SWIG_fail;
9409 }
9410 {
9411 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9412 }
9413 return resultobj;
9414 fail:
9415 return NULL;
9416 }
9417
9418
9419 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9420 PyObject *resultobj;
9421 wxChar *arg1 = (wxChar *) 0 ;
9422 bool result;
9423 PyObject * obj0 = 0 ;
9424 char *kwnames[] = {
9425 (char *) "mask", NULL
9426 };
9427
9428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9430 if (SWIG_arg_fail(1)) SWIG_fail;
9431 {
9432 PyThreadState* __tstate = wxPyBeginAllowThreads();
9433 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9434
9435 wxPyEndAllowThreads(__tstate);
9436 if (PyErr_Occurred()) SWIG_fail;
9437 }
9438 {
9439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9440 }
9441 return resultobj;
9442 fail:
9443 return NULL;
9444 }
9445
9446
9447 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9448 PyObject *resultobj;
9449 wxLogLevel result;
9450 char *kwnames[] = {
9451 NULL
9452 };
9453
9454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9455 {
9456 PyThreadState* __tstate = wxPyBeginAllowThreads();
9457 result = (wxLogLevel)wxLog::GetLogLevel();
9458
9459 wxPyEndAllowThreads(__tstate);
9460 if (PyErr_Occurred()) SWIG_fail;
9461 }
9462 {
9463 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9464 }
9465 return resultobj;
9466 fail:
9467 return NULL;
9468 }
9469
9470
9471 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9472 PyObject *resultobj;
9473 wxChar *result;
9474 char *kwnames[] = {
9475 NULL
9476 };
9477
9478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9479 {
9480 PyThreadState* __tstate = wxPyBeginAllowThreads();
9481 result = (wxChar *)wxLog::GetTimestamp();
9482
9483 wxPyEndAllowThreads(__tstate);
9484 if (PyErr_Occurred()) SWIG_fail;
9485 }
9486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9487 return resultobj;
9488 fail:
9489 return NULL;
9490 }
9491
9492
9493 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9494 PyObject *resultobj;
9495 wxString result;
9496 char *kwnames[] = {
9497 NULL
9498 };
9499
9500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9501 {
9502 PyThreadState* __tstate = wxPyBeginAllowThreads();
9503 result = Log_TimeStamp();
9504
9505 wxPyEndAllowThreads(__tstate);
9506 if (PyErr_Occurred()) SWIG_fail;
9507 }
9508 {
9509 #if wxUSE_UNICODE
9510 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9511 #else
9512 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9513 #endif
9514 }
9515 return resultobj;
9516 fail:
9517 return NULL;
9518 }
9519
9520
9521 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9522 PyObject *resultobj;
9523 wxLog *arg1 = (wxLog *) 0 ;
9524 PyObject * obj0 = 0 ;
9525 char *kwnames[] = {
9526 (char *) "self", NULL
9527 };
9528
9529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9531 if (SWIG_arg_fail(1)) SWIG_fail;
9532 {
9533 PyThreadState* __tstate = wxPyBeginAllowThreads();
9534 wxLog_Destroy(arg1);
9535
9536 wxPyEndAllowThreads(__tstate);
9537 if (PyErr_Occurred()) SWIG_fail;
9538 }
9539 Py_INCREF(Py_None); resultobj = Py_None;
9540 return resultobj;
9541 fail:
9542 return NULL;
9543 }
9544
9545
9546 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9547 PyObject *obj;
9548 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9549 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9550 Py_INCREF(obj);
9551 return Py_BuildValue((char *)"");
9552 }
9553 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9554 PyObject *resultobj;
9555 wxLogStderr *result;
9556 char *kwnames[] = {
9557 NULL
9558 };
9559
9560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9561 {
9562 PyThreadState* __tstate = wxPyBeginAllowThreads();
9563 result = (wxLogStderr *)new wxLogStderr();
9564
9565 wxPyEndAllowThreads(__tstate);
9566 if (PyErr_Occurred()) SWIG_fail;
9567 }
9568 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9569 return resultobj;
9570 fail:
9571 return NULL;
9572 }
9573
9574
9575 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9576 PyObject *obj;
9577 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9578 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9579 Py_INCREF(obj);
9580 return Py_BuildValue((char *)"");
9581 }
9582 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9583 PyObject *resultobj;
9584 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9585 wxLogTextCtrl *result;
9586 PyObject * obj0 = 0 ;
9587 char *kwnames[] = {
9588 (char *) "pTextCtrl", NULL
9589 };
9590
9591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9593 if (SWIG_arg_fail(1)) SWIG_fail;
9594 {
9595 PyThreadState* __tstate = wxPyBeginAllowThreads();
9596 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9597
9598 wxPyEndAllowThreads(__tstate);
9599 if (PyErr_Occurred()) SWIG_fail;
9600 }
9601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9602 return resultobj;
9603 fail:
9604 return NULL;
9605 }
9606
9607
9608 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9609 PyObject *obj;
9610 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9611 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9612 Py_INCREF(obj);
9613 return Py_BuildValue((char *)"");
9614 }
9615 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9616 PyObject *resultobj;
9617 wxLogGui *result;
9618 char *kwnames[] = {
9619 NULL
9620 };
9621
9622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9623 {
9624 PyThreadState* __tstate = wxPyBeginAllowThreads();
9625 result = (wxLogGui *)new wxLogGui();
9626
9627 wxPyEndAllowThreads(__tstate);
9628 if (PyErr_Occurred()) SWIG_fail;
9629 }
9630 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9631 return resultobj;
9632 fail:
9633 return NULL;
9634 }
9635
9636
9637 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9638 PyObject *obj;
9639 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9640 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9641 Py_INCREF(obj);
9642 return Py_BuildValue((char *)"");
9643 }
9644 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9645 PyObject *resultobj;
9646 wxFrame *arg1 = (wxFrame *) 0 ;
9647 wxString *arg2 = 0 ;
9648 bool arg3 = (bool) true ;
9649 bool arg4 = (bool) true ;
9650 wxLogWindow *result;
9651 bool temp2 = false ;
9652 PyObject * obj0 = 0 ;
9653 PyObject * obj1 = 0 ;
9654 PyObject * obj2 = 0 ;
9655 PyObject * obj3 = 0 ;
9656 char *kwnames[] = {
9657 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9658 };
9659
9660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9662 if (SWIG_arg_fail(1)) SWIG_fail;
9663 {
9664 arg2 = wxString_in_helper(obj1);
9665 if (arg2 == NULL) SWIG_fail;
9666 temp2 = true;
9667 }
9668 if (obj2) {
9669 {
9670 arg3 = (bool)(SWIG_As_bool(obj2));
9671 if (SWIG_arg_fail(3)) SWIG_fail;
9672 }
9673 }
9674 if (obj3) {
9675 {
9676 arg4 = (bool)(SWIG_As_bool(obj3));
9677 if (SWIG_arg_fail(4)) SWIG_fail;
9678 }
9679 }
9680 {
9681 PyThreadState* __tstate = wxPyBeginAllowThreads();
9682 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9683
9684 wxPyEndAllowThreads(__tstate);
9685 if (PyErr_Occurred()) SWIG_fail;
9686 }
9687 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9688 {
9689 if (temp2)
9690 delete arg2;
9691 }
9692 return resultobj;
9693 fail:
9694 {
9695 if (temp2)
9696 delete arg2;
9697 }
9698 return NULL;
9699 }
9700
9701
9702 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9703 PyObject *resultobj;
9704 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9705 bool arg2 = (bool) true ;
9706 PyObject * obj0 = 0 ;
9707 PyObject * obj1 = 0 ;
9708 char *kwnames[] = {
9709 (char *) "self",(char *) "bShow", NULL
9710 };
9711
9712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9714 if (SWIG_arg_fail(1)) SWIG_fail;
9715 if (obj1) {
9716 {
9717 arg2 = (bool)(SWIG_As_bool(obj1));
9718 if (SWIG_arg_fail(2)) SWIG_fail;
9719 }
9720 }
9721 {
9722 PyThreadState* __tstate = wxPyBeginAllowThreads();
9723 (arg1)->Show(arg2);
9724
9725 wxPyEndAllowThreads(__tstate);
9726 if (PyErr_Occurred()) SWIG_fail;
9727 }
9728 Py_INCREF(Py_None); resultobj = Py_None;
9729 return resultobj;
9730 fail:
9731 return NULL;
9732 }
9733
9734
9735 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9736 PyObject *resultobj;
9737 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9738 wxFrame *result;
9739 PyObject * obj0 = 0 ;
9740 char *kwnames[] = {
9741 (char *) "self", NULL
9742 };
9743
9744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9746 if (SWIG_arg_fail(1)) SWIG_fail;
9747 {
9748 PyThreadState* __tstate = wxPyBeginAllowThreads();
9749 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9750
9751 wxPyEndAllowThreads(__tstate);
9752 if (PyErr_Occurred()) SWIG_fail;
9753 }
9754 {
9755 resultobj = wxPyMake_wxObject(result, 0);
9756 }
9757 return resultobj;
9758 fail:
9759 return NULL;
9760 }
9761
9762
9763 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9764 PyObject *resultobj;
9765 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9766 wxLog *result;
9767 PyObject * obj0 = 0 ;
9768 char *kwnames[] = {
9769 (char *) "self", NULL
9770 };
9771
9772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9774 if (SWIG_arg_fail(1)) SWIG_fail;
9775 {
9776 PyThreadState* __tstate = wxPyBeginAllowThreads();
9777 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9778
9779 wxPyEndAllowThreads(__tstate);
9780 if (PyErr_Occurred()) SWIG_fail;
9781 }
9782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9783 return resultobj;
9784 fail:
9785 return NULL;
9786 }
9787
9788
9789 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9790 PyObject *resultobj;
9791 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9792 bool result;
9793 PyObject * obj0 = 0 ;
9794 char *kwnames[] = {
9795 (char *) "self", NULL
9796 };
9797
9798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9800 if (SWIG_arg_fail(1)) SWIG_fail;
9801 {
9802 PyThreadState* __tstate = wxPyBeginAllowThreads();
9803 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9804
9805 wxPyEndAllowThreads(__tstate);
9806 if (PyErr_Occurred()) SWIG_fail;
9807 }
9808 {
9809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9810 }
9811 return resultobj;
9812 fail:
9813 return NULL;
9814 }
9815
9816
9817 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9818 PyObject *resultobj;
9819 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9820 bool arg2 ;
9821 PyObject * obj0 = 0 ;
9822 PyObject * obj1 = 0 ;
9823 char *kwnames[] = {
9824 (char *) "self",(char *) "bDoPass", NULL
9825 };
9826
9827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9829 if (SWIG_arg_fail(1)) SWIG_fail;
9830 {
9831 arg2 = (bool)(SWIG_As_bool(obj1));
9832 if (SWIG_arg_fail(2)) SWIG_fail;
9833 }
9834 {
9835 PyThreadState* __tstate = wxPyBeginAllowThreads();
9836 (arg1)->PassMessages(arg2);
9837
9838 wxPyEndAllowThreads(__tstate);
9839 if (PyErr_Occurred()) SWIG_fail;
9840 }
9841 Py_INCREF(Py_None); resultobj = Py_None;
9842 return resultobj;
9843 fail:
9844 return NULL;
9845 }
9846
9847
9848 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9849 PyObject *obj;
9850 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9851 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9852 Py_INCREF(obj);
9853 return Py_BuildValue((char *)"");
9854 }
9855 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9856 PyObject *resultobj;
9857 wxLog *arg1 = (wxLog *) 0 ;
9858 wxLogChain *result;
9859 PyObject * obj0 = 0 ;
9860 char *kwnames[] = {
9861 (char *) "logger", NULL
9862 };
9863
9864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9866 if (SWIG_arg_fail(1)) SWIG_fail;
9867 {
9868 PyThreadState* __tstate = wxPyBeginAllowThreads();
9869 result = (wxLogChain *)new wxLogChain(arg1);
9870
9871 wxPyEndAllowThreads(__tstate);
9872 if (PyErr_Occurred()) SWIG_fail;
9873 }
9874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9875 return resultobj;
9876 fail:
9877 return NULL;
9878 }
9879
9880
9881 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9882 PyObject *resultobj;
9883 wxLogChain *arg1 = (wxLogChain *) 0 ;
9884 wxLog *arg2 = (wxLog *) 0 ;
9885 PyObject * obj0 = 0 ;
9886 PyObject * obj1 = 0 ;
9887 char *kwnames[] = {
9888 (char *) "self",(char *) "logger", NULL
9889 };
9890
9891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9893 if (SWIG_arg_fail(1)) SWIG_fail;
9894 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9895 if (SWIG_arg_fail(2)) SWIG_fail;
9896 {
9897 PyThreadState* __tstate = wxPyBeginAllowThreads();
9898 (arg1)->SetLog(arg2);
9899
9900 wxPyEndAllowThreads(__tstate);
9901 if (PyErr_Occurred()) SWIG_fail;
9902 }
9903 Py_INCREF(Py_None); resultobj = Py_None;
9904 return resultobj;
9905 fail:
9906 return NULL;
9907 }
9908
9909
9910 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9911 PyObject *resultobj;
9912 wxLogChain *arg1 = (wxLogChain *) 0 ;
9913 bool arg2 ;
9914 PyObject * obj0 = 0 ;
9915 PyObject * obj1 = 0 ;
9916 char *kwnames[] = {
9917 (char *) "self",(char *) "bDoPass", NULL
9918 };
9919
9920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9922 if (SWIG_arg_fail(1)) SWIG_fail;
9923 {
9924 arg2 = (bool)(SWIG_As_bool(obj1));
9925 if (SWIG_arg_fail(2)) SWIG_fail;
9926 }
9927 {
9928 PyThreadState* __tstate = wxPyBeginAllowThreads();
9929 (arg1)->PassMessages(arg2);
9930
9931 wxPyEndAllowThreads(__tstate);
9932 if (PyErr_Occurred()) SWIG_fail;
9933 }
9934 Py_INCREF(Py_None); resultobj = Py_None;
9935 return resultobj;
9936 fail:
9937 return NULL;
9938 }
9939
9940
9941 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9942 PyObject *resultobj;
9943 wxLogChain *arg1 = (wxLogChain *) 0 ;
9944 bool result;
9945 PyObject * obj0 = 0 ;
9946 char *kwnames[] = {
9947 (char *) "self", NULL
9948 };
9949
9950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9952 if (SWIG_arg_fail(1)) SWIG_fail;
9953 {
9954 PyThreadState* __tstate = wxPyBeginAllowThreads();
9955 result = (bool)(arg1)->IsPassingMessages();
9956
9957 wxPyEndAllowThreads(__tstate);
9958 if (PyErr_Occurred()) SWIG_fail;
9959 }
9960 {
9961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9962 }
9963 return resultobj;
9964 fail:
9965 return NULL;
9966 }
9967
9968
9969 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9970 PyObject *resultobj;
9971 wxLogChain *arg1 = (wxLogChain *) 0 ;
9972 wxLog *result;
9973 PyObject * obj0 = 0 ;
9974 char *kwnames[] = {
9975 (char *) "self", NULL
9976 };
9977
9978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9980 if (SWIG_arg_fail(1)) SWIG_fail;
9981 {
9982 PyThreadState* __tstate = wxPyBeginAllowThreads();
9983 result = (wxLog *)(arg1)->GetOldLog();
9984
9985 wxPyEndAllowThreads(__tstate);
9986 if (PyErr_Occurred()) SWIG_fail;
9987 }
9988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9989 return resultobj;
9990 fail:
9991 return NULL;
9992 }
9993
9994
9995 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9996 PyObject *obj;
9997 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9998 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9999 Py_INCREF(obj);
10000 return Py_BuildValue((char *)"");
10001 }
10002 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10003 PyObject *resultobj;
10004 unsigned long result;
10005 char *kwnames[] = {
10006 NULL
10007 };
10008
10009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10010 {
10011 PyThreadState* __tstate = wxPyBeginAllowThreads();
10012 result = (unsigned long)wxSysErrorCode();
10013
10014 wxPyEndAllowThreads(__tstate);
10015 if (PyErr_Occurred()) SWIG_fail;
10016 }
10017 {
10018 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10019 }
10020 return resultobj;
10021 fail:
10022 return NULL;
10023 }
10024
10025
10026 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10027 PyObject *resultobj;
10028 unsigned long arg1 = (unsigned long) 0 ;
10029 wxString result;
10030 PyObject * obj0 = 0 ;
10031 char *kwnames[] = {
10032 (char *) "nErrCode", NULL
10033 };
10034
10035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10036 if (obj0) {
10037 {
10038 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10039 if (SWIG_arg_fail(1)) SWIG_fail;
10040 }
10041 }
10042 {
10043 PyThreadState* __tstate = wxPyBeginAllowThreads();
10044 result = wxSysErrorMsg(arg1);
10045
10046 wxPyEndAllowThreads(__tstate);
10047 if (PyErr_Occurred()) SWIG_fail;
10048 }
10049 {
10050 #if wxUSE_UNICODE
10051 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10052 #else
10053 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10054 #endif
10055 }
10056 return resultobj;
10057 fail:
10058 return NULL;
10059 }
10060
10061
10062 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10063 PyObject *resultobj;
10064 wxString *arg1 = 0 ;
10065 bool temp1 = false ;
10066 PyObject * obj0 = 0 ;
10067 char *kwnames[] = {
10068 (char *) "msg", NULL
10069 };
10070
10071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10072 {
10073 arg1 = wxString_in_helper(obj0);
10074 if (arg1 == NULL) SWIG_fail;
10075 temp1 = true;
10076 }
10077 {
10078 PyThreadState* __tstate = wxPyBeginAllowThreads();
10079 wxPyLogFatalError((wxString const &)*arg1);
10080
10081 wxPyEndAllowThreads(__tstate);
10082 if (PyErr_Occurred()) SWIG_fail;
10083 }
10084 Py_INCREF(Py_None); resultobj = Py_None;
10085 {
10086 if (temp1)
10087 delete arg1;
10088 }
10089 return resultobj;
10090 fail:
10091 {
10092 if (temp1)
10093 delete arg1;
10094 }
10095 return NULL;
10096 }
10097
10098
10099 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10100 PyObject *resultobj;
10101 wxString *arg1 = 0 ;
10102 bool temp1 = false ;
10103 PyObject * obj0 = 0 ;
10104 char *kwnames[] = {
10105 (char *) "msg", NULL
10106 };
10107
10108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10109 {
10110 arg1 = wxString_in_helper(obj0);
10111 if (arg1 == NULL) SWIG_fail;
10112 temp1 = true;
10113 }
10114 {
10115 PyThreadState* __tstate = wxPyBeginAllowThreads();
10116 wxPyLogError((wxString const &)*arg1);
10117
10118 wxPyEndAllowThreads(__tstate);
10119 if (PyErr_Occurred()) SWIG_fail;
10120 }
10121 Py_INCREF(Py_None); resultobj = Py_None;
10122 {
10123 if (temp1)
10124 delete arg1;
10125 }
10126 return resultobj;
10127 fail:
10128 {
10129 if (temp1)
10130 delete arg1;
10131 }
10132 return NULL;
10133 }
10134
10135
10136 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10137 PyObject *resultobj;
10138 wxString *arg1 = 0 ;
10139 bool temp1 = false ;
10140 PyObject * obj0 = 0 ;
10141 char *kwnames[] = {
10142 (char *) "msg", NULL
10143 };
10144
10145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10146 {
10147 arg1 = wxString_in_helper(obj0);
10148 if (arg1 == NULL) SWIG_fail;
10149 temp1 = true;
10150 }
10151 {
10152 PyThreadState* __tstate = wxPyBeginAllowThreads();
10153 wxPyLogWarning((wxString const &)*arg1);
10154
10155 wxPyEndAllowThreads(__tstate);
10156 if (PyErr_Occurred()) SWIG_fail;
10157 }
10158 Py_INCREF(Py_None); resultobj = Py_None;
10159 {
10160 if (temp1)
10161 delete arg1;
10162 }
10163 return resultobj;
10164 fail:
10165 {
10166 if (temp1)
10167 delete arg1;
10168 }
10169 return NULL;
10170 }
10171
10172
10173 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10174 PyObject *resultobj;
10175 wxString *arg1 = 0 ;
10176 bool temp1 = false ;
10177 PyObject * obj0 = 0 ;
10178 char *kwnames[] = {
10179 (char *) "msg", NULL
10180 };
10181
10182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10183 {
10184 arg1 = wxString_in_helper(obj0);
10185 if (arg1 == NULL) SWIG_fail;
10186 temp1 = true;
10187 }
10188 {
10189 PyThreadState* __tstate = wxPyBeginAllowThreads();
10190 wxPyLogMessage((wxString const &)*arg1);
10191
10192 wxPyEndAllowThreads(__tstate);
10193 if (PyErr_Occurred()) SWIG_fail;
10194 }
10195 Py_INCREF(Py_None); resultobj = Py_None;
10196 {
10197 if (temp1)
10198 delete arg1;
10199 }
10200 return resultobj;
10201 fail:
10202 {
10203 if (temp1)
10204 delete arg1;
10205 }
10206 return NULL;
10207 }
10208
10209
10210 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10211 PyObject *resultobj;
10212 wxString *arg1 = 0 ;
10213 bool temp1 = false ;
10214 PyObject * obj0 = 0 ;
10215 char *kwnames[] = {
10216 (char *) "msg", NULL
10217 };
10218
10219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10220 {
10221 arg1 = wxString_in_helper(obj0);
10222 if (arg1 == NULL) SWIG_fail;
10223 temp1 = true;
10224 }
10225 {
10226 PyThreadState* __tstate = wxPyBeginAllowThreads();
10227 wxPyLogInfo((wxString const &)*arg1);
10228
10229 wxPyEndAllowThreads(__tstate);
10230 if (PyErr_Occurred()) SWIG_fail;
10231 }
10232 Py_INCREF(Py_None); resultobj = Py_None;
10233 {
10234 if (temp1)
10235 delete arg1;
10236 }
10237 return resultobj;
10238 fail:
10239 {
10240 if (temp1)
10241 delete arg1;
10242 }
10243 return NULL;
10244 }
10245
10246
10247 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10248 PyObject *resultobj;
10249 wxString *arg1 = 0 ;
10250 bool temp1 = false ;
10251 PyObject * obj0 = 0 ;
10252 char *kwnames[] = {
10253 (char *) "msg", NULL
10254 };
10255
10256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10257 {
10258 arg1 = wxString_in_helper(obj0);
10259 if (arg1 == NULL) SWIG_fail;
10260 temp1 = true;
10261 }
10262 {
10263 PyThreadState* __tstate = wxPyBeginAllowThreads();
10264 wxPyLogDebug((wxString const &)*arg1);
10265
10266 wxPyEndAllowThreads(__tstate);
10267 if (PyErr_Occurred()) SWIG_fail;
10268 }
10269 Py_INCREF(Py_None); resultobj = Py_None;
10270 {
10271 if (temp1)
10272 delete arg1;
10273 }
10274 return resultobj;
10275 fail:
10276 {
10277 if (temp1)
10278 delete arg1;
10279 }
10280 return NULL;
10281 }
10282
10283
10284 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10285 PyObject *resultobj;
10286 wxString *arg1 = 0 ;
10287 bool temp1 = false ;
10288 PyObject * obj0 = 0 ;
10289 char *kwnames[] = {
10290 (char *) "msg", NULL
10291 };
10292
10293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10294 {
10295 arg1 = wxString_in_helper(obj0);
10296 if (arg1 == NULL) SWIG_fail;
10297 temp1 = true;
10298 }
10299 {
10300 PyThreadState* __tstate = wxPyBeginAllowThreads();
10301 wxPyLogVerbose((wxString const &)*arg1);
10302
10303 wxPyEndAllowThreads(__tstate);
10304 if (PyErr_Occurred()) SWIG_fail;
10305 }
10306 Py_INCREF(Py_None); resultobj = Py_None;
10307 {
10308 if (temp1)
10309 delete arg1;
10310 }
10311 return resultobj;
10312 fail:
10313 {
10314 if (temp1)
10315 delete arg1;
10316 }
10317 return NULL;
10318 }
10319
10320
10321 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10322 PyObject *resultobj;
10323 wxString *arg1 = 0 ;
10324 bool temp1 = false ;
10325 PyObject * obj0 = 0 ;
10326 char *kwnames[] = {
10327 (char *) "msg", NULL
10328 };
10329
10330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10331 {
10332 arg1 = wxString_in_helper(obj0);
10333 if (arg1 == NULL) SWIG_fail;
10334 temp1 = true;
10335 }
10336 {
10337 PyThreadState* __tstate = wxPyBeginAllowThreads();
10338 wxPyLogStatus((wxString const &)*arg1);
10339
10340 wxPyEndAllowThreads(__tstate);
10341 if (PyErr_Occurred()) SWIG_fail;
10342 }
10343 Py_INCREF(Py_None); resultobj = Py_None;
10344 {
10345 if (temp1)
10346 delete arg1;
10347 }
10348 return resultobj;
10349 fail:
10350 {
10351 if (temp1)
10352 delete arg1;
10353 }
10354 return NULL;
10355 }
10356
10357
10358 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10359 PyObject *resultobj;
10360 wxFrame *arg1 = (wxFrame *) 0 ;
10361 wxString *arg2 = 0 ;
10362 bool temp2 = false ;
10363 PyObject * obj0 = 0 ;
10364 PyObject * obj1 = 0 ;
10365 char *kwnames[] = {
10366 (char *) "pFrame",(char *) "msg", NULL
10367 };
10368
10369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10371 if (SWIG_arg_fail(1)) SWIG_fail;
10372 {
10373 arg2 = wxString_in_helper(obj1);
10374 if (arg2 == NULL) SWIG_fail;
10375 temp2 = true;
10376 }
10377 {
10378 PyThreadState* __tstate = wxPyBeginAllowThreads();
10379 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10380
10381 wxPyEndAllowThreads(__tstate);
10382 if (PyErr_Occurred()) SWIG_fail;
10383 }
10384 Py_INCREF(Py_None); resultobj = Py_None;
10385 {
10386 if (temp2)
10387 delete arg2;
10388 }
10389 return resultobj;
10390 fail:
10391 {
10392 if (temp2)
10393 delete arg2;
10394 }
10395 return NULL;
10396 }
10397
10398
10399 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10400 PyObject *resultobj;
10401 wxString *arg1 = 0 ;
10402 bool temp1 = false ;
10403 PyObject * obj0 = 0 ;
10404 char *kwnames[] = {
10405 (char *) "msg", NULL
10406 };
10407
10408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10409 {
10410 arg1 = wxString_in_helper(obj0);
10411 if (arg1 == NULL) SWIG_fail;
10412 temp1 = true;
10413 }
10414 {
10415 PyThreadState* __tstate = wxPyBeginAllowThreads();
10416 wxPyLogSysError((wxString const &)*arg1);
10417
10418 wxPyEndAllowThreads(__tstate);
10419 if (PyErr_Occurred()) SWIG_fail;
10420 }
10421 Py_INCREF(Py_None); resultobj = Py_None;
10422 {
10423 if (temp1)
10424 delete arg1;
10425 }
10426 return resultobj;
10427 fail:
10428 {
10429 if (temp1)
10430 delete arg1;
10431 }
10432 return NULL;
10433 }
10434
10435
10436 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10437 PyObject *resultobj;
10438 unsigned long arg1 ;
10439 wxString *arg2 = 0 ;
10440 bool temp2 = false ;
10441 PyObject * obj0 = 0 ;
10442 PyObject * obj1 = 0 ;
10443 char *kwnames[] = {
10444 (char *) "level",(char *) "msg", NULL
10445 };
10446
10447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10448 {
10449 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10450 if (SWIG_arg_fail(1)) SWIG_fail;
10451 }
10452 {
10453 arg2 = wxString_in_helper(obj1);
10454 if (arg2 == NULL) SWIG_fail;
10455 temp2 = true;
10456 }
10457 {
10458 PyThreadState* __tstate = wxPyBeginAllowThreads();
10459 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10460
10461 wxPyEndAllowThreads(__tstate);
10462 if (PyErr_Occurred()) SWIG_fail;
10463 }
10464 Py_INCREF(Py_None); resultobj = Py_None;
10465 {
10466 if (temp2)
10467 delete arg2;
10468 }
10469 return resultobj;
10470 fail:
10471 {
10472 if (temp2)
10473 delete arg2;
10474 }
10475 return NULL;
10476 }
10477
10478
10479 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10480 PyObject *resultobj;
10481 unsigned long arg1 ;
10482 wxString *arg2 = 0 ;
10483 bool temp2 = false ;
10484 PyObject * obj0 = 0 ;
10485 PyObject * obj1 = 0 ;
10486
10487 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10488 {
10489 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10490 if (SWIG_arg_fail(1)) SWIG_fail;
10491 }
10492 {
10493 arg2 = wxString_in_helper(obj1);
10494 if (arg2 == NULL) SWIG_fail;
10495 temp2 = true;
10496 }
10497 {
10498 PyThreadState* __tstate = wxPyBeginAllowThreads();
10499 wxPyLogTrace(arg1,(wxString const &)*arg2);
10500
10501 wxPyEndAllowThreads(__tstate);
10502 if (PyErr_Occurred()) SWIG_fail;
10503 }
10504 Py_INCREF(Py_None); resultobj = Py_None;
10505 {
10506 if (temp2)
10507 delete arg2;
10508 }
10509 return resultobj;
10510 fail:
10511 {
10512 if (temp2)
10513 delete arg2;
10514 }
10515 return NULL;
10516 }
10517
10518
10519 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10520 PyObject *resultobj;
10521 wxString *arg1 = 0 ;
10522 wxString *arg2 = 0 ;
10523 bool temp1 = false ;
10524 bool temp2 = false ;
10525 PyObject * obj0 = 0 ;
10526 PyObject * obj1 = 0 ;
10527
10528 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10529 {
10530 arg1 = wxString_in_helper(obj0);
10531 if (arg1 == NULL) SWIG_fail;
10532 temp1 = true;
10533 }
10534 {
10535 arg2 = wxString_in_helper(obj1);
10536 if (arg2 == NULL) SWIG_fail;
10537 temp2 = true;
10538 }
10539 {
10540 PyThreadState* __tstate = wxPyBeginAllowThreads();
10541 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10542
10543 wxPyEndAllowThreads(__tstate);
10544 if (PyErr_Occurred()) SWIG_fail;
10545 }
10546 Py_INCREF(Py_None); resultobj = Py_None;
10547 {
10548 if (temp1)
10549 delete arg1;
10550 }
10551 {
10552 if (temp2)
10553 delete arg2;
10554 }
10555 return resultobj;
10556 fail:
10557 {
10558 if (temp1)
10559 delete arg1;
10560 }
10561 {
10562 if (temp2)
10563 delete arg2;
10564 }
10565 return NULL;
10566 }
10567
10568
10569 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10570 int argc;
10571 PyObject *argv[3];
10572 int ii;
10573
10574 argc = PyObject_Length(args);
10575 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10576 argv[ii] = PyTuple_GetItem(args,ii);
10577 }
10578 if (argc == 2) {
10579 int _v;
10580 {
10581 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10582 }
10583 if (_v) {
10584 {
10585 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10586 }
10587 if (_v) {
10588 return _wrap_LogTrace__SWIG_1(self,args);
10589 }
10590 }
10591 }
10592 if (argc == 2) {
10593 int _v;
10594 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10595 if (_v) {
10596 {
10597 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10598 }
10599 if (_v) {
10600 return _wrap_LogTrace__SWIG_0(self,args);
10601 }
10602 }
10603 }
10604
10605 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10606 return NULL;
10607 }
10608
10609
10610 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10611 PyObject *resultobj;
10612 wxString *arg1 = 0 ;
10613 wxString *arg2 = 0 ;
10614 bool temp1 = false ;
10615 bool temp2 = false ;
10616 PyObject * obj0 = 0 ;
10617 PyObject * obj1 = 0 ;
10618 char *kwnames[] = {
10619 (char *) "title",(char *) "text", NULL
10620 };
10621
10622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10623 {
10624 arg1 = wxString_in_helper(obj0);
10625 if (arg1 == NULL) SWIG_fail;
10626 temp1 = true;
10627 }
10628 {
10629 arg2 = wxString_in_helper(obj1);
10630 if (arg2 == NULL) SWIG_fail;
10631 temp2 = true;
10632 }
10633 {
10634 PyThreadState* __tstate = wxPyBeginAllowThreads();
10635 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10636
10637 wxPyEndAllowThreads(__tstate);
10638 if (PyErr_Occurred()) SWIG_fail;
10639 }
10640 Py_INCREF(Py_None); resultobj = Py_None;
10641 {
10642 if (temp1)
10643 delete arg1;
10644 }
10645 {
10646 if (temp2)
10647 delete arg2;
10648 }
10649 return resultobj;
10650 fail:
10651 {
10652 if (temp1)
10653 delete arg1;
10654 }
10655 {
10656 if (temp2)
10657 delete arg2;
10658 }
10659 return NULL;
10660 }
10661
10662
10663 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10664 PyObject *resultobj;
10665 wxLogNull *result;
10666 char *kwnames[] = {
10667 NULL
10668 };
10669
10670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10671 {
10672 PyThreadState* __tstate = wxPyBeginAllowThreads();
10673 result = (wxLogNull *)new wxLogNull();
10674
10675 wxPyEndAllowThreads(__tstate);
10676 if (PyErr_Occurred()) SWIG_fail;
10677 }
10678 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10679 return resultobj;
10680 fail:
10681 return NULL;
10682 }
10683
10684
10685 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10686 PyObject *resultobj;
10687 wxLogNull *arg1 = (wxLogNull *) 0 ;
10688 PyObject * obj0 = 0 ;
10689 char *kwnames[] = {
10690 (char *) "self", NULL
10691 };
10692
10693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10695 if (SWIG_arg_fail(1)) SWIG_fail;
10696 {
10697 PyThreadState* __tstate = wxPyBeginAllowThreads();
10698 delete arg1;
10699
10700 wxPyEndAllowThreads(__tstate);
10701 if (PyErr_Occurred()) SWIG_fail;
10702 }
10703 Py_INCREF(Py_None); resultobj = Py_None;
10704 return resultobj;
10705 fail:
10706 return NULL;
10707 }
10708
10709
10710 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10711 PyObject *obj;
10712 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10713 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10714 Py_INCREF(obj);
10715 return Py_BuildValue((char *)"");
10716 }
10717 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10718 PyObject *resultobj;
10719 wxPyLog *result;
10720 char *kwnames[] = {
10721 NULL
10722 };
10723
10724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10725 {
10726 PyThreadState* __tstate = wxPyBeginAllowThreads();
10727 result = (wxPyLog *)new wxPyLog();
10728
10729 wxPyEndAllowThreads(__tstate);
10730 if (PyErr_Occurred()) SWIG_fail;
10731 }
10732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10733 return resultobj;
10734 fail:
10735 return NULL;
10736 }
10737
10738
10739 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10740 PyObject *resultobj;
10741 wxPyLog *arg1 = (wxPyLog *) 0 ;
10742 PyObject *arg2 = (PyObject *) 0 ;
10743 PyObject *arg3 = (PyObject *) 0 ;
10744 PyObject * obj0 = 0 ;
10745 PyObject * obj1 = 0 ;
10746 PyObject * obj2 = 0 ;
10747 char *kwnames[] = {
10748 (char *) "self",(char *) "self",(char *) "_class", NULL
10749 };
10750
10751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10753 if (SWIG_arg_fail(1)) SWIG_fail;
10754 arg2 = obj1;
10755 arg3 = obj2;
10756 {
10757 PyThreadState* __tstate = wxPyBeginAllowThreads();
10758 (arg1)->_setCallbackInfo(arg2,arg3);
10759
10760 wxPyEndAllowThreads(__tstate);
10761 if (PyErr_Occurred()) SWIG_fail;
10762 }
10763 Py_INCREF(Py_None); resultobj = Py_None;
10764 return resultobj;
10765 fail:
10766 return NULL;
10767 }
10768
10769
10770 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10771 PyObject *obj;
10772 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10773 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10774 Py_INCREF(obj);
10775 return Py_BuildValue((char *)"");
10776 }
10777 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10778 PyObject *resultobj;
10779 int arg1 ;
10780 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10781 int arg3 = (int) wxKILL_NOCHILDREN ;
10782 wxKillError result;
10783 PyObject * obj0 = 0 ;
10784 PyObject * obj1 = 0 ;
10785 PyObject * obj2 = 0 ;
10786 char *kwnames[] = {
10787 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10788 };
10789
10790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10791 {
10792 arg1 = (int)(SWIG_As_int(obj0));
10793 if (SWIG_arg_fail(1)) SWIG_fail;
10794 }
10795 if (obj1) {
10796 {
10797 arg2 = (wxSignal)(SWIG_As_int(obj1));
10798 if (SWIG_arg_fail(2)) SWIG_fail;
10799 }
10800 }
10801 if (obj2) {
10802 {
10803 arg3 = (int)(SWIG_As_int(obj2));
10804 if (SWIG_arg_fail(3)) SWIG_fail;
10805 }
10806 }
10807 {
10808 PyThreadState* __tstate = wxPyBeginAllowThreads();
10809 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10810
10811 wxPyEndAllowThreads(__tstate);
10812 if (PyErr_Occurred()) SWIG_fail;
10813 }
10814 resultobj = SWIG_From_int((result));
10815 return resultobj;
10816 fail:
10817 return NULL;
10818 }
10819
10820
10821 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10822 PyObject *resultobj;
10823 int arg1 ;
10824 bool result;
10825 PyObject * obj0 = 0 ;
10826 char *kwnames[] = {
10827 (char *) "pid", NULL
10828 };
10829
10830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10831 {
10832 arg1 = (int)(SWIG_As_int(obj0));
10833 if (SWIG_arg_fail(1)) SWIG_fail;
10834 }
10835 {
10836 PyThreadState* __tstate = wxPyBeginAllowThreads();
10837 result = (bool)wxPyProcess::Exists(arg1);
10838
10839 wxPyEndAllowThreads(__tstate);
10840 if (PyErr_Occurred()) SWIG_fail;
10841 }
10842 {
10843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10844 }
10845 return resultobj;
10846 fail:
10847 return NULL;
10848 }
10849
10850
10851 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10852 PyObject *resultobj;
10853 wxString *arg1 = 0 ;
10854 int arg2 = (int) wxEXEC_ASYNC ;
10855 wxPyProcess *result;
10856 bool temp1 = false ;
10857 PyObject * obj0 = 0 ;
10858 PyObject * obj1 = 0 ;
10859 char *kwnames[] = {
10860 (char *) "cmd",(char *) "flags", NULL
10861 };
10862
10863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10864 {
10865 arg1 = wxString_in_helper(obj0);
10866 if (arg1 == NULL) SWIG_fail;
10867 temp1 = true;
10868 }
10869 if (obj1) {
10870 {
10871 arg2 = (int)(SWIG_As_int(obj1));
10872 if (SWIG_arg_fail(2)) SWIG_fail;
10873 }
10874 }
10875 {
10876 PyThreadState* __tstate = wxPyBeginAllowThreads();
10877 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10878
10879 wxPyEndAllowThreads(__tstate);
10880 if (PyErr_Occurred()) SWIG_fail;
10881 }
10882 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10883 {
10884 if (temp1)
10885 delete arg1;
10886 }
10887 return resultobj;
10888 fail:
10889 {
10890 if (temp1)
10891 delete arg1;
10892 }
10893 return NULL;
10894 }
10895
10896
10897 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10898 PyObject *resultobj;
10899 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10900 int arg2 = (int) -1 ;
10901 wxPyProcess *result;
10902 PyObject * obj0 = 0 ;
10903 PyObject * obj1 = 0 ;
10904 char *kwnames[] = {
10905 (char *) "parent",(char *) "id", NULL
10906 };
10907
10908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10909 if (obj0) {
10910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10911 if (SWIG_arg_fail(1)) SWIG_fail;
10912 }
10913 if (obj1) {
10914 {
10915 arg2 = (int)(SWIG_As_int(obj1));
10916 if (SWIG_arg_fail(2)) SWIG_fail;
10917 }
10918 }
10919 {
10920 PyThreadState* __tstate = wxPyBeginAllowThreads();
10921 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10922
10923 wxPyEndAllowThreads(__tstate);
10924 if (PyErr_Occurred()) SWIG_fail;
10925 }
10926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10927 return resultobj;
10928 fail:
10929 return NULL;
10930 }
10931
10932
10933 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10934 PyObject *resultobj;
10935 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10936 PyObject *arg2 = (PyObject *) 0 ;
10937 PyObject *arg3 = (PyObject *) 0 ;
10938 PyObject * obj0 = 0 ;
10939 PyObject * obj1 = 0 ;
10940 PyObject * obj2 = 0 ;
10941 char *kwnames[] = {
10942 (char *) "self",(char *) "self",(char *) "_class", NULL
10943 };
10944
10945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10947 if (SWIG_arg_fail(1)) SWIG_fail;
10948 arg2 = obj1;
10949 arg3 = obj2;
10950 {
10951 PyThreadState* __tstate = wxPyBeginAllowThreads();
10952 (arg1)->_setCallbackInfo(arg2,arg3);
10953
10954 wxPyEndAllowThreads(__tstate);
10955 if (PyErr_Occurred()) SWIG_fail;
10956 }
10957 Py_INCREF(Py_None); resultobj = Py_None;
10958 return resultobj;
10959 fail:
10960 return NULL;
10961 }
10962
10963
10964 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10965 PyObject *resultobj;
10966 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10967 int arg2 ;
10968 int arg3 ;
10969 PyObject * obj0 = 0 ;
10970 PyObject * obj1 = 0 ;
10971 PyObject * obj2 = 0 ;
10972 char *kwnames[] = {
10973 (char *) "self",(char *) "pid",(char *) "status", NULL
10974 };
10975
10976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10978 if (SWIG_arg_fail(1)) SWIG_fail;
10979 {
10980 arg2 = (int)(SWIG_As_int(obj1));
10981 if (SWIG_arg_fail(2)) SWIG_fail;
10982 }
10983 {
10984 arg3 = (int)(SWIG_As_int(obj2));
10985 if (SWIG_arg_fail(3)) SWIG_fail;
10986 }
10987 {
10988 PyThreadState* __tstate = wxPyBeginAllowThreads();
10989 (arg1)->base_OnTerminate(arg2,arg3);
10990
10991 wxPyEndAllowThreads(__tstate);
10992 if (PyErr_Occurred()) SWIG_fail;
10993 }
10994 Py_INCREF(Py_None); resultobj = Py_None;
10995 return resultobj;
10996 fail:
10997 return NULL;
10998 }
10999
11000
11001 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11002 PyObject *resultobj;
11003 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11004 PyObject * obj0 = 0 ;
11005 char *kwnames[] = {
11006 (char *) "self", NULL
11007 };
11008
11009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11011 if (SWIG_arg_fail(1)) SWIG_fail;
11012 {
11013 PyThreadState* __tstate = wxPyBeginAllowThreads();
11014 (arg1)->Redirect();
11015
11016 wxPyEndAllowThreads(__tstate);
11017 if (PyErr_Occurred()) SWIG_fail;
11018 }
11019 Py_INCREF(Py_None); resultobj = Py_None;
11020 return resultobj;
11021 fail:
11022 return NULL;
11023 }
11024
11025
11026 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11027 PyObject *resultobj;
11028 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11029 bool result;
11030 PyObject * obj0 = 0 ;
11031 char *kwnames[] = {
11032 (char *) "self", NULL
11033 };
11034
11035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11037 if (SWIG_arg_fail(1)) SWIG_fail;
11038 {
11039 PyThreadState* __tstate = wxPyBeginAllowThreads();
11040 result = (bool)(arg1)->IsRedirected();
11041
11042 wxPyEndAllowThreads(__tstate);
11043 if (PyErr_Occurred()) SWIG_fail;
11044 }
11045 {
11046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11047 }
11048 return resultobj;
11049 fail:
11050 return NULL;
11051 }
11052
11053
11054 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11055 PyObject *resultobj;
11056 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11057 PyObject * obj0 = 0 ;
11058 char *kwnames[] = {
11059 (char *) "self", NULL
11060 };
11061
11062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11064 if (SWIG_arg_fail(1)) SWIG_fail;
11065 {
11066 PyThreadState* __tstate = wxPyBeginAllowThreads();
11067 (arg1)->Detach();
11068
11069 wxPyEndAllowThreads(__tstate);
11070 if (PyErr_Occurred()) SWIG_fail;
11071 }
11072 Py_INCREF(Py_None); resultobj = Py_None;
11073 return resultobj;
11074 fail:
11075 return NULL;
11076 }
11077
11078
11079 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11080 PyObject *resultobj;
11081 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11082 wxInputStream *result;
11083 PyObject * obj0 = 0 ;
11084 char *kwnames[] = {
11085 (char *) "self", NULL
11086 };
11087
11088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11090 if (SWIG_arg_fail(1)) SWIG_fail;
11091 {
11092 PyThreadState* __tstate = wxPyBeginAllowThreads();
11093 result = (wxInputStream *)(arg1)->GetInputStream();
11094
11095 wxPyEndAllowThreads(__tstate);
11096 if (PyErr_Occurred()) SWIG_fail;
11097 }
11098 {
11099 wxPyInputStream * _ptr = NULL;
11100
11101 if (result) {
11102 _ptr = new wxPyInputStream(result);
11103 }
11104 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11105 }
11106 return resultobj;
11107 fail:
11108 return NULL;
11109 }
11110
11111
11112 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11113 PyObject *resultobj;
11114 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11115 wxInputStream *result;
11116 PyObject * obj0 = 0 ;
11117 char *kwnames[] = {
11118 (char *) "self", NULL
11119 };
11120
11121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11123 if (SWIG_arg_fail(1)) SWIG_fail;
11124 {
11125 PyThreadState* __tstate = wxPyBeginAllowThreads();
11126 result = (wxInputStream *)(arg1)->GetErrorStream();
11127
11128 wxPyEndAllowThreads(__tstate);
11129 if (PyErr_Occurred()) SWIG_fail;
11130 }
11131 {
11132 wxPyInputStream * _ptr = NULL;
11133
11134 if (result) {
11135 _ptr = new wxPyInputStream(result);
11136 }
11137 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11138 }
11139 return resultobj;
11140 fail:
11141 return NULL;
11142 }
11143
11144
11145 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11146 PyObject *resultobj;
11147 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11148 wxOutputStream *result;
11149 PyObject * obj0 = 0 ;
11150 char *kwnames[] = {
11151 (char *) "self", NULL
11152 };
11153
11154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11156 if (SWIG_arg_fail(1)) SWIG_fail;
11157 {
11158 PyThreadState* __tstate = wxPyBeginAllowThreads();
11159 result = (wxOutputStream *)(arg1)->GetOutputStream();
11160
11161 wxPyEndAllowThreads(__tstate);
11162 if (PyErr_Occurred()) SWIG_fail;
11163 }
11164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11165 return resultobj;
11166 fail:
11167 return NULL;
11168 }
11169
11170
11171 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11172 PyObject *resultobj;
11173 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11174 PyObject * obj0 = 0 ;
11175 char *kwnames[] = {
11176 (char *) "self", NULL
11177 };
11178
11179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11181 if (SWIG_arg_fail(1)) SWIG_fail;
11182 {
11183 PyThreadState* __tstate = wxPyBeginAllowThreads();
11184 (arg1)->CloseOutput();
11185
11186 wxPyEndAllowThreads(__tstate);
11187 if (PyErr_Occurred()) SWIG_fail;
11188 }
11189 Py_INCREF(Py_None); resultobj = Py_None;
11190 return resultobj;
11191 fail:
11192 return NULL;
11193 }
11194
11195
11196 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11197 PyObject *resultobj;
11198 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11199 bool result;
11200 PyObject * obj0 = 0 ;
11201 char *kwnames[] = {
11202 (char *) "self", NULL
11203 };
11204
11205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11207 if (SWIG_arg_fail(1)) SWIG_fail;
11208 {
11209 PyThreadState* __tstate = wxPyBeginAllowThreads();
11210 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11211
11212 wxPyEndAllowThreads(__tstate);
11213 if (PyErr_Occurred()) SWIG_fail;
11214 }
11215 {
11216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11217 }
11218 return resultobj;
11219 fail:
11220 return NULL;
11221 }
11222
11223
11224 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11225 PyObject *resultobj;
11226 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11227 bool result;
11228 PyObject * obj0 = 0 ;
11229 char *kwnames[] = {
11230 (char *) "self", NULL
11231 };
11232
11233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11235 if (SWIG_arg_fail(1)) SWIG_fail;
11236 {
11237 PyThreadState* __tstate = wxPyBeginAllowThreads();
11238 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11239
11240 wxPyEndAllowThreads(__tstate);
11241 if (PyErr_Occurred()) SWIG_fail;
11242 }
11243 {
11244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11245 }
11246 return resultobj;
11247 fail:
11248 return NULL;
11249 }
11250
11251
11252 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11253 PyObject *resultobj;
11254 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11255 bool result;
11256 PyObject * obj0 = 0 ;
11257 char *kwnames[] = {
11258 (char *) "self", NULL
11259 };
11260
11261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11263 if (SWIG_arg_fail(1)) SWIG_fail;
11264 {
11265 PyThreadState* __tstate = wxPyBeginAllowThreads();
11266 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11267
11268 wxPyEndAllowThreads(__tstate);
11269 if (PyErr_Occurred()) SWIG_fail;
11270 }
11271 {
11272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11273 }
11274 return resultobj;
11275 fail:
11276 return NULL;
11277 }
11278
11279
11280 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11281 PyObject *obj;
11282 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11283 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11284 Py_INCREF(obj);
11285 return Py_BuildValue((char *)"");
11286 }
11287 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11288 PyObject *resultobj;
11289 int arg1 = (int) 0 ;
11290 int arg2 = (int) 0 ;
11291 int arg3 = (int) 0 ;
11292 wxProcessEvent *result;
11293 PyObject * obj0 = 0 ;
11294 PyObject * obj1 = 0 ;
11295 PyObject * obj2 = 0 ;
11296 char *kwnames[] = {
11297 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11298 };
11299
11300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11301 if (obj0) {
11302 {
11303 arg1 = (int)(SWIG_As_int(obj0));
11304 if (SWIG_arg_fail(1)) SWIG_fail;
11305 }
11306 }
11307 if (obj1) {
11308 {
11309 arg2 = (int)(SWIG_As_int(obj1));
11310 if (SWIG_arg_fail(2)) SWIG_fail;
11311 }
11312 }
11313 if (obj2) {
11314 {
11315 arg3 = (int)(SWIG_As_int(obj2));
11316 if (SWIG_arg_fail(3)) SWIG_fail;
11317 }
11318 }
11319 {
11320 PyThreadState* __tstate = wxPyBeginAllowThreads();
11321 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11322
11323 wxPyEndAllowThreads(__tstate);
11324 if (PyErr_Occurred()) SWIG_fail;
11325 }
11326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11327 return resultobj;
11328 fail:
11329 return NULL;
11330 }
11331
11332
11333 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11334 PyObject *resultobj;
11335 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11336 int result;
11337 PyObject * obj0 = 0 ;
11338 char *kwnames[] = {
11339 (char *) "self", NULL
11340 };
11341
11342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11344 if (SWIG_arg_fail(1)) SWIG_fail;
11345 {
11346 PyThreadState* __tstate = wxPyBeginAllowThreads();
11347 result = (int)(arg1)->GetPid();
11348
11349 wxPyEndAllowThreads(__tstate);
11350 if (PyErr_Occurred()) SWIG_fail;
11351 }
11352 {
11353 resultobj = SWIG_From_int((int)(result));
11354 }
11355 return resultobj;
11356 fail:
11357 return NULL;
11358 }
11359
11360
11361 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11362 PyObject *resultobj;
11363 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11364 int result;
11365 PyObject * obj0 = 0 ;
11366 char *kwnames[] = {
11367 (char *) "self", NULL
11368 };
11369
11370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11372 if (SWIG_arg_fail(1)) SWIG_fail;
11373 {
11374 PyThreadState* __tstate = wxPyBeginAllowThreads();
11375 result = (int)(arg1)->GetExitCode();
11376
11377 wxPyEndAllowThreads(__tstate);
11378 if (PyErr_Occurred()) SWIG_fail;
11379 }
11380 {
11381 resultobj = SWIG_From_int((int)(result));
11382 }
11383 return resultobj;
11384 fail:
11385 return NULL;
11386 }
11387
11388
11389 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11390 PyObject *resultobj;
11391 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11392 int arg2 ;
11393 PyObject * obj0 = 0 ;
11394 PyObject * obj1 = 0 ;
11395 char *kwnames[] = {
11396 (char *) "self",(char *) "m_pid", NULL
11397 };
11398
11399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11401 if (SWIG_arg_fail(1)) SWIG_fail;
11402 {
11403 arg2 = (int)(SWIG_As_int(obj1));
11404 if (SWIG_arg_fail(2)) SWIG_fail;
11405 }
11406 if (arg1) (arg1)->m_pid = arg2;
11407
11408 Py_INCREF(Py_None); resultobj = Py_None;
11409 return resultobj;
11410 fail:
11411 return NULL;
11412 }
11413
11414
11415 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11416 PyObject *resultobj;
11417 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11418 int result;
11419 PyObject * obj0 = 0 ;
11420 char *kwnames[] = {
11421 (char *) "self", NULL
11422 };
11423
11424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11426 if (SWIG_arg_fail(1)) SWIG_fail;
11427 result = (int) ((arg1)->m_pid);
11428
11429 {
11430 resultobj = SWIG_From_int((int)(result));
11431 }
11432 return resultobj;
11433 fail:
11434 return NULL;
11435 }
11436
11437
11438 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11439 PyObject *resultobj;
11440 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11441 int arg2 ;
11442 PyObject * obj0 = 0 ;
11443 PyObject * obj1 = 0 ;
11444 char *kwnames[] = {
11445 (char *) "self",(char *) "m_exitcode", NULL
11446 };
11447
11448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11450 if (SWIG_arg_fail(1)) SWIG_fail;
11451 {
11452 arg2 = (int)(SWIG_As_int(obj1));
11453 if (SWIG_arg_fail(2)) SWIG_fail;
11454 }
11455 if (arg1) (arg1)->m_exitcode = arg2;
11456
11457 Py_INCREF(Py_None); resultobj = Py_None;
11458 return resultobj;
11459 fail:
11460 return NULL;
11461 }
11462
11463
11464 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11465 PyObject *resultobj;
11466 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11467 int result;
11468 PyObject * obj0 = 0 ;
11469 char *kwnames[] = {
11470 (char *) "self", NULL
11471 };
11472
11473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11475 if (SWIG_arg_fail(1)) SWIG_fail;
11476 result = (int) ((arg1)->m_exitcode);
11477
11478 {
11479 resultobj = SWIG_From_int((int)(result));
11480 }
11481 return resultobj;
11482 fail:
11483 return NULL;
11484 }
11485
11486
11487 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11488 PyObject *obj;
11489 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11490 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11491 Py_INCREF(obj);
11492 return Py_BuildValue((char *)"");
11493 }
11494 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11495 PyObject *resultobj;
11496 wxString *arg1 = 0 ;
11497 int arg2 = (int) wxEXEC_ASYNC ;
11498 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11499 long result;
11500 bool temp1 = false ;
11501 PyObject * obj0 = 0 ;
11502 PyObject * obj1 = 0 ;
11503 PyObject * obj2 = 0 ;
11504 char *kwnames[] = {
11505 (char *) "command",(char *) "flags",(char *) "process", NULL
11506 };
11507
11508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11509 {
11510 arg1 = wxString_in_helper(obj0);
11511 if (arg1 == NULL) SWIG_fail;
11512 temp1 = true;
11513 }
11514 if (obj1) {
11515 {
11516 arg2 = (int)(SWIG_As_int(obj1));
11517 if (SWIG_arg_fail(2)) SWIG_fail;
11518 }
11519 }
11520 if (obj2) {
11521 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11522 if (SWIG_arg_fail(3)) SWIG_fail;
11523 }
11524 {
11525 if (!wxPyCheckForApp()) SWIG_fail;
11526 PyThreadState* __tstate = wxPyBeginAllowThreads();
11527 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11528
11529 wxPyEndAllowThreads(__tstate);
11530 if (PyErr_Occurred()) SWIG_fail;
11531 }
11532 {
11533 resultobj = SWIG_From_long((long)(result));
11534 }
11535 {
11536 if (temp1)
11537 delete arg1;
11538 }
11539 return resultobj;
11540 fail:
11541 {
11542 if (temp1)
11543 delete arg1;
11544 }
11545 return NULL;
11546 }
11547
11548
11549 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11550 PyObject *resultobj;
11551 long arg1 ;
11552 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11553 wxKillError *arg3 = (wxKillError *) 0 ;
11554 int arg4 = (int) wxKILL_NOCHILDREN ;
11555 int result;
11556 wxKillError temp3 ;
11557 PyObject * obj0 = 0 ;
11558 PyObject * obj1 = 0 ;
11559 PyObject * obj2 = 0 ;
11560 char *kwnames[] = {
11561 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11562 };
11563
11564 {
11565 arg3 = &temp3;
11566 }
11567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11568 {
11569 arg1 = (long)(SWIG_As_long(obj0));
11570 if (SWIG_arg_fail(1)) SWIG_fail;
11571 }
11572 if (obj1) {
11573 {
11574 arg2 = (wxSignal)(SWIG_As_int(obj1));
11575 if (SWIG_arg_fail(2)) SWIG_fail;
11576 }
11577 }
11578 if (obj2) {
11579 {
11580 arg4 = (int)(SWIG_As_int(obj2));
11581 if (SWIG_arg_fail(4)) SWIG_fail;
11582 }
11583 }
11584 {
11585 PyThreadState* __tstate = wxPyBeginAllowThreads();
11586 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11587
11588 wxPyEndAllowThreads(__tstate);
11589 if (PyErr_Occurred()) SWIG_fail;
11590 }
11591 {
11592 resultobj = SWIG_From_int((int)(result));
11593 }
11594 {
11595 PyObject* o;
11596 o = PyInt_FromLong((long) (*arg3));
11597 resultobj = t_output_helper(resultobj, o);
11598 }
11599 return resultobj;
11600 fail:
11601 return NULL;
11602 }
11603
11604
11605 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11606 PyObject *resultobj;
11607 int arg1 = (int) wxJOYSTICK1 ;
11608 wxJoystick *result;
11609 PyObject * obj0 = 0 ;
11610 char *kwnames[] = {
11611 (char *) "joystick", NULL
11612 };
11613
11614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11615 if (obj0) {
11616 {
11617 arg1 = (int)(SWIG_As_int(obj0));
11618 if (SWIG_arg_fail(1)) SWIG_fail;
11619 }
11620 }
11621 {
11622 if (!wxPyCheckForApp()) SWIG_fail;
11623 PyThreadState* __tstate = wxPyBeginAllowThreads();
11624 result = (wxJoystick *)new wxJoystick(arg1);
11625
11626 wxPyEndAllowThreads(__tstate);
11627 if (PyErr_Occurred()) SWIG_fail;
11628 }
11629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11630 return resultobj;
11631 fail:
11632 return NULL;
11633 }
11634
11635
11636 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11637 PyObject *resultobj;
11638 wxJoystick *arg1 = (wxJoystick *) 0 ;
11639 PyObject * obj0 = 0 ;
11640 char *kwnames[] = {
11641 (char *) "self", NULL
11642 };
11643
11644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11646 if (SWIG_arg_fail(1)) SWIG_fail;
11647 {
11648 PyThreadState* __tstate = wxPyBeginAllowThreads();
11649 delete arg1;
11650
11651 wxPyEndAllowThreads(__tstate);
11652 if (PyErr_Occurred()) SWIG_fail;
11653 }
11654 Py_INCREF(Py_None); resultobj = Py_None;
11655 return resultobj;
11656 fail:
11657 return NULL;
11658 }
11659
11660
11661 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11662 PyObject *resultobj;
11663 wxJoystick *arg1 = (wxJoystick *) 0 ;
11664 wxPoint result;
11665 PyObject * obj0 = 0 ;
11666 char *kwnames[] = {
11667 (char *) "self", NULL
11668 };
11669
11670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11672 if (SWIG_arg_fail(1)) SWIG_fail;
11673 {
11674 PyThreadState* __tstate = wxPyBeginAllowThreads();
11675 result = (arg1)->GetPosition();
11676
11677 wxPyEndAllowThreads(__tstate);
11678 if (PyErr_Occurred()) SWIG_fail;
11679 }
11680 {
11681 wxPoint * resultptr;
11682 resultptr = new wxPoint((wxPoint &)(result));
11683 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11684 }
11685 return resultobj;
11686 fail:
11687 return NULL;
11688 }
11689
11690
11691 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11692 PyObject *resultobj;
11693 wxJoystick *arg1 = (wxJoystick *) 0 ;
11694 int result;
11695 PyObject * obj0 = 0 ;
11696 char *kwnames[] = {
11697 (char *) "self", NULL
11698 };
11699
11700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11702 if (SWIG_arg_fail(1)) SWIG_fail;
11703 {
11704 PyThreadState* __tstate = wxPyBeginAllowThreads();
11705 result = (int)(arg1)->GetZPosition();
11706
11707 wxPyEndAllowThreads(__tstate);
11708 if (PyErr_Occurred()) SWIG_fail;
11709 }
11710 {
11711 resultobj = SWIG_From_int((int)(result));
11712 }
11713 return resultobj;
11714 fail:
11715 return NULL;
11716 }
11717
11718
11719 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11720 PyObject *resultobj;
11721 wxJoystick *arg1 = (wxJoystick *) 0 ;
11722 int result;
11723 PyObject * obj0 = 0 ;
11724 char *kwnames[] = {
11725 (char *) "self", NULL
11726 };
11727
11728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11730 if (SWIG_arg_fail(1)) SWIG_fail;
11731 {
11732 PyThreadState* __tstate = wxPyBeginAllowThreads();
11733 result = (int)(arg1)->GetButtonState();
11734
11735 wxPyEndAllowThreads(__tstate);
11736 if (PyErr_Occurred()) SWIG_fail;
11737 }
11738 {
11739 resultobj = SWIG_From_int((int)(result));
11740 }
11741 return resultobj;
11742 fail:
11743 return NULL;
11744 }
11745
11746
11747 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11748 PyObject *resultobj;
11749 wxJoystick *arg1 = (wxJoystick *) 0 ;
11750 int result;
11751 PyObject * obj0 = 0 ;
11752 char *kwnames[] = {
11753 (char *) "self", NULL
11754 };
11755
11756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11758 if (SWIG_arg_fail(1)) SWIG_fail;
11759 {
11760 PyThreadState* __tstate = wxPyBeginAllowThreads();
11761 result = (int)(arg1)->GetPOVPosition();
11762
11763 wxPyEndAllowThreads(__tstate);
11764 if (PyErr_Occurred()) SWIG_fail;
11765 }
11766 {
11767 resultobj = SWIG_From_int((int)(result));
11768 }
11769 return resultobj;
11770 fail:
11771 return NULL;
11772 }
11773
11774
11775 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11776 PyObject *resultobj;
11777 wxJoystick *arg1 = (wxJoystick *) 0 ;
11778 int result;
11779 PyObject * obj0 = 0 ;
11780 char *kwnames[] = {
11781 (char *) "self", NULL
11782 };
11783
11784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11786 if (SWIG_arg_fail(1)) SWIG_fail;
11787 {
11788 PyThreadState* __tstate = wxPyBeginAllowThreads();
11789 result = (int)(arg1)->GetPOVCTSPosition();
11790
11791 wxPyEndAllowThreads(__tstate);
11792 if (PyErr_Occurred()) SWIG_fail;
11793 }
11794 {
11795 resultobj = SWIG_From_int((int)(result));
11796 }
11797 return resultobj;
11798 fail:
11799 return NULL;
11800 }
11801
11802
11803 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11804 PyObject *resultobj;
11805 wxJoystick *arg1 = (wxJoystick *) 0 ;
11806 int result;
11807 PyObject * obj0 = 0 ;
11808 char *kwnames[] = {
11809 (char *) "self", NULL
11810 };
11811
11812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11814 if (SWIG_arg_fail(1)) SWIG_fail;
11815 {
11816 PyThreadState* __tstate = wxPyBeginAllowThreads();
11817 result = (int)(arg1)->GetRudderPosition();
11818
11819 wxPyEndAllowThreads(__tstate);
11820 if (PyErr_Occurred()) SWIG_fail;
11821 }
11822 {
11823 resultobj = SWIG_From_int((int)(result));
11824 }
11825 return resultobj;
11826 fail:
11827 return NULL;
11828 }
11829
11830
11831 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11832 PyObject *resultobj;
11833 wxJoystick *arg1 = (wxJoystick *) 0 ;
11834 int result;
11835 PyObject * obj0 = 0 ;
11836 char *kwnames[] = {
11837 (char *) "self", NULL
11838 };
11839
11840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11842 if (SWIG_arg_fail(1)) SWIG_fail;
11843 {
11844 PyThreadState* __tstate = wxPyBeginAllowThreads();
11845 result = (int)(arg1)->GetUPosition();
11846
11847 wxPyEndAllowThreads(__tstate);
11848 if (PyErr_Occurred()) SWIG_fail;
11849 }
11850 {
11851 resultobj = SWIG_From_int((int)(result));
11852 }
11853 return resultobj;
11854 fail:
11855 return NULL;
11856 }
11857
11858
11859 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11860 PyObject *resultobj;
11861 wxJoystick *arg1 = (wxJoystick *) 0 ;
11862 int result;
11863 PyObject * obj0 = 0 ;
11864 char *kwnames[] = {
11865 (char *) "self", NULL
11866 };
11867
11868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11870 if (SWIG_arg_fail(1)) SWIG_fail;
11871 {
11872 PyThreadState* __tstate = wxPyBeginAllowThreads();
11873 result = (int)(arg1)->GetVPosition();
11874
11875 wxPyEndAllowThreads(__tstate);
11876 if (PyErr_Occurred()) SWIG_fail;
11877 }
11878 {
11879 resultobj = SWIG_From_int((int)(result));
11880 }
11881 return resultobj;
11882 fail:
11883 return NULL;
11884 }
11885
11886
11887 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11888 PyObject *resultobj;
11889 wxJoystick *arg1 = (wxJoystick *) 0 ;
11890 int result;
11891 PyObject * obj0 = 0 ;
11892 char *kwnames[] = {
11893 (char *) "self", NULL
11894 };
11895
11896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11898 if (SWIG_arg_fail(1)) SWIG_fail;
11899 {
11900 PyThreadState* __tstate = wxPyBeginAllowThreads();
11901 result = (int)(arg1)->GetMovementThreshold();
11902
11903 wxPyEndAllowThreads(__tstate);
11904 if (PyErr_Occurred()) SWIG_fail;
11905 }
11906 {
11907 resultobj = SWIG_From_int((int)(result));
11908 }
11909 return resultobj;
11910 fail:
11911 return NULL;
11912 }
11913
11914
11915 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11916 PyObject *resultobj;
11917 wxJoystick *arg1 = (wxJoystick *) 0 ;
11918 int arg2 ;
11919 PyObject * obj0 = 0 ;
11920 PyObject * obj1 = 0 ;
11921 char *kwnames[] = {
11922 (char *) "self",(char *) "threshold", NULL
11923 };
11924
11925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11927 if (SWIG_arg_fail(1)) SWIG_fail;
11928 {
11929 arg2 = (int)(SWIG_As_int(obj1));
11930 if (SWIG_arg_fail(2)) SWIG_fail;
11931 }
11932 {
11933 PyThreadState* __tstate = wxPyBeginAllowThreads();
11934 (arg1)->SetMovementThreshold(arg2);
11935
11936 wxPyEndAllowThreads(__tstate);
11937 if (PyErr_Occurred()) SWIG_fail;
11938 }
11939 Py_INCREF(Py_None); resultobj = Py_None;
11940 return resultobj;
11941 fail:
11942 return NULL;
11943 }
11944
11945
11946 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11947 PyObject *resultobj;
11948 wxJoystick *arg1 = (wxJoystick *) 0 ;
11949 bool result;
11950 PyObject * obj0 = 0 ;
11951 char *kwnames[] = {
11952 (char *) "self", NULL
11953 };
11954
11955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11957 if (SWIG_arg_fail(1)) SWIG_fail;
11958 {
11959 PyThreadState* __tstate = wxPyBeginAllowThreads();
11960 result = (bool)(arg1)->IsOk();
11961
11962 wxPyEndAllowThreads(__tstate);
11963 if (PyErr_Occurred()) SWIG_fail;
11964 }
11965 {
11966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11967 }
11968 return resultobj;
11969 fail:
11970 return NULL;
11971 }
11972
11973
11974 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11975 PyObject *resultobj;
11976 wxJoystick *arg1 = (wxJoystick *) 0 ;
11977 int result;
11978 PyObject * obj0 = 0 ;
11979 char *kwnames[] = {
11980 (char *) "self", NULL
11981 };
11982
11983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11985 if (SWIG_arg_fail(1)) SWIG_fail;
11986 {
11987 PyThreadState* __tstate = wxPyBeginAllowThreads();
11988 result = (int)(arg1)->GetNumberJoysticks();
11989
11990 wxPyEndAllowThreads(__tstate);
11991 if (PyErr_Occurred()) SWIG_fail;
11992 }
11993 {
11994 resultobj = SWIG_From_int((int)(result));
11995 }
11996 return resultobj;
11997 fail:
11998 return NULL;
11999 }
12000
12001
12002 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12003 PyObject *resultobj;
12004 wxJoystick *arg1 = (wxJoystick *) 0 ;
12005 int result;
12006 PyObject * obj0 = 0 ;
12007 char *kwnames[] = {
12008 (char *) "self", NULL
12009 };
12010
12011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12013 if (SWIG_arg_fail(1)) SWIG_fail;
12014 {
12015 PyThreadState* __tstate = wxPyBeginAllowThreads();
12016 result = (int)(arg1)->GetManufacturerId();
12017
12018 wxPyEndAllowThreads(__tstate);
12019 if (PyErr_Occurred()) SWIG_fail;
12020 }
12021 {
12022 resultobj = SWIG_From_int((int)(result));
12023 }
12024 return resultobj;
12025 fail:
12026 return NULL;
12027 }
12028
12029
12030 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12031 PyObject *resultobj;
12032 wxJoystick *arg1 = (wxJoystick *) 0 ;
12033 int result;
12034 PyObject * obj0 = 0 ;
12035 char *kwnames[] = {
12036 (char *) "self", NULL
12037 };
12038
12039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12041 if (SWIG_arg_fail(1)) SWIG_fail;
12042 {
12043 PyThreadState* __tstate = wxPyBeginAllowThreads();
12044 result = (int)(arg1)->GetProductId();
12045
12046 wxPyEndAllowThreads(__tstate);
12047 if (PyErr_Occurred()) SWIG_fail;
12048 }
12049 {
12050 resultobj = SWIG_From_int((int)(result));
12051 }
12052 return resultobj;
12053 fail:
12054 return NULL;
12055 }
12056
12057
12058 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12059 PyObject *resultobj;
12060 wxJoystick *arg1 = (wxJoystick *) 0 ;
12061 wxString result;
12062 PyObject * obj0 = 0 ;
12063 char *kwnames[] = {
12064 (char *) "self", NULL
12065 };
12066
12067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12069 if (SWIG_arg_fail(1)) SWIG_fail;
12070 {
12071 PyThreadState* __tstate = wxPyBeginAllowThreads();
12072 result = (arg1)->GetProductName();
12073
12074 wxPyEndAllowThreads(__tstate);
12075 if (PyErr_Occurred()) SWIG_fail;
12076 }
12077 {
12078 #if wxUSE_UNICODE
12079 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12080 #else
12081 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12082 #endif
12083 }
12084 return resultobj;
12085 fail:
12086 return NULL;
12087 }
12088
12089
12090 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12091 PyObject *resultobj;
12092 wxJoystick *arg1 = (wxJoystick *) 0 ;
12093 int result;
12094 PyObject * obj0 = 0 ;
12095 char *kwnames[] = {
12096 (char *) "self", NULL
12097 };
12098
12099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12101 if (SWIG_arg_fail(1)) SWIG_fail;
12102 {
12103 PyThreadState* __tstate = wxPyBeginAllowThreads();
12104 result = (int)(arg1)->GetXMin();
12105
12106 wxPyEndAllowThreads(__tstate);
12107 if (PyErr_Occurred()) SWIG_fail;
12108 }
12109 {
12110 resultobj = SWIG_From_int((int)(result));
12111 }
12112 return resultobj;
12113 fail:
12114 return NULL;
12115 }
12116
12117
12118 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12119 PyObject *resultobj;
12120 wxJoystick *arg1 = (wxJoystick *) 0 ;
12121 int result;
12122 PyObject * obj0 = 0 ;
12123 char *kwnames[] = {
12124 (char *) "self", NULL
12125 };
12126
12127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12129 if (SWIG_arg_fail(1)) SWIG_fail;
12130 {
12131 PyThreadState* __tstate = wxPyBeginAllowThreads();
12132 result = (int)(arg1)->GetYMin();
12133
12134 wxPyEndAllowThreads(__tstate);
12135 if (PyErr_Occurred()) SWIG_fail;
12136 }
12137 {
12138 resultobj = SWIG_From_int((int)(result));
12139 }
12140 return resultobj;
12141 fail:
12142 return NULL;
12143 }
12144
12145
12146 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12147 PyObject *resultobj;
12148 wxJoystick *arg1 = (wxJoystick *) 0 ;
12149 int result;
12150 PyObject * obj0 = 0 ;
12151 char *kwnames[] = {
12152 (char *) "self", NULL
12153 };
12154
12155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12157 if (SWIG_arg_fail(1)) SWIG_fail;
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 result = (int)(arg1)->GetZMin();
12161
12162 wxPyEndAllowThreads(__tstate);
12163 if (PyErr_Occurred()) SWIG_fail;
12164 }
12165 {
12166 resultobj = SWIG_From_int((int)(result));
12167 }
12168 return resultobj;
12169 fail:
12170 return NULL;
12171 }
12172
12173
12174 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12175 PyObject *resultobj;
12176 wxJoystick *arg1 = (wxJoystick *) 0 ;
12177 int result;
12178 PyObject * obj0 = 0 ;
12179 char *kwnames[] = {
12180 (char *) "self", NULL
12181 };
12182
12183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12185 if (SWIG_arg_fail(1)) SWIG_fail;
12186 {
12187 PyThreadState* __tstate = wxPyBeginAllowThreads();
12188 result = (int)(arg1)->GetXMax();
12189
12190 wxPyEndAllowThreads(__tstate);
12191 if (PyErr_Occurred()) SWIG_fail;
12192 }
12193 {
12194 resultobj = SWIG_From_int((int)(result));
12195 }
12196 return resultobj;
12197 fail:
12198 return NULL;
12199 }
12200
12201
12202 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12203 PyObject *resultobj;
12204 wxJoystick *arg1 = (wxJoystick *) 0 ;
12205 int result;
12206 PyObject * obj0 = 0 ;
12207 char *kwnames[] = {
12208 (char *) "self", NULL
12209 };
12210
12211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12213 if (SWIG_arg_fail(1)) SWIG_fail;
12214 {
12215 PyThreadState* __tstate = wxPyBeginAllowThreads();
12216 result = (int)(arg1)->GetYMax();
12217
12218 wxPyEndAllowThreads(__tstate);
12219 if (PyErr_Occurred()) SWIG_fail;
12220 }
12221 {
12222 resultobj = SWIG_From_int((int)(result));
12223 }
12224 return resultobj;
12225 fail:
12226 return NULL;
12227 }
12228
12229
12230 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12231 PyObject *resultobj;
12232 wxJoystick *arg1 = (wxJoystick *) 0 ;
12233 int result;
12234 PyObject * obj0 = 0 ;
12235 char *kwnames[] = {
12236 (char *) "self", NULL
12237 };
12238
12239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12241 if (SWIG_arg_fail(1)) SWIG_fail;
12242 {
12243 PyThreadState* __tstate = wxPyBeginAllowThreads();
12244 result = (int)(arg1)->GetZMax();
12245
12246 wxPyEndAllowThreads(__tstate);
12247 if (PyErr_Occurred()) SWIG_fail;
12248 }
12249 {
12250 resultobj = SWIG_From_int((int)(result));
12251 }
12252 return resultobj;
12253 fail:
12254 return NULL;
12255 }
12256
12257
12258 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12259 PyObject *resultobj;
12260 wxJoystick *arg1 = (wxJoystick *) 0 ;
12261 int result;
12262 PyObject * obj0 = 0 ;
12263 char *kwnames[] = {
12264 (char *) "self", NULL
12265 };
12266
12267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12269 if (SWIG_arg_fail(1)) SWIG_fail;
12270 {
12271 PyThreadState* __tstate = wxPyBeginAllowThreads();
12272 result = (int)(arg1)->GetNumberButtons();
12273
12274 wxPyEndAllowThreads(__tstate);
12275 if (PyErr_Occurred()) SWIG_fail;
12276 }
12277 {
12278 resultobj = SWIG_From_int((int)(result));
12279 }
12280 return resultobj;
12281 fail:
12282 return NULL;
12283 }
12284
12285
12286 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12287 PyObject *resultobj;
12288 wxJoystick *arg1 = (wxJoystick *) 0 ;
12289 int result;
12290 PyObject * obj0 = 0 ;
12291 char *kwnames[] = {
12292 (char *) "self", NULL
12293 };
12294
12295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12297 if (SWIG_arg_fail(1)) SWIG_fail;
12298 {
12299 PyThreadState* __tstate = wxPyBeginAllowThreads();
12300 result = (int)(arg1)->GetNumberAxes();
12301
12302 wxPyEndAllowThreads(__tstate);
12303 if (PyErr_Occurred()) SWIG_fail;
12304 }
12305 {
12306 resultobj = SWIG_From_int((int)(result));
12307 }
12308 return resultobj;
12309 fail:
12310 return NULL;
12311 }
12312
12313
12314 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12315 PyObject *resultobj;
12316 wxJoystick *arg1 = (wxJoystick *) 0 ;
12317 int result;
12318 PyObject * obj0 = 0 ;
12319 char *kwnames[] = {
12320 (char *) "self", NULL
12321 };
12322
12323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12325 if (SWIG_arg_fail(1)) SWIG_fail;
12326 {
12327 PyThreadState* __tstate = wxPyBeginAllowThreads();
12328 result = (int)(arg1)->GetMaxButtons();
12329
12330 wxPyEndAllowThreads(__tstate);
12331 if (PyErr_Occurred()) SWIG_fail;
12332 }
12333 {
12334 resultobj = SWIG_From_int((int)(result));
12335 }
12336 return resultobj;
12337 fail:
12338 return NULL;
12339 }
12340
12341
12342 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12343 PyObject *resultobj;
12344 wxJoystick *arg1 = (wxJoystick *) 0 ;
12345 int result;
12346 PyObject * obj0 = 0 ;
12347 char *kwnames[] = {
12348 (char *) "self", NULL
12349 };
12350
12351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12353 if (SWIG_arg_fail(1)) SWIG_fail;
12354 {
12355 PyThreadState* __tstate = wxPyBeginAllowThreads();
12356 result = (int)(arg1)->GetMaxAxes();
12357
12358 wxPyEndAllowThreads(__tstate);
12359 if (PyErr_Occurred()) SWIG_fail;
12360 }
12361 {
12362 resultobj = SWIG_From_int((int)(result));
12363 }
12364 return resultobj;
12365 fail:
12366 return NULL;
12367 }
12368
12369
12370 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12371 PyObject *resultobj;
12372 wxJoystick *arg1 = (wxJoystick *) 0 ;
12373 int result;
12374 PyObject * obj0 = 0 ;
12375 char *kwnames[] = {
12376 (char *) "self", NULL
12377 };
12378
12379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12381 if (SWIG_arg_fail(1)) SWIG_fail;
12382 {
12383 PyThreadState* __tstate = wxPyBeginAllowThreads();
12384 result = (int)(arg1)->GetPollingMin();
12385
12386 wxPyEndAllowThreads(__tstate);
12387 if (PyErr_Occurred()) SWIG_fail;
12388 }
12389 {
12390 resultobj = SWIG_From_int((int)(result));
12391 }
12392 return resultobj;
12393 fail:
12394 return NULL;
12395 }
12396
12397
12398 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12399 PyObject *resultobj;
12400 wxJoystick *arg1 = (wxJoystick *) 0 ;
12401 int result;
12402 PyObject * obj0 = 0 ;
12403 char *kwnames[] = {
12404 (char *) "self", NULL
12405 };
12406
12407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12409 if (SWIG_arg_fail(1)) SWIG_fail;
12410 {
12411 PyThreadState* __tstate = wxPyBeginAllowThreads();
12412 result = (int)(arg1)->GetPollingMax();
12413
12414 wxPyEndAllowThreads(__tstate);
12415 if (PyErr_Occurred()) SWIG_fail;
12416 }
12417 {
12418 resultobj = SWIG_From_int((int)(result));
12419 }
12420 return resultobj;
12421 fail:
12422 return NULL;
12423 }
12424
12425
12426 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12427 PyObject *resultobj;
12428 wxJoystick *arg1 = (wxJoystick *) 0 ;
12429 int result;
12430 PyObject * obj0 = 0 ;
12431 char *kwnames[] = {
12432 (char *) "self", NULL
12433 };
12434
12435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12437 if (SWIG_arg_fail(1)) SWIG_fail;
12438 {
12439 PyThreadState* __tstate = wxPyBeginAllowThreads();
12440 result = (int)(arg1)->GetRudderMin();
12441
12442 wxPyEndAllowThreads(__tstate);
12443 if (PyErr_Occurred()) SWIG_fail;
12444 }
12445 {
12446 resultobj = SWIG_From_int((int)(result));
12447 }
12448 return resultobj;
12449 fail:
12450 return NULL;
12451 }
12452
12453
12454 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12455 PyObject *resultobj;
12456 wxJoystick *arg1 = (wxJoystick *) 0 ;
12457 int result;
12458 PyObject * obj0 = 0 ;
12459 char *kwnames[] = {
12460 (char *) "self", NULL
12461 };
12462
12463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12465 if (SWIG_arg_fail(1)) SWIG_fail;
12466 {
12467 PyThreadState* __tstate = wxPyBeginAllowThreads();
12468 result = (int)(arg1)->GetRudderMax();
12469
12470 wxPyEndAllowThreads(__tstate);
12471 if (PyErr_Occurred()) SWIG_fail;
12472 }
12473 {
12474 resultobj = SWIG_From_int((int)(result));
12475 }
12476 return resultobj;
12477 fail:
12478 return NULL;
12479 }
12480
12481
12482 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12483 PyObject *resultobj;
12484 wxJoystick *arg1 = (wxJoystick *) 0 ;
12485 int result;
12486 PyObject * obj0 = 0 ;
12487 char *kwnames[] = {
12488 (char *) "self", NULL
12489 };
12490
12491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12493 if (SWIG_arg_fail(1)) SWIG_fail;
12494 {
12495 PyThreadState* __tstate = wxPyBeginAllowThreads();
12496 result = (int)(arg1)->GetUMin();
12497
12498 wxPyEndAllowThreads(__tstate);
12499 if (PyErr_Occurred()) SWIG_fail;
12500 }
12501 {
12502 resultobj = SWIG_From_int((int)(result));
12503 }
12504 return resultobj;
12505 fail:
12506 return NULL;
12507 }
12508
12509
12510 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12511 PyObject *resultobj;
12512 wxJoystick *arg1 = (wxJoystick *) 0 ;
12513 int result;
12514 PyObject * obj0 = 0 ;
12515 char *kwnames[] = {
12516 (char *) "self", NULL
12517 };
12518
12519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12521 if (SWIG_arg_fail(1)) SWIG_fail;
12522 {
12523 PyThreadState* __tstate = wxPyBeginAllowThreads();
12524 result = (int)(arg1)->GetUMax();
12525
12526 wxPyEndAllowThreads(__tstate);
12527 if (PyErr_Occurred()) SWIG_fail;
12528 }
12529 {
12530 resultobj = SWIG_From_int((int)(result));
12531 }
12532 return resultobj;
12533 fail:
12534 return NULL;
12535 }
12536
12537
12538 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12539 PyObject *resultobj;
12540 wxJoystick *arg1 = (wxJoystick *) 0 ;
12541 int result;
12542 PyObject * obj0 = 0 ;
12543 char *kwnames[] = {
12544 (char *) "self", NULL
12545 };
12546
12547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12549 if (SWIG_arg_fail(1)) SWIG_fail;
12550 {
12551 PyThreadState* __tstate = wxPyBeginAllowThreads();
12552 result = (int)(arg1)->GetVMin();
12553
12554 wxPyEndAllowThreads(__tstate);
12555 if (PyErr_Occurred()) SWIG_fail;
12556 }
12557 {
12558 resultobj = SWIG_From_int((int)(result));
12559 }
12560 return resultobj;
12561 fail:
12562 return NULL;
12563 }
12564
12565
12566 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12567 PyObject *resultobj;
12568 wxJoystick *arg1 = (wxJoystick *) 0 ;
12569 int result;
12570 PyObject * obj0 = 0 ;
12571 char *kwnames[] = {
12572 (char *) "self", NULL
12573 };
12574
12575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12577 if (SWIG_arg_fail(1)) SWIG_fail;
12578 {
12579 PyThreadState* __tstate = wxPyBeginAllowThreads();
12580 result = (int)(arg1)->GetVMax();
12581
12582 wxPyEndAllowThreads(__tstate);
12583 if (PyErr_Occurred()) SWIG_fail;
12584 }
12585 {
12586 resultobj = SWIG_From_int((int)(result));
12587 }
12588 return resultobj;
12589 fail:
12590 return NULL;
12591 }
12592
12593
12594 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12595 PyObject *resultobj;
12596 wxJoystick *arg1 = (wxJoystick *) 0 ;
12597 bool result;
12598 PyObject * obj0 = 0 ;
12599 char *kwnames[] = {
12600 (char *) "self", NULL
12601 };
12602
12603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12605 if (SWIG_arg_fail(1)) SWIG_fail;
12606 {
12607 PyThreadState* __tstate = wxPyBeginAllowThreads();
12608 result = (bool)(arg1)->HasRudder();
12609
12610 wxPyEndAllowThreads(__tstate);
12611 if (PyErr_Occurred()) SWIG_fail;
12612 }
12613 {
12614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12615 }
12616 return resultobj;
12617 fail:
12618 return NULL;
12619 }
12620
12621
12622 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12623 PyObject *resultobj;
12624 wxJoystick *arg1 = (wxJoystick *) 0 ;
12625 bool result;
12626 PyObject * obj0 = 0 ;
12627 char *kwnames[] = {
12628 (char *) "self", NULL
12629 };
12630
12631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12633 if (SWIG_arg_fail(1)) SWIG_fail;
12634 {
12635 PyThreadState* __tstate = wxPyBeginAllowThreads();
12636 result = (bool)(arg1)->HasZ();
12637
12638 wxPyEndAllowThreads(__tstate);
12639 if (PyErr_Occurred()) SWIG_fail;
12640 }
12641 {
12642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12643 }
12644 return resultobj;
12645 fail:
12646 return NULL;
12647 }
12648
12649
12650 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12651 PyObject *resultobj;
12652 wxJoystick *arg1 = (wxJoystick *) 0 ;
12653 bool result;
12654 PyObject * obj0 = 0 ;
12655 char *kwnames[] = {
12656 (char *) "self", NULL
12657 };
12658
12659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12661 if (SWIG_arg_fail(1)) SWIG_fail;
12662 {
12663 PyThreadState* __tstate = wxPyBeginAllowThreads();
12664 result = (bool)(arg1)->HasU();
12665
12666 wxPyEndAllowThreads(__tstate);
12667 if (PyErr_Occurred()) SWIG_fail;
12668 }
12669 {
12670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12671 }
12672 return resultobj;
12673 fail:
12674 return NULL;
12675 }
12676
12677
12678 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12679 PyObject *resultobj;
12680 wxJoystick *arg1 = (wxJoystick *) 0 ;
12681 bool result;
12682 PyObject * obj0 = 0 ;
12683 char *kwnames[] = {
12684 (char *) "self", NULL
12685 };
12686
12687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12689 if (SWIG_arg_fail(1)) SWIG_fail;
12690 {
12691 PyThreadState* __tstate = wxPyBeginAllowThreads();
12692 result = (bool)(arg1)->HasV();
12693
12694 wxPyEndAllowThreads(__tstate);
12695 if (PyErr_Occurred()) SWIG_fail;
12696 }
12697 {
12698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12699 }
12700 return resultobj;
12701 fail:
12702 return NULL;
12703 }
12704
12705
12706 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12707 PyObject *resultobj;
12708 wxJoystick *arg1 = (wxJoystick *) 0 ;
12709 bool result;
12710 PyObject * obj0 = 0 ;
12711 char *kwnames[] = {
12712 (char *) "self", NULL
12713 };
12714
12715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12717 if (SWIG_arg_fail(1)) SWIG_fail;
12718 {
12719 PyThreadState* __tstate = wxPyBeginAllowThreads();
12720 result = (bool)(arg1)->HasPOV();
12721
12722 wxPyEndAllowThreads(__tstate);
12723 if (PyErr_Occurred()) SWIG_fail;
12724 }
12725 {
12726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12727 }
12728 return resultobj;
12729 fail:
12730 return NULL;
12731 }
12732
12733
12734 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12735 PyObject *resultobj;
12736 wxJoystick *arg1 = (wxJoystick *) 0 ;
12737 bool result;
12738 PyObject * obj0 = 0 ;
12739 char *kwnames[] = {
12740 (char *) "self", NULL
12741 };
12742
12743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12745 if (SWIG_arg_fail(1)) SWIG_fail;
12746 {
12747 PyThreadState* __tstate = wxPyBeginAllowThreads();
12748 result = (bool)(arg1)->HasPOV4Dir();
12749
12750 wxPyEndAllowThreads(__tstate);
12751 if (PyErr_Occurred()) SWIG_fail;
12752 }
12753 {
12754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12755 }
12756 return resultobj;
12757 fail:
12758 return NULL;
12759 }
12760
12761
12762 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12763 PyObject *resultobj;
12764 wxJoystick *arg1 = (wxJoystick *) 0 ;
12765 bool result;
12766 PyObject * obj0 = 0 ;
12767 char *kwnames[] = {
12768 (char *) "self", NULL
12769 };
12770
12771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12773 if (SWIG_arg_fail(1)) SWIG_fail;
12774 {
12775 PyThreadState* __tstate = wxPyBeginAllowThreads();
12776 result = (bool)(arg1)->HasPOVCTS();
12777
12778 wxPyEndAllowThreads(__tstate);
12779 if (PyErr_Occurred()) SWIG_fail;
12780 }
12781 {
12782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12783 }
12784 return resultobj;
12785 fail:
12786 return NULL;
12787 }
12788
12789
12790 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12791 PyObject *resultobj;
12792 wxJoystick *arg1 = (wxJoystick *) 0 ;
12793 wxWindow *arg2 = (wxWindow *) 0 ;
12794 int arg3 = (int) 0 ;
12795 bool result;
12796 PyObject * obj0 = 0 ;
12797 PyObject * obj1 = 0 ;
12798 PyObject * obj2 = 0 ;
12799 char *kwnames[] = {
12800 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12801 };
12802
12803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12805 if (SWIG_arg_fail(1)) SWIG_fail;
12806 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12807 if (SWIG_arg_fail(2)) SWIG_fail;
12808 if (obj2) {
12809 {
12810 arg3 = (int)(SWIG_As_int(obj2));
12811 if (SWIG_arg_fail(3)) SWIG_fail;
12812 }
12813 }
12814 {
12815 PyThreadState* __tstate = wxPyBeginAllowThreads();
12816 result = (bool)(arg1)->SetCapture(arg2,arg3);
12817
12818 wxPyEndAllowThreads(__tstate);
12819 if (PyErr_Occurred()) SWIG_fail;
12820 }
12821 {
12822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12823 }
12824 return resultobj;
12825 fail:
12826 return NULL;
12827 }
12828
12829
12830 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12831 PyObject *resultobj;
12832 wxJoystick *arg1 = (wxJoystick *) 0 ;
12833 bool result;
12834 PyObject * obj0 = 0 ;
12835 char *kwnames[] = {
12836 (char *) "self", NULL
12837 };
12838
12839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12841 if (SWIG_arg_fail(1)) SWIG_fail;
12842 {
12843 PyThreadState* __tstate = wxPyBeginAllowThreads();
12844 result = (bool)(arg1)->ReleaseCapture();
12845
12846 wxPyEndAllowThreads(__tstate);
12847 if (PyErr_Occurred()) SWIG_fail;
12848 }
12849 {
12850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12851 }
12852 return resultobj;
12853 fail:
12854 return NULL;
12855 }
12856
12857
12858 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12859 PyObject *obj;
12860 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12861 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12862 Py_INCREF(obj);
12863 return Py_BuildValue((char *)"");
12864 }
12865 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12866 PyObject *resultobj;
12867 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12868 int arg2 = (int) 0 ;
12869 int arg3 = (int) wxJOYSTICK1 ;
12870 int arg4 = (int) 0 ;
12871 wxJoystickEvent *result;
12872 PyObject * obj0 = 0 ;
12873 PyObject * obj1 = 0 ;
12874 PyObject * obj2 = 0 ;
12875 PyObject * obj3 = 0 ;
12876 char *kwnames[] = {
12877 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12878 };
12879
12880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12881 if (obj0) {
12882 {
12883 arg1 = (wxEventType)(SWIG_As_int(obj0));
12884 if (SWIG_arg_fail(1)) SWIG_fail;
12885 }
12886 }
12887 if (obj1) {
12888 {
12889 arg2 = (int)(SWIG_As_int(obj1));
12890 if (SWIG_arg_fail(2)) SWIG_fail;
12891 }
12892 }
12893 if (obj2) {
12894 {
12895 arg3 = (int)(SWIG_As_int(obj2));
12896 if (SWIG_arg_fail(3)) SWIG_fail;
12897 }
12898 }
12899 if (obj3) {
12900 {
12901 arg4 = (int)(SWIG_As_int(obj3));
12902 if (SWIG_arg_fail(4)) SWIG_fail;
12903 }
12904 }
12905 {
12906 PyThreadState* __tstate = wxPyBeginAllowThreads();
12907 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12908
12909 wxPyEndAllowThreads(__tstate);
12910 if (PyErr_Occurred()) SWIG_fail;
12911 }
12912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12913 return resultobj;
12914 fail:
12915 return NULL;
12916 }
12917
12918
12919 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12920 PyObject *resultobj;
12921 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12922 wxPoint result;
12923 PyObject * obj0 = 0 ;
12924 char *kwnames[] = {
12925 (char *) "self", NULL
12926 };
12927
12928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12930 if (SWIG_arg_fail(1)) SWIG_fail;
12931 {
12932 PyThreadState* __tstate = wxPyBeginAllowThreads();
12933 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12934
12935 wxPyEndAllowThreads(__tstate);
12936 if (PyErr_Occurred()) SWIG_fail;
12937 }
12938 {
12939 wxPoint * resultptr;
12940 resultptr = new wxPoint((wxPoint &)(result));
12941 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12942 }
12943 return resultobj;
12944 fail:
12945 return NULL;
12946 }
12947
12948
12949 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12950 PyObject *resultobj;
12951 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12952 int result;
12953 PyObject * obj0 = 0 ;
12954 char *kwnames[] = {
12955 (char *) "self", NULL
12956 };
12957
12958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12960 if (SWIG_arg_fail(1)) SWIG_fail;
12961 {
12962 PyThreadState* __tstate = wxPyBeginAllowThreads();
12963 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12964
12965 wxPyEndAllowThreads(__tstate);
12966 if (PyErr_Occurred()) SWIG_fail;
12967 }
12968 {
12969 resultobj = SWIG_From_int((int)(result));
12970 }
12971 return resultobj;
12972 fail:
12973 return NULL;
12974 }
12975
12976
12977 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12978 PyObject *resultobj;
12979 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12980 int result;
12981 PyObject * obj0 = 0 ;
12982 char *kwnames[] = {
12983 (char *) "self", NULL
12984 };
12985
12986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12988 if (SWIG_arg_fail(1)) SWIG_fail;
12989 {
12990 PyThreadState* __tstate = wxPyBeginAllowThreads();
12991 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12992
12993 wxPyEndAllowThreads(__tstate);
12994 if (PyErr_Occurred()) SWIG_fail;
12995 }
12996 {
12997 resultobj = SWIG_From_int((int)(result));
12998 }
12999 return resultobj;
13000 fail:
13001 return NULL;
13002 }
13003
13004
13005 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13006 PyObject *resultobj;
13007 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13008 int result;
13009 PyObject * obj0 = 0 ;
13010 char *kwnames[] = {
13011 (char *) "self", NULL
13012 };
13013
13014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13016 if (SWIG_arg_fail(1)) SWIG_fail;
13017 {
13018 PyThreadState* __tstate = wxPyBeginAllowThreads();
13019 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13020
13021 wxPyEndAllowThreads(__tstate);
13022 if (PyErr_Occurred()) SWIG_fail;
13023 }
13024 {
13025 resultobj = SWIG_From_int((int)(result));
13026 }
13027 return resultobj;
13028 fail:
13029 return NULL;
13030 }
13031
13032
13033 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13034 PyObject *resultobj;
13035 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13036 int result;
13037 PyObject * obj0 = 0 ;
13038 char *kwnames[] = {
13039 (char *) "self", NULL
13040 };
13041
13042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13044 if (SWIG_arg_fail(1)) SWIG_fail;
13045 {
13046 PyThreadState* __tstate = wxPyBeginAllowThreads();
13047 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13048
13049 wxPyEndAllowThreads(__tstate);
13050 if (PyErr_Occurred()) SWIG_fail;
13051 }
13052 {
13053 resultobj = SWIG_From_int((int)(result));
13054 }
13055 return resultobj;
13056 fail:
13057 return NULL;
13058 }
13059
13060
13061 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13062 PyObject *resultobj;
13063 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13064 int arg2 ;
13065 PyObject * obj0 = 0 ;
13066 PyObject * obj1 = 0 ;
13067 char *kwnames[] = {
13068 (char *) "self",(char *) "stick", NULL
13069 };
13070
13071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13073 if (SWIG_arg_fail(1)) SWIG_fail;
13074 {
13075 arg2 = (int)(SWIG_As_int(obj1));
13076 if (SWIG_arg_fail(2)) SWIG_fail;
13077 }
13078 {
13079 PyThreadState* __tstate = wxPyBeginAllowThreads();
13080 (arg1)->SetJoystick(arg2);
13081
13082 wxPyEndAllowThreads(__tstate);
13083 if (PyErr_Occurred()) SWIG_fail;
13084 }
13085 Py_INCREF(Py_None); resultobj = Py_None;
13086 return resultobj;
13087 fail:
13088 return NULL;
13089 }
13090
13091
13092 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13093 PyObject *resultobj;
13094 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13095 int arg2 ;
13096 PyObject * obj0 = 0 ;
13097 PyObject * obj1 = 0 ;
13098 char *kwnames[] = {
13099 (char *) "self",(char *) "state", NULL
13100 };
13101
13102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13104 if (SWIG_arg_fail(1)) SWIG_fail;
13105 {
13106 arg2 = (int)(SWIG_As_int(obj1));
13107 if (SWIG_arg_fail(2)) SWIG_fail;
13108 }
13109 {
13110 PyThreadState* __tstate = wxPyBeginAllowThreads();
13111 (arg1)->SetButtonState(arg2);
13112
13113 wxPyEndAllowThreads(__tstate);
13114 if (PyErr_Occurred()) SWIG_fail;
13115 }
13116 Py_INCREF(Py_None); resultobj = Py_None;
13117 return resultobj;
13118 fail:
13119 return NULL;
13120 }
13121
13122
13123 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13124 PyObject *resultobj;
13125 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13126 int arg2 ;
13127 PyObject * obj0 = 0 ;
13128 PyObject * obj1 = 0 ;
13129 char *kwnames[] = {
13130 (char *) "self",(char *) "change", NULL
13131 };
13132
13133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13135 if (SWIG_arg_fail(1)) SWIG_fail;
13136 {
13137 arg2 = (int)(SWIG_As_int(obj1));
13138 if (SWIG_arg_fail(2)) SWIG_fail;
13139 }
13140 {
13141 PyThreadState* __tstate = wxPyBeginAllowThreads();
13142 (arg1)->SetButtonChange(arg2);
13143
13144 wxPyEndAllowThreads(__tstate);
13145 if (PyErr_Occurred()) SWIG_fail;
13146 }
13147 Py_INCREF(Py_None); resultobj = Py_None;
13148 return resultobj;
13149 fail:
13150 return NULL;
13151 }
13152
13153
13154 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13155 PyObject *resultobj;
13156 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13157 wxPoint *arg2 = 0 ;
13158 wxPoint temp2 ;
13159 PyObject * obj0 = 0 ;
13160 PyObject * obj1 = 0 ;
13161 char *kwnames[] = {
13162 (char *) "self",(char *) "pos", NULL
13163 };
13164
13165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13167 if (SWIG_arg_fail(1)) SWIG_fail;
13168 {
13169 arg2 = &temp2;
13170 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13171 }
13172 {
13173 PyThreadState* __tstate = wxPyBeginAllowThreads();
13174 (arg1)->SetPosition((wxPoint const &)*arg2);
13175
13176 wxPyEndAllowThreads(__tstate);
13177 if (PyErr_Occurred()) SWIG_fail;
13178 }
13179 Py_INCREF(Py_None); resultobj = Py_None;
13180 return resultobj;
13181 fail:
13182 return NULL;
13183 }
13184
13185
13186 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13187 PyObject *resultobj;
13188 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13189 int arg2 ;
13190 PyObject * obj0 = 0 ;
13191 PyObject * obj1 = 0 ;
13192 char *kwnames[] = {
13193 (char *) "self",(char *) "zPos", NULL
13194 };
13195
13196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13198 if (SWIG_arg_fail(1)) SWIG_fail;
13199 {
13200 arg2 = (int)(SWIG_As_int(obj1));
13201 if (SWIG_arg_fail(2)) SWIG_fail;
13202 }
13203 {
13204 PyThreadState* __tstate = wxPyBeginAllowThreads();
13205 (arg1)->SetZPosition(arg2);
13206
13207 wxPyEndAllowThreads(__tstate);
13208 if (PyErr_Occurred()) SWIG_fail;
13209 }
13210 Py_INCREF(Py_None); resultobj = Py_None;
13211 return resultobj;
13212 fail:
13213 return NULL;
13214 }
13215
13216
13217 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13218 PyObject *resultobj;
13219 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13220 bool result;
13221 PyObject * obj0 = 0 ;
13222 char *kwnames[] = {
13223 (char *) "self", NULL
13224 };
13225
13226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13228 if (SWIG_arg_fail(1)) SWIG_fail;
13229 {
13230 PyThreadState* __tstate = wxPyBeginAllowThreads();
13231 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13232
13233 wxPyEndAllowThreads(__tstate);
13234 if (PyErr_Occurred()) SWIG_fail;
13235 }
13236 {
13237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13238 }
13239 return resultobj;
13240 fail:
13241 return NULL;
13242 }
13243
13244
13245 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13246 PyObject *resultobj;
13247 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13248 bool result;
13249 PyObject * obj0 = 0 ;
13250 char *kwnames[] = {
13251 (char *) "self", NULL
13252 };
13253
13254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13256 if (SWIG_arg_fail(1)) SWIG_fail;
13257 {
13258 PyThreadState* __tstate = wxPyBeginAllowThreads();
13259 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13260
13261 wxPyEndAllowThreads(__tstate);
13262 if (PyErr_Occurred()) SWIG_fail;
13263 }
13264 {
13265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13266 }
13267 return resultobj;
13268 fail:
13269 return NULL;
13270 }
13271
13272
13273 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13274 PyObject *resultobj;
13275 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13276 bool result;
13277 PyObject * obj0 = 0 ;
13278 char *kwnames[] = {
13279 (char *) "self", NULL
13280 };
13281
13282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13284 if (SWIG_arg_fail(1)) SWIG_fail;
13285 {
13286 PyThreadState* __tstate = wxPyBeginAllowThreads();
13287 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13288
13289 wxPyEndAllowThreads(__tstate);
13290 if (PyErr_Occurred()) SWIG_fail;
13291 }
13292 {
13293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13294 }
13295 return resultobj;
13296 fail:
13297 return NULL;
13298 }
13299
13300
13301 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13302 PyObject *resultobj;
13303 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13304 int arg2 = (int) wxJOY_BUTTON_ANY ;
13305 bool result;
13306 PyObject * obj0 = 0 ;
13307 PyObject * obj1 = 0 ;
13308 char *kwnames[] = {
13309 (char *) "self",(char *) "but", NULL
13310 };
13311
13312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13314 if (SWIG_arg_fail(1)) SWIG_fail;
13315 if (obj1) {
13316 {
13317 arg2 = (int)(SWIG_As_int(obj1));
13318 if (SWIG_arg_fail(2)) SWIG_fail;
13319 }
13320 }
13321 {
13322 PyThreadState* __tstate = wxPyBeginAllowThreads();
13323 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13324
13325 wxPyEndAllowThreads(__tstate);
13326 if (PyErr_Occurred()) SWIG_fail;
13327 }
13328 {
13329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13330 }
13331 return resultobj;
13332 fail:
13333 return NULL;
13334 }
13335
13336
13337 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13338 PyObject *resultobj;
13339 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13340 int arg2 = (int) wxJOY_BUTTON_ANY ;
13341 bool result;
13342 PyObject * obj0 = 0 ;
13343 PyObject * obj1 = 0 ;
13344 char *kwnames[] = {
13345 (char *) "self",(char *) "but", NULL
13346 };
13347
13348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13350 if (SWIG_arg_fail(1)) SWIG_fail;
13351 if (obj1) {
13352 {
13353 arg2 = (int)(SWIG_As_int(obj1));
13354 if (SWIG_arg_fail(2)) SWIG_fail;
13355 }
13356 }
13357 {
13358 PyThreadState* __tstate = wxPyBeginAllowThreads();
13359 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13360
13361 wxPyEndAllowThreads(__tstate);
13362 if (PyErr_Occurred()) SWIG_fail;
13363 }
13364 {
13365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13366 }
13367 return resultobj;
13368 fail:
13369 return NULL;
13370 }
13371
13372
13373 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13374 PyObject *resultobj;
13375 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13376 int arg2 = (int) wxJOY_BUTTON_ANY ;
13377 bool result;
13378 PyObject * obj0 = 0 ;
13379 PyObject * obj1 = 0 ;
13380 char *kwnames[] = {
13381 (char *) "self",(char *) "but", NULL
13382 };
13383
13384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13386 if (SWIG_arg_fail(1)) SWIG_fail;
13387 if (obj1) {
13388 {
13389 arg2 = (int)(SWIG_As_int(obj1));
13390 if (SWIG_arg_fail(2)) SWIG_fail;
13391 }
13392 }
13393 {
13394 PyThreadState* __tstate = wxPyBeginAllowThreads();
13395 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13396
13397 wxPyEndAllowThreads(__tstate);
13398 if (PyErr_Occurred()) SWIG_fail;
13399 }
13400 {
13401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13402 }
13403 return resultobj;
13404 fail:
13405 return NULL;
13406 }
13407
13408
13409 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13410 PyObject *obj;
13411 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13412 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13413 Py_INCREF(obj);
13414 return Py_BuildValue((char *)"");
13415 }
13416 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13417 PyObject *resultobj;
13418 wxString const &arg1_defvalue = wxPyEmptyString ;
13419 wxString *arg1 = (wxString *) &arg1_defvalue ;
13420 wxSound *result;
13421 bool temp1 = false ;
13422 PyObject * obj0 = 0 ;
13423 char *kwnames[] = {
13424 (char *) "fileName", NULL
13425 };
13426
13427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13428 if (obj0) {
13429 {
13430 arg1 = wxString_in_helper(obj0);
13431 if (arg1 == NULL) SWIG_fail;
13432 temp1 = true;
13433 }
13434 }
13435 {
13436 if (!wxPyCheckForApp()) SWIG_fail;
13437 PyThreadState* __tstate = wxPyBeginAllowThreads();
13438 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13439
13440 wxPyEndAllowThreads(__tstate);
13441 if (PyErr_Occurred()) SWIG_fail;
13442 }
13443 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13444 {
13445 if (temp1)
13446 delete arg1;
13447 }
13448 return resultobj;
13449 fail:
13450 {
13451 if (temp1)
13452 delete arg1;
13453 }
13454 return NULL;
13455 }
13456
13457
13458 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13459 PyObject *resultobj;
13460 PyObject *arg1 = (PyObject *) 0 ;
13461 wxSound *result;
13462 PyObject * obj0 = 0 ;
13463 char *kwnames[] = {
13464 (char *) "data", NULL
13465 };
13466
13467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13468 arg1 = obj0;
13469 {
13470 if (!wxPyCheckForApp()) SWIG_fail;
13471 PyThreadState* __tstate = wxPyBeginAllowThreads();
13472 result = (wxSound *)new_wxSound(arg1);
13473
13474 wxPyEndAllowThreads(__tstate);
13475 if (PyErr_Occurred()) SWIG_fail;
13476 }
13477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13478 return resultobj;
13479 fail:
13480 return NULL;
13481 }
13482
13483
13484 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13485 PyObject *resultobj;
13486 wxSound *arg1 = (wxSound *) 0 ;
13487 PyObject * obj0 = 0 ;
13488 char *kwnames[] = {
13489 (char *) "self", NULL
13490 };
13491
13492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13494 if (SWIG_arg_fail(1)) SWIG_fail;
13495 {
13496 PyThreadState* __tstate = wxPyBeginAllowThreads();
13497 delete arg1;
13498
13499 wxPyEndAllowThreads(__tstate);
13500 if (PyErr_Occurred()) SWIG_fail;
13501 }
13502 Py_INCREF(Py_None); resultobj = Py_None;
13503 return resultobj;
13504 fail:
13505 return NULL;
13506 }
13507
13508
13509 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13510 PyObject *resultobj;
13511 wxSound *arg1 = (wxSound *) 0 ;
13512 wxString *arg2 = 0 ;
13513 bool result;
13514 bool temp2 = false ;
13515 PyObject * obj0 = 0 ;
13516 PyObject * obj1 = 0 ;
13517 char *kwnames[] = {
13518 (char *) "self",(char *) "fileName", NULL
13519 };
13520
13521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13523 if (SWIG_arg_fail(1)) SWIG_fail;
13524 {
13525 arg2 = wxString_in_helper(obj1);
13526 if (arg2 == NULL) SWIG_fail;
13527 temp2 = true;
13528 }
13529 {
13530 PyThreadState* __tstate = wxPyBeginAllowThreads();
13531 result = (bool)(arg1)->Create((wxString const &)*arg2);
13532
13533 wxPyEndAllowThreads(__tstate);
13534 if (PyErr_Occurred()) SWIG_fail;
13535 }
13536 {
13537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13538 }
13539 {
13540 if (temp2)
13541 delete arg2;
13542 }
13543 return resultobj;
13544 fail:
13545 {
13546 if (temp2)
13547 delete arg2;
13548 }
13549 return NULL;
13550 }
13551
13552
13553 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13554 PyObject *resultobj;
13555 wxSound *arg1 = (wxSound *) 0 ;
13556 PyObject *arg2 = (PyObject *) 0 ;
13557 bool result;
13558 PyObject * obj0 = 0 ;
13559 PyObject * obj1 = 0 ;
13560 char *kwnames[] = {
13561 (char *) "self",(char *) "data", NULL
13562 };
13563
13564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13566 if (SWIG_arg_fail(1)) SWIG_fail;
13567 arg2 = obj1;
13568 {
13569 PyThreadState* __tstate = wxPyBeginAllowThreads();
13570 result = (bool)wxSound_CreateFromData(arg1,arg2);
13571
13572 wxPyEndAllowThreads(__tstate);
13573 if (PyErr_Occurred()) SWIG_fail;
13574 }
13575 {
13576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13577 }
13578 return resultobj;
13579 fail:
13580 return NULL;
13581 }
13582
13583
13584 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13585 PyObject *resultobj;
13586 wxSound *arg1 = (wxSound *) 0 ;
13587 bool result;
13588 PyObject * obj0 = 0 ;
13589 char *kwnames[] = {
13590 (char *) "self", NULL
13591 };
13592
13593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13595 if (SWIG_arg_fail(1)) SWIG_fail;
13596 {
13597 PyThreadState* __tstate = wxPyBeginAllowThreads();
13598 result = (bool)(arg1)->IsOk();
13599
13600 wxPyEndAllowThreads(__tstate);
13601 if (PyErr_Occurred()) SWIG_fail;
13602 }
13603 {
13604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13605 }
13606 return resultobj;
13607 fail:
13608 return NULL;
13609 }
13610
13611
13612 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13613 PyObject *resultobj;
13614 wxSound *arg1 = (wxSound *) 0 ;
13615 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13616 bool result;
13617 PyObject * obj0 = 0 ;
13618 PyObject * obj1 = 0 ;
13619 char *kwnames[] = {
13620 (char *) "self",(char *) "flags", NULL
13621 };
13622
13623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13625 if (SWIG_arg_fail(1)) SWIG_fail;
13626 if (obj1) {
13627 {
13628 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13629 if (SWIG_arg_fail(2)) SWIG_fail;
13630 }
13631 }
13632 {
13633 if (!wxPyCheckForApp()) SWIG_fail;
13634 PyThreadState* __tstate = wxPyBeginAllowThreads();
13635 result = (bool)((wxSound const *)arg1)->Play(arg2);
13636
13637 wxPyEndAllowThreads(__tstate);
13638 if (PyErr_Occurred()) SWIG_fail;
13639 }
13640 {
13641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13642 }
13643 return resultobj;
13644 fail:
13645 return NULL;
13646 }
13647
13648
13649 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13650 PyObject *resultobj;
13651 wxString *arg1 = 0 ;
13652 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13653 bool result;
13654 bool temp1 = false ;
13655 PyObject * obj0 = 0 ;
13656 PyObject * obj1 = 0 ;
13657 char *kwnames[] = {
13658 (char *) "filename",(char *) "flags", NULL
13659 };
13660
13661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13662 {
13663 arg1 = wxString_in_helper(obj0);
13664 if (arg1 == NULL) SWIG_fail;
13665 temp1 = true;
13666 }
13667 if (obj1) {
13668 {
13669 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13670 if (SWIG_arg_fail(2)) SWIG_fail;
13671 }
13672 }
13673 {
13674 if (!wxPyCheckForApp()) SWIG_fail;
13675 PyThreadState* __tstate = wxPyBeginAllowThreads();
13676 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13677
13678 wxPyEndAllowThreads(__tstate);
13679 if (PyErr_Occurred()) SWIG_fail;
13680 }
13681 {
13682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13683 }
13684 {
13685 if (temp1)
13686 delete arg1;
13687 }
13688 return resultobj;
13689 fail:
13690 {
13691 if (temp1)
13692 delete arg1;
13693 }
13694 return NULL;
13695 }
13696
13697
13698 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13699 PyObject *resultobj;
13700 char *kwnames[] = {
13701 NULL
13702 };
13703
13704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13705 {
13706 if (!wxPyCheckForApp()) SWIG_fail;
13707 PyThreadState* __tstate = wxPyBeginAllowThreads();
13708 wxSound::Stop();
13709
13710 wxPyEndAllowThreads(__tstate);
13711 if (PyErr_Occurred()) SWIG_fail;
13712 }
13713 Py_INCREF(Py_None); resultobj = Py_None;
13714 return resultobj;
13715 fail:
13716 return NULL;
13717 }
13718
13719
13720 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13721 PyObject *obj;
13722 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13723 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13724 Py_INCREF(obj);
13725 return Py_BuildValue((char *)"");
13726 }
13727 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13728 PyObject *resultobj;
13729 wxString *arg1 = 0 ;
13730 wxString *arg2 = 0 ;
13731 wxString *arg3 = 0 ;
13732 wxString *arg4 = 0 ;
13733 wxFileTypeInfo *result;
13734 bool temp1 = false ;
13735 bool temp2 = false ;
13736 bool temp3 = false ;
13737 bool temp4 = false ;
13738 PyObject * obj0 = 0 ;
13739 PyObject * obj1 = 0 ;
13740 PyObject * obj2 = 0 ;
13741 PyObject * obj3 = 0 ;
13742 char *kwnames[] = {
13743 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13744 };
13745
13746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13747 {
13748 arg1 = wxString_in_helper(obj0);
13749 if (arg1 == NULL) SWIG_fail;
13750 temp1 = true;
13751 }
13752 {
13753 arg2 = wxString_in_helper(obj1);
13754 if (arg2 == NULL) SWIG_fail;
13755 temp2 = true;
13756 }
13757 {
13758 arg3 = wxString_in_helper(obj2);
13759 if (arg3 == NULL) SWIG_fail;
13760 temp3 = true;
13761 }
13762 {
13763 arg4 = wxString_in_helper(obj3);
13764 if (arg4 == NULL) SWIG_fail;
13765 temp4 = true;
13766 }
13767 {
13768 PyThreadState* __tstate = wxPyBeginAllowThreads();
13769 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13770
13771 wxPyEndAllowThreads(__tstate);
13772 if (PyErr_Occurred()) SWIG_fail;
13773 }
13774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13775 {
13776 if (temp1)
13777 delete arg1;
13778 }
13779 {
13780 if (temp2)
13781 delete arg2;
13782 }
13783 {
13784 if (temp3)
13785 delete arg3;
13786 }
13787 {
13788 if (temp4)
13789 delete arg4;
13790 }
13791 return resultobj;
13792 fail:
13793 {
13794 if (temp1)
13795 delete arg1;
13796 }
13797 {
13798 if (temp2)
13799 delete arg2;
13800 }
13801 {
13802 if (temp3)
13803 delete arg3;
13804 }
13805 {
13806 if (temp4)
13807 delete arg4;
13808 }
13809 return NULL;
13810 }
13811
13812
13813 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13814 PyObject *resultobj;
13815 wxArrayString *arg1 = 0 ;
13816 wxFileTypeInfo *result;
13817 bool temp1 = false ;
13818 PyObject * obj0 = 0 ;
13819 char *kwnames[] = {
13820 (char *) "sArray", NULL
13821 };
13822
13823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13824 {
13825 if (! PySequence_Check(obj0)) {
13826 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13827 SWIG_fail;
13828 }
13829 arg1 = new wxArrayString;
13830 temp1 = true;
13831 int i, len=PySequence_Length(obj0);
13832 for (i=0; i<len; i++) {
13833 PyObject* item = PySequence_GetItem(obj0, i);
13834 wxString* s = wxString_in_helper(item);
13835 if (PyErr_Occurred()) SWIG_fail;
13836 arg1->Add(*s);
13837 delete s;
13838 Py_DECREF(item);
13839 }
13840 }
13841 {
13842 PyThreadState* __tstate = wxPyBeginAllowThreads();
13843 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13844
13845 wxPyEndAllowThreads(__tstate);
13846 if (PyErr_Occurred()) SWIG_fail;
13847 }
13848 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13849 {
13850 if (temp1) delete arg1;
13851 }
13852 return resultobj;
13853 fail:
13854 {
13855 if (temp1) delete arg1;
13856 }
13857 return NULL;
13858 }
13859
13860
13861 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13862 PyObject *resultobj;
13863 wxFileTypeInfo *result;
13864 char *kwnames[] = {
13865 NULL
13866 };
13867
13868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13869 {
13870 PyThreadState* __tstate = wxPyBeginAllowThreads();
13871 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13872
13873 wxPyEndAllowThreads(__tstate);
13874 if (PyErr_Occurred()) SWIG_fail;
13875 }
13876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13877 return resultobj;
13878 fail:
13879 return NULL;
13880 }
13881
13882
13883 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13884 PyObject *resultobj;
13885 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13886 bool result;
13887 PyObject * obj0 = 0 ;
13888 char *kwnames[] = {
13889 (char *) "self", NULL
13890 };
13891
13892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13894 if (SWIG_arg_fail(1)) SWIG_fail;
13895 {
13896 PyThreadState* __tstate = wxPyBeginAllowThreads();
13897 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13898
13899 wxPyEndAllowThreads(__tstate);
13900 if (PyErr_Occurred()) SWIG_fail;
13901 }
13902 {
13903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13904 }
13905 return resultobj;
13906 fail:
13907 return NULL;
13908 }
13909
13910
13911 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13912 PyObject *resultobj;
13913 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13914 wxString *arg2 = 0 ;
13915 int arg3 = (int) 0 ;
13916 bool temp2 = false ;
13917 PyObject * obj0 = 0 ;
13918 PyObject * obj1 = 0 ;
13919 PyObject * obj2 = 0 ;
13920 char *kwnames[] = {
13921 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13922 };
13923
13924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13926 if (SWIG_arg_fail(1)) SWIG_fail;
13927 {
13928 arg2 = wxString_in_helper(obj1);
13929 if (arg2 == NULL) SWIG_fail;
13930 temp2 = true;
13931 }
13932 if (obj2) {
13933 {
13934 arg3 = (int)(SWIG_As_int(obj2));
13935 if (SWIG_arg_fail(3)) SWIG_fail;
13936 }
13937 }
13938 {
13939 PyThreadState* __tstate = wxPyBeginAllowThreads();
13940 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13941
13942 wxPyEndAllowThreads(__tstate);
13943 if (PyErr_Occurred()) SWIG_fail;
13944 }
13945 Py_INCREF(Py_None); resultobj = Py_None;
13946 {
13947 if (temp2)
13948 delete arg2;
13949 }
13950 return resultobj;
13951 fail:
13952 {
13953 if (temp2)
13954 delete arg2;
13955 }
13956 return NULL;
13957 }
13958
13959
13960 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13961 PyObject *resultobj;
13962 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13963 wxString *arg2 = 0 ;
13964 bool temp2 = false ;
13965 PyObject * obj0 = 0 ;
13966 PyObject * obj1 = 0 ;
13967 char *kwnames[] = {
13968 (char *) "self",(char *) "shortDesc", NULL
13969 };
13970
13971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13973 if (SWIG_arg_fail(1)) SWIG_fail;
13974 {
13975 arg2 = wxString_in_helper(obj1);
13976 if (arg2 == NULL) SWIG_fail;
13977 temp2 = true;
13978 }
13979 {
13980 PyThreadState* __tstate = wxPyBeginAllowThreads();
13981 (arg1)->SetShortDesc((wxString const &)*arg2);
13982
13983 wxPyEndAllowThreads(__tstate);
13984 if (PyErr_Occurred()) SWIG_fail;
13985 }
13986 Py_INCREF(Py_None); resultobj = Py_None;
13987 {
13988 if (temp2)
13989 delete arg2;
13990 }
13991 return resultobj;
13992 fail:
13993 {
13994 if (temp2)
13995 delete arg2;
13996 }
13997 return NULL;
13998 }
13999
14000
14001 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14002 PyObject *resultobj;
14003 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14004 wxString *result;
14005 PyObject * obj0 = 0 ;
14006 char *kwnames[] = {
14007 (char *) "self", NULL
14008 };
14009
14010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14012 if (SWIG_arg_fail(1)) SWIG_fail;
14013 {
14014 PyThreadState* __tstate = wxPyBeginAllowThreads();
14015 {
14016 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14017 result = (wxString *) &_result_ref;
14018 }
14019
14020 wxPyEndAllowThreads(__tstate);
14021 if (PyErr_Occurred()) SWIG_fail;
14022 }
14023 {
14024 #if wxUSE_UNICODE
14025 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14026 #else
14027 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14028 #endif
14029 }
14030 return resultobj;
14031 fail:
14032 return NULL;
14033 }
14034
14035
14036 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14037 PyObject *resultobj;
14038 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14039 wxString *result;
14040 PyObject * obj0 = 0 ;
14041 char *kwnames[] = {
14042 (char *) "self", NULL
14043 };
14044
14045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14047 if (SWIG_arg_fail(1)) SWIG_fail;
14048 {
14049 PyThreadState* __tstate = wxPyBeginAllowThreads();
14050 {
14051 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14052 result = (wxString *) &_result_ref;
14053 }
14054
14055 wxPyEndAllowThreads(__tstate);
14056 if (PyErr_Occurred()) SWIG_fail;
14057 }
14058 {
14059 #if wxUSE_UNICODE
14060 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14061 #else
14062 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14063 #endif
14064 }
14065 return resultobj;
14066 fail:
14067 return NULL;
14068 }
14069
14070
14071 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14072 PyObject *resultobj;
14073 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14074 wxString *result;
14075 PyObject * obj0 = 0 ;
14076 char *kwnames[] = {
14077 (char *) "self", NULL
14078 };
14079
14080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14082 if (SWIG_arg_fail(1)) SWIG_fail;
14083 {
14084 PyThreadState* __tstate = wxPyBeginAllowThreads();
14085 {
14086 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14087 result = (wxString *) &_result_ref;
14088 }
14089
14090 wxPyEndAllowThreads(__tstate);
14091 if (PyErr_Occurred()) SWIG_fail;
14092 }
14093 {
14094 #if wxUSE_UNICODE
14095 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14096 #else
14097 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14098 #endif
14099 }
14100 return resultobj;
14101 fail:
14102 return NULL;
14103 }
14104
14105
14106 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14107 PyObject *resultobj;
14108 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14109 wxString *result;
14110 PyObject * obj0 = 0 ;
14111 char *kwnames[] = {
14112 (char *) "self", NULL
14113 };
14114
14115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14117 if (SWIG_arg_fail(1)) SWIG_fail;
14118 {
14119 PyThreadState* __tstate = wxPyBeginAllowThreads();
14120 {
14121 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14122 result = (wxString *) &_result_ref;
14123 }
14124
14125 wxPyEndAllowThreads(__tstate);
14126 if (PyErr_Occurred()) SWIG_fail;
14127 }
14128 {
14129 #if wxUSE_UNICODE
14130 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14131 #else
14132 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14133 #endif
14134 }
14135 return resultobj;
14136 fail:
14137 return NULL;
14138 }
14139
14140
14141 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14142 PyObject *resultobj;
14143 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14144 wxString *result;
14145 PyObject * obj0 = 0 ;
14146 char *kwnames[] = {
14147 (char *) "self", NULL
14148 };
14149
14150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14152 if (SWIG_arg_fail(1)) SWIG_fail;
14153 {
14154 PyThreadState* __tstate = wxPyBeginAllowThreads();
14155 {
14156 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14157 result = (wxString *) &_result_ref;
14158 }
14159
14160 wxPyEndAllowThreads(__tstate);
14161 if (PyErr_Occurred()) SWIG_fail;
14162 }
14163 {
14164 #if wxUSE_UNICODE
14165 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14166 #else
14167 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14168 #endif
14169 }
14170 return resultobj;
14171 fail:
14172 return NULL;
14173 }
14174
14175
14176 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14177 PyObject *resultobj;
14178 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14179 wxArrayString *result;
14180 PyObject * obj0 = 0 ;
14181 char *kwnames[] = {
14182 (char *) "self", NULL
14183 };
14184
14185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14187 if (SWIG_arg_fail(1)) SWIG_fail;
14188 {
14189 PyThreadState* __tstate = wxPyBeginAllowThreads();
14190 {
14191 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14192 result = (wxArrayString *) &_result_ref;
14193 }
14194
14195 wxPyEndAllowThreads(__tstate);
14196 if (PyErr_Occurred()) SWIG_fail;
14197 }
14198 {
14199 resultobj = wxArrayString2PyList_helper(*result);
14200 }
14201 return resultobj;
14202 fail:
14203 return NULL;
14204 }
14205
14206
14207 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14208 PyObject *resultobj;
14209 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14210 int result;
14211 PyObject * obj0 = 0 ;
14212 char *kwnames[] = {
14213 (char *) "self", NULL
14214 };
14215
14216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14218 if (SWIG_arg_fail(1)) SWIG_fail;
14219 {
14220 PyThreadState* __tstate = wxPyBeginAllowThreads();
14221 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14222
14223 wxPyEndAllowThreads(__tstate);
14224 if (PyErr_Occurred()) SWIG_fail;
14225 }
14226 {
14227 resultobj = SWIG_From_int((int)(result));
14228 }
14229 return resultobj;
14230 fail:
14231 return NULL;
14232 }
14233
14234
14235 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14236 PyObject *resultobj;
14237 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14238 wxString *result;
14239 PyObject * obj0 = 0 ;
14240 char *kwnames[] = {
14241 (char *) "self", NULL
14242 };
14243
14244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14246 if (SWIG_arg_fail(1)) SWIG_fail;
14247 {
14248 PyThreadState* __tstate = wxPyBeginAllowThreads();
14249 {
14250 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14251 result = (wxString *) &_result_ref;
14252 }
14253
14254 wxPyEndAllowThreads(__tstate);
14255 if (PyErr_Occurred()) SWIG_fail;
14256 }
14257 {
14258 #if wxUSE_UNICODE
14259 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14260 #else
14261 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14262 #endif
14263 }
14264 return resultobj;
14265 fail:
14266 return NULL;
14267 }
14268
14269
14270 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14271 PyObject *resultobj;
14272 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14273 int result;
14274 PyObject * obj0 = 0 ;
14275 char *kwnames[] = {
14276 (char *) "self", NULL
14277 };
14278
14279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14281 if (SWIG_arg_fail(1)) SWIG_fail;
14282 {
14283 PyThreadState* __tstate = wxPyBeginAllowThreads();
14284 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14285
14286 wxPyEndAllowThreads(__tstate);
14287 if (PyErr_Occurred()) SWIG_fail;
14288 }
14289 {
14290 resultobj = SWIG_From_int((int)(result));
14291 }
14292 return resultobj;
14293 fail:
14294 return NULL;
14295 }
14296
14297
14298 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14299 PyObject *obj;
14300 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14301 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14302 Py_INCREF(obj);
14303 return Py_BuildValue((char *)"");
14304 }
14305 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14306 PyObject *resultobj;
14307 wxFileTypeInfo *arg1 = 0 ;
14308 wxFileType *result;
14309 PyObject * obj0 = 0 ;
14310 char *kwnames[] = {
14311 (char *) "ftInfo", NULL
14312 };
14313
14314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14315 {
14316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14317 if (SWIG_arg_fail(1)) SWIG_fail;
14318 if (arg1 == NULL) {
14319 SWIG_null_ref("wxFileTypeInfo");
14320 }
14321 if (SWIG_arg_fail(1)) SWIG_fail;
14322 }
14323 {
14324 PyThreadState* __tstate = wxPyBeginAllowThreads();
14325 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14326
14327 wxPyEndAllowThreads(__tstate);
14328 if (PyErr_Occurred()) SWIG_fail;
14329 }
14330 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14331 return resultobj;
14332 fail:
14333 return NULL;
14334 }
14335
14336
14337 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14338 PyObject *resultobj;
14339 wxFileType *arg1 = (wxFileType *) 0 ;
14340 PyObject * obj0 = 0 ;
14341 char *kwnames[] = {
14342 (char *) "self", NULL
14343 };
14344
14345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14347 if (SWIG_arg_fail(1)) SWIG_fail;
14348 {
14349 PyThreadState* __tstate = wxPyBeginAllowThreads();
14350 delete arg1;
14351
14352 wxPyEndAllowThreads(__tstate);
14353 if (PyErr_Occurred()) SWIG_fail;
14354 }
14355 Py_INCREF(Py_None); resultobj = Py_None;
14356 return resultobj;
14357 fail:
14358 return NULL;
14359 }
14360
14361
14362 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14363 PyObject *resultobj;
14364 wxFileType *arg1 = (wxFileType *) 0 ;
14365 PyObject *result;
14366 PyObject * obj0 = 0 ;
14367 char *kwnames[] = {
14368 (char *) "self", NULL
14369 };
14370
14371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14373 if (SWIG_arg_fail(1)) SWIG_fail;
14374 {
14375 PyThreadState* __tstate = wxPyBeginAllowThreads();
14376 result = (PyObject *)wxFileType_GetMimeType(arg1);
14377
14378 wxPyEndAllowThreads(__tstate);
14379 if (PyErr_Occurred()) SWIG_fail;
14380 }
14381 resultobj = result;
14382 return resultobj;
14383 fail:
14384 return NULL;
14385 }
14386
14387
14388 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14389 PyObject *resultobj;
14390 wxFileType *arg1 = (wxFileType *) 0 ;
14391 PyObject *result;
14392 PyObject * obj0 = 0 ;
14393 char *kwnames[] = {
14394 (char *) "self", NULL
14395 };
14396
14397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14399 if (SWIG_arg_fail(1)) SWIG_fail;
14400 {
14401 PyThreadState* __tstate = wxPyBeginAllowThreads();
14402 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14403
14404 wxPyEndAllowThreads(__tstate);
14405 if (PyErr_Occurred()) SWIG_fail;
14406 }
14407 resultobj = result;
14408 return resultobj;
14409 fail:
14410 return NULL;
14411 }
14412
14413
14414 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14415 PyObject *resultobj;
14416 wxFileType *arg1 = (wxFileType *) 0 ;
14417 PyObject *result;
14418 PyObject * obj0 = 0 ;
14419 char *kwnames[] = {
14420 (char *) "self", NULL
14421 };
14422
14423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14425 if (SWIG_arg_fail(1)) SWIG_fail;
14426 {
14427 PyThreadState* __tstate = wxPyBeginAllowThreads();
14428 result = (PyObject *)wxFileType_GetExtensions(arg1);
14429
14430 wxPyEndAllowThreads(__tstate);
14431 if (PyErr_Occurred()) SWIG_fail;
14432 }
14433 resultobj = result;
14434 return resultobj;
14435 fail:
14436 return NULL;
14437 }
14438
14439
14440 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14441 PyObject *resultobj;
14442 wxFileType *arg1 = (wxFileType *) 0 ;
14443 wxIcon *result;
14444 PyObject * obj0 = 0 ;
14445 char *kwnames[] = {
14446 (char *) "self", NULL
14447 };
14448
14449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14451 if (SWIG_arg_fail(1)) SWIG_fail;
14452 {
14453 PyThreadState* __tstate = wxPyBeginAllowThreads();
14454 result = (wxIcon *)wxFileType_GetIcon(arg1);
14455
14456 wxPyEndAllowThreads(__tstate);
14457 if (PyErr_Occurred()) SWIG_fail;
14458 }
14459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14460 return resultobj;
14461 fail:
14462 return NULL;
14463 }
14464
14465
14466 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14467 PyObject *resultobj;
14468 wxFileType *arg1 = (wxFileType *) 0 ;
14469 PyObject *result;
14470 PyObject * obj0 = 0 ;
14471 char *kwnames[] = {
14472 (char *) "self", NULL
14473 };
14474
14475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14477 if (SWIG_arg_fail(1)) SWIG_fail;
14478 {
14479 PyThreadState* __tstate = wxPyBeginAllowThreads();
14480 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14481
14482 wxPyEndAllowThreads(__tstate);
14483 if (PyErr_Occurred()) SWIG_fail;
14484 }
14485 resultobj = result;
14486 return resultobj;
14487 fail:
14488 return NULL;
14489 }
14490
14491
14492 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14493 PyObject *resultobj;
14494 wxFileType *arg1 = (wxFileType *) 0 ;
14495 PyObject *result;
14496 PyObject * obj0 = 0 ;
14497 char *kwnames[] = {
14498 (char *) "self", NULL
14499 };
14500
14501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14503 if (SWIG_arg_fail(1)) SWIG_fail;
14504 {
14505 PyThreadState* __tstate = wxPyBeginAllowThreads();
14506 result = (PyObject *)wxFileType_GetDescription(arg1);
14507
14508 wxPyEndAllowThreads(__tstate);
14509 if (PyErr_Occurred()) SWIG_fail;
14510 }
14511 resultobj = result;
14512 return resultobj;
14513 fail:
14514 return NULL;
14515 }
14516
14517
14518 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14519 PyObject *resultobj;
14520 wxFileType *arg1 = (wxFileType *) 0 ;
14521 wxString *arg2 = 0 ;
14522 wxString const &arg3_defvalue = wxPyEmptyString ;
14523 wxString *arg3 = (wxString *) &arg3_defvalue ;
14524 PyObject *result;
14525 bool temp2 = false ;
14526 bool temp3 = false ;
14527 PyObject * obj0 = 0 ;
14528 PyObject * obj1 = 0 ;
14529 PyObject * obj2 = 0 ;
14530 char *kwnames[] = {
14531 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14532 };
14533
14534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14536 if (SWIG_arg_fail(1)) SWIG_fail;
14537 {
14538 arg2 = wxString_in_helper(obj1);
14539 if (arg2 == NULL) SWIG_fail;
14540 temp2 = true;
14541 }
14542 if (obj2) {
14543 {
14544 arg3 = wxString_in_helper(obj2);
14545 if (arg3 == NULL) SWIG_fail;
14546 temp3 = true;
14547 }
14548 }
14549 {
14550 PyThreadState* __tstate = wxPyBeginAllowThreads();
14551 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14552
14553 wxPyEndAllowThreads(__tstate);
14554 if (PyErr_Occurred()) SWIG_fail;
14555 }
14556 resultobj = result;
14557 {
14558 if (temp2)
14559 delete arg2;
14560 }
14561 {
14562 if (temp3)
14563 delete arg3;
14564 }
14565 return resultobj;
14566 fail:
14567 {
14568 if (temp2)
14569 delete arg2;
14570 }
14571 {
14572 if (temp3)
14573 delete arg3;
14574 }
14575 return NULL;
14576 }
14577
14578
14579 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14580 PyObject *resultobj;
14581 wxFileType *arg1 = (wxFileType *) 0 ;
14582 wxString *arg2 = 0 ;
14583 wxString const &arg3_defvalue = wxPyEmptyString ;
14584 wxString *arg3 = (wxString *) &arg3_defvalue ;
14585 PyObject *result;
14586 bool temp2 = false ;
14587 bool temp3 = false ;
14588 PyObject * obj0 = 0 ;
14589 PyObject * obj1 = 0 ;
14590 PyObject * obj2 = 0 ;
14591 char *kwnames[] = {
14592 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14593 };
14594
14595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14597 if (SWIG_arg_fail(1)) SWIG_fail;
14598 {
14599 arg2 = wxString_in_helper(obj1);
14600 if (arg2 == NULL) SWIG_fail;
14601 temp2 = true;
14602 }
14603 if (obj2) {
14604 {
14605 arg3 = wxString_in_helper(obj2);
14606 if (arg3 == NULL) SWIG_fail;
14607 temp3 = true;
14608 }
14609 }
14610 {
14611 PyThreadState* __tstate = wxPyBeginAllowThreads();
14612 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14613
14614 wxPyEndAllowThreads(__tstate);
14615 if (PyErr_Occurred()) SWIG_fail;
14616 }
14617 resultobj = result;
14618 {
14619 if (temp2)
14620 delete arg2;
14621 }
14622 {
14623 if (temp3)
14624 delete arg3;
14625 }
14626 return resultobj;
14627 fail:
14628 {
14629 if (temp2)
14630 delete arg2;
14631 }
14632 {
14633 if (temp3)
14634 delete arg3;
14635 }
14636 return NULL;
14637 }
14638
14639
14640 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14641 PyObject *resultobj;
14642 wxFileType *arg1 = (wxFileType *) 0 ;
14643 wxString *arg2 = 0 ;
14644 wxString const &arg3_defvalue = wxPyEmptyString ;
14645 wxString *arg3 = (wxString *) &arg3_defvalue ;
14646 PyObject *result;
14647 bool temp2 = false ;
14648 bool temp3 = false ;
14649 PyObject * obj0 = 0 ;
14650 PyObject * obj1 = 0 ;
14651 PyObject * obj2 = 0 ;
14652 char *kwnames[] = {
14653 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14654 };
14655
14656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14658 if (SWIG_arg_fail(1)) SWIG_fail;
14659 {
14660 arg2 = wxString_in_helper(obj1);
14661 if (arg2 == NULL) SWIG_fail;
14662 temp2 = true;
14663 }
14664 if (obj2) {
14665 {
14666 arg3 = wxString_in_helper(obj2);
14667 if (arg3 == NULL) SWIG_fail;
14668 temp3 = true;
14669 }
14670 }
14671 {
14672 PyThreadState* __tstate = wxPyBeginAllowThreads();
14673 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14674
14675 wxPyEndAllowThreads(__tstate);
14676 if (PyErr_Occurred()) SWIG_fail;
14677 }
14678 resultobj = result;
14679 {
14680 if (temp2)
14681 delete arg2;
14682 }
14683 {
14684 if (temp3)
14685 delete arg3;
14686 }
14687 return resultobj;
14688 fail:
14689 {
14690 if (temp2)
14691 delete arg2;
14692 }
14693 {
14694 if (temp3)
14695 delete arg3;
14696 }
14697 return NULL;
14698 }
14699
14700
14701 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14702 PyObject *resultobj;
14703 wxFileType *arg1 = (wxFileType *) 0 ;
14704 wxString *arg2 = 0 ;
14705 wxString *arg3 = 0 ;
14706 bool arg4 = (bool) true ;
14707 bool result;
14708 bool temp2 = false ;
14709 bool temp3 = false ;
14710 PyObject * obj0 = 0 ;
14711 PyObject * obj1 = 0 ;
14712 PyObject * obj2 = 0 ;
14713 PyObject * obj3 = 0 ;
14714 char *kwnames[] = {
14715 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14716 };
14717
14718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14720 if (SWIG_arg_fail(1)) SWIG_fail;
14721 {
14722 arg2 = wxString_in_helper(obj1);
14723 if (arg2 == NULL) SWIG_fail;
14724 temp2 = true;
14725 }
14726 {
14727 arg3 = wxString_in_helper(obj2);
14728 if (arg3 == NULL) SWIG_fail;
14729 temp3 = true;
14730 }
14731 if (obj3) {
14732 {
14733 arg4 = (bool)(SWIG_As_bool(obj3));
14734 if (SWIG_arg_fail(4)) SWIG_fail;
14735 }
14736 }
14737 {
14738 PyThreadState* __tstate = wxPyBeginAllowThreads();
14739 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14740
14741 wxPyEndAllowThreads(__tstate);
14742 if (PyErr_Occurred()) SWIG_fail;
14743 }
14744 {
14745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14746 }
14747 {
14748 if (temp2)
14749 delete arg2;
14750 }
14751 {
14752 if (temp3)
14753 delete arg3;
14754 }
14755 return resultobj;
14756 fail:
14757 {
14758 if (temp2)
14759 delete arg2;
14760 }
14761 {
14762 if (temp3)
14763 delete arg3;
14764 }
14765 return NULL;
14766 }
14767
14768
14769 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14770 PyObject *resultobj;
14771 wxFileType *arg1 = (wxFileType *) 0 ;
14772 wxString const &arg2_defvalue = wxPyEmptyString ;
14773 wxString *arg2 = (wxString *) &arg2_defvalue ;
14774 int arg3 = (int) 0 ;
14775 bool result;
14776 bool temp2 = false ;
14777 PyObject * obj0 = 0 ;
14778 PyObject * obj1 = 0 ;
14779 PyObject * obj2 = 0 ;
14780 char *kwnames[] = {
14781 (char *) "self",(char *) "cmd",(char *) "index", NULL
14782 };
14783
14784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14786 if (SWIG_arg_fail(1)) SWIG_fail;
14787 if (obj1) {
14788 {
14789 arg2 = wxString_in_helper(obj1);
14790 if (arg2 == NULL) SWIG_fail;
14791 temp2 = true;
14792 }
14793 }
14794 if (obj2) {
14795 {
14796 arg3 = (int)(SWIG_As_int(obj2));
14797 if (SWIG_arg_fail(3)) SWIG_fail;
14798 }
14799 }
14800 {
14801 PyThreadState* __tstate = wxPyBeginAllowThreads();
14802 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14803
14804 wxPyEndAllowThreads(__tstate);
14805 if (PyErr_Occurred()) SWIG_fail;
14806 }
14807 {
14808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14809 }
14810 {
14811 if (temp2)
14812 delete arg2;
14813 }
14814 return resultobj;
14815 fail:
14816 {
14817 if (temp2)
14818 delete arg2;
14819 }
14820 return NULL;
14821 }
14822
14823
14824 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14825 PyObject *resultobj;
14826 wxFileType *arg1 = (wxFileType *) 0 ;
14827 bool result;
14828 PyObject * obj0 = 0 ;
14829 char *kwnames[] = {
14830 (char *) "self", NULL
14831 };
14832
14833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14835 if (SWIG_arg_fail(1)) SWIG_fail;
14836 {
14837 PyThreadState* __tstate = wxPyBeginAllowThreads();
14838 result = (bool)(arg1)->Unassociate();
14839
14840 wxPyEndAllowThreads(__tstate);
14841 if (PyErr_Occurred()) SWIG_fail;
14842 }
14843 {
14844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14845 }
14846 return resultobj;
14847 fail:
14848 return NULL;
14849 }
14850
14851
14852 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14853 PyObject *resultobj;
14854 wxString *arg1 = 0 ;
14855 wxString *arg2 = 0 ;
14856 wxString const &arg3_defvalue = wxPyEmptyString ;
14857 wxString *arg3 = (wxString *) &arg3_defvalue ;
14858 wxString result;
14859 bool temp1 = false ;
14860 bool temp2 = false ;
14861 bool temp3 = false ;
14862 PyObject * obj0 = 0 ;
14863 PyObject * obj1 = 0 ;
14864 PyObject * obj2 = 0 ;
14865 char *kwnames[] = {
14866 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14867 };
14868
14869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14870 {
14871 arg1 = wxString_in_helper(obj0);
14872 if (arg1 == NULL) SWIG_fail;
14873 temp1 = true;
14874 }
14875 {
14876 arg2 = wxString_in_helper(obj1);
14877 if (arg2 == NULL) SWIG_fail;
14878 temp2 = true;
14879 }
14880 if (obj2) {
14881 {
14882 arg3 = wxString_in_helper(obj2);
14883 if (arg3 == NULL) SWIG_fail;
14884 temp3 = true;
14885 }
14886 }
14887 {
14888 PyThreadState* __tstate = wxPyBeginAllowThreads();
14889 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14890
14891 wxPyEndAllowThreads(__tstate);
14892 if (PyErr_Occurred()) SWIG_fail;
14893 }
14894 {
14895 #if wxUSE_UNICODE
14896 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14897 #else
14898 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14899 #endif
14900 }
14901 {
14902 if (temp1)
14903 delete arg1;
14904 }
14905 {
14906 if (temp2)
14907 delete arg2;
14908 }
14909 {
14910 if (temp3)
14911 delete arg3;
14912 }
14913 return resultobj;
14914 fail:
14915 {
14916 if (temp1)
14917 delete arg1;
14918 }
14919 {
14920 if (temp2)
14921 delete arg2;
14922 }
14923 {
14924 if (temp3)
14925 delete arg3;
14926 }
14927 return NULL;
14928 }
14929
14930
14931 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14932 PyObject *obj;
14933 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14934 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14935 Py_INCREF(obj);
14936 return Py_BuildValue((char *)"");
14937 }
14938 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14939 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14940 return 1;
14941 }
14942
14943
14944 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14945 PyObject *pyobj;
14946
14947 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14948 return pyobj;
14949 }
14950
14951
14952 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14953 PyObject *resultobj;
14954 wxString *arg1 = 0 ;
14955 wxString *arg2 = 0 ;
14956 bool result;
14957 bool temp1 = false ;
14958 bool temp2 = false ;
14959 PyObject * obj0 = 0 ;
14960 PyObject * obj1 = 0 ;
14961 char *kwnames[] = {
14962 (char *) "mimeType",(char *) "wildcard", NULL
14963 };
14964
14965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14966 {
14967 arg1 = wxString_in_helper(obj0);
14968 if (arg1 == NULL) SWIG_fail;
14969 temp1 = true;
14970 }
14971 {
14972 arg2 = wxString_in_helper(obj1);
14973 if (arg2 == NULL) SWIG_fail;
14974 temp2 = true;
14975 }
14976 {
14977 PyThreadState* __tstate = wxPyBeginAllowThreads();
14978 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14979
14980 wxPyEndAllowThreads(__tstate);
14981 if (PyErr_Occurred()) SWIG_fail;
14982 }
14983 {
14984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14985 }
14986 {
14987 if (temp1)
14988 delete arg1;
14989 }
14990 {
14991 if (temp2)
14992 delete arg2;
14993 }
14994 return resultobj;
14995 fail:
14996 {
14997 if (temp1)
14998 delete arg1;
14999 }
15000 {
15001 if (temp2)
15002 delete arg2;
15003 }
15004 return NULL;
15005 }
15006
15007
15008 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15009 PyObject *resultobj;
15010 wxMimeTypesManager *result;
15011 char *kwnames[] = {
15012 NULL
15013 };
15014
15015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15016 {
15017 PyThreadState* __tstate = wxPyBeginAllowThreads();
15018 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15019
15020 wxPyEndAllowThreads(__tstate);
15021 if (PyErr_Occurred()) SWIG_fail;
15022 }
15023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15024 return resultobj;
15025 fail:
15026 return NULL;
15027 }
15028
15029
15030 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15031 PyObject *resultobj;
15032 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15033 int arg2 = (int) wxMAILCAP_ALL ;
15034 wxString const &arg3_defvalue = wxPyEmptyString ;
15035 wxString *arg3 = (wxString *) &arg3_defvalue ;
15036 bool temp3 = false ;
15037 PyObject * obj0 = 0 ;
15038 PyObject * obj1 = 0 ;
15039 PyObject * obj2 = 0 ;
15040 char *kwnames[] = {
15041 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15042 };
15043
15044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15046 if (SWIG_arg_fail(1)) SWIG_fail;
15047 if (obj1) {
15048 {
15049 arg2 = (int)(SWIG_As_int(obj1));
15050 if (SWIG_arg_fail(2)) SWIG_fail;
15051 }
15052 }
15053 if (obj2) {
15054 {
15055 arg3 = wxString_in_helper(obj2);
15056 if (arg3 == NULL) SWIG_fail;
15057 temp3 = true;
15058 }
15059 }
15060 {
15061 PyThreadState* __tstate = wxPyBeginAllowThreads();
15062 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15063
15064 wxPyEndAllowThreads(__tstate);
15065 if (PyErr_Occurred()) SWIG_fail;
15066 }
15067 Py_INCREF(Py_None); resultobj = Py_None;
15068 {
15069 if (temp3)
15070 delete arg3;
15071 }
15072 return resultobj;
15073 fail:
15074 {
15075 if (temp3)
15076 delete arg3;
15077 }
15078 return NULL;
15079 }
15080
15081
15082 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15083 PyObject *resultobj;
15084 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15085 PyObject * obj0 = 0 ;
15086 char *kwnames[] = {
15087 (char *) "self", NULL
15088 };
15089
15090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15092 if (SWIG_arg_fail(1)) SWIG_fail;
15093 {
15094 PyThreadState* __tstate = wxPyBeginAllowThreads();
15095 (arg1)->ClearData();
15096
15097 wxPyEndAllowThreads(__tstate);
15098 if (PyErr_Occurred()) SWIG_fail;
15099 }
15100 Py_INCREF(Py_None); resultobj = Py_None;
15101 return resultobj;
15102 fail:
15103 return NULL;
15104 }
15105
15106
15107 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15108 PyObject *resultobj;
15109 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15110 wxString *arg2 = 0 ;
15111 wxFileType *result;
15112 bool temp2 = false ;
15113 PyObject * obj0 = 0 ;
15114 PyObject * obj1 = 0 ;
15115 char *kwnames[] = {
15116 (char *) "self",(char *) "ext", NULL
15117 };
15118
15119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15121 if (SWIG_arg_fail(1)) SWIG_fail;
15122 {
15123 arg2 = wxString_in_helper(obj1);
15124 if (arg2 == NULL) SWIG_fail;
15125 temp2 = true;
15126 }
15127 {
15128 PyThreadState* __tstate = wxPyBeginAllowThreads();
15129 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15130
15131 wxPyEndAllowThreads(__tstate);
15132 if (PyErr_Occurred()) SWIG_fail;
15133 }
15134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15135 {
15136 if (temp2)
15137 delete arg2;
15138 }
15139 return resultobj;
15140 fail:
15141 {
15142 if (temp2)
15143 delete arg2;
15144 }
15145 return NULL;
15146 }
15147
15148
15149 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15150 PyObject *resultobj;
15151 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15152 wxString *arg2 = 0 ;
15153 wxFileType *result;
15154 bool temp2 = false ;
15155 PyObject * obj0 = 0 ;
15156 PyObject * obj1 = 0 ;
15157 char *kwnames[] = {
15158 (char *) "self",(char *) "mimeType", NULL
15159 };
15160
15161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15163 if (SWIG_arg_fail(1)) SWIG_fail;
15164 {
15165 arg2 = wxString_in_helper(obj1);
15166 if (arg2 == NULL) SWIG_fail;
15167 temp2 = true;
15168 }
15169 {
15170 PyThreadState* __tstate = wxPyBeginAllowThreads();
15171 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15172
15173 wxPyEndAllowThreads(__tstate);
15174 if (PyErr_Occurred()) SWIG_fail;
15175 }
15176 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15177 {
15178 if (temp2)
15179 delete arg2;
15180 }
15181 return resultobj;
15182 fail:
15183 {
15184 if (temp2)
15185 delete arg2;
15186 }
15187 return NULL;
15188 }
15189
15190
15191 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15192 PyObject *resultobj;
15193 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15194 wxString *arg2 = 0 ;
15195 bool arg3 = (bool) false ;
15196 bool result;
15197 bool temp2 = false ;
15198 PyObject * obj0 = 0 ;
15199 PyObject * obj1 = 0 ;
15200 PyObject * obj2 = 0 ;
15201 char *kwnames[] = {
15202 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15203 };
15204
15205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15207 if (SWIG_arg_fail(1)) SWIG_fail;
15208 {
15209 arg2 = wxString_in_helper(obj1);
15210 if (arg2 == NULL) SWIG_fail;
15211 temp2 = true;
15212 }
15213 if (obj2) {
15214 {
15215 arg3 = (bool)(SWIG_As_bool(obj2));
15216 if (SWIG_arg_fail(3)) SWIG_fail;
15217 }
15218 }
15219 {
15220 PyThreadState* __tstate = wxPyBeginAllowThreads();
15221 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15222
15223 wxPyEndAllowThreads(__tstate);
15224 if (PyErr_Occurred()) SWIG_fail;
15225 }
15226 {
15227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15228 }
15229 {
15230 if (temp2)
15231 delete arg2;
15232 }
15233 return resultobj;
15234 fail:
15235 {
15236 if (temp2)
15237 delete arg2;
15238 }
15239 return NULL;
15240 }
15241
15242
15243 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15244 PyObject *resultobj;
15245 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15246 wxString *arg2 = 0 ;
15247 bool result;
15248 bool temp2 = false ;
15249 PyObject * obj0 = 0 ;
15250 PyObject * obj1 = 0 ;
15251 char *kwnames[] = {
15252 (char *) "self",(char *) "filename", NULL
15253 };
15254
15255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15257 if (SWIG_arg_fail(1)) SWIG_fail;
15258 {
15259 arg2 = wxString_in_helper(obj1);
15260 if (arg2 == NULL) SWIG_fail;
15261 temp2 = true;
15262 }
15263 {
15264 PyThreadState* __tstate = wxPyBeginAllowThreads();
15265 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15266
15267 wxPyEndAllowThreads(__tstate);
15268 if (PyErr_Occurred()) SWIG_fail;
15269 }
15270 {
15271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15272 }
15273 {
15274 if (temp2)
15275 delete arg2;
15276 }
15277 return resultobj;
15278 fail:
15279 {
15280 if (temp2)
15281 delete arg2;
15282 }
15283 return NULL;
15284 }
15285
15286
15287 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15288 PyObject *resultobj;
15289 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15290 PyObject *result;
15291 PyObject * obj0 = 0 ;
15292 char *kwnames[] = {
15293 (char *) "self", NULL
15294 };
15295
15296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15298 if (SWIG_arg_fail(1)) SWIG_fail;
15299 {
15300 PyThreadState* __tstate = wxPyBeginAllowThreads();
15301 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15302
15303 wxPyEndAllowThreads(__tstate);
15304 if (PyErr_Occurred()) SWIG_fail;
15305 }
15306 resultobj = result;
15307 return resultobj;
15308 fail:
15309 return NULL;
15310 }
15311
15312
15313 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15314 PyObject *resultobj;
15315 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15316 wxFileTypeInfo *arg2 = 0 ;
15317 PyObject * obj0 = 0 ;
15318 PyObject * obj1 = 0 ;
15319 char *kwnames[] = {
15320 (char *) "self",(char *) "ft", NULL
15321 };
15322
15323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15325 if (SWIG_arg_fail(1)) SWIG_fail;
15326 {
15327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15328 if (SWIG_arg_fail(2)) SWIG_fail;
15329 if (arg2 == NULL) {
15330 SWIG_null_ref("wxFileTypeInfo");
15331 }
15332 if (SWIG_arg_fail(2)) SWIG_fail;
15333 }
15334 {
15335 PyThreadState* __tstate = wxPyBeginAllowThreads();
15336 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15337
15338 wxPyEndAllowThreads(__tstate);
15339 if (PyErr_Occurred()) SWIG_fail;
15340 }
15341 Py_INCREF(Py_None); resultobj = Py_None;
15342 return resultobj;
15343 fail:
15344 return NULL;
15345 }
15346
15347
15348 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15349 PyObject *resultobj;
15350 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15351 wxFileTypeInfo *arg2 = 0 ;
15352 wxFileType *result;
15353 PyObject * obj0 = 0 ;
15354 PyObject * obj1 = 0 ;
15355 char *kwnames[] = {
15356 (char *) "self",(char *) "ftInfo", NULL
15357 };
15358
15359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15361 if (SWIG_arg_fail(1)) SWIG_fail;
15362 {
15363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15364 if (SWIG_arg_fail(2)) SWIG_fail;
15365 if (arg2 == NULL) {
15366 SWIG_null_ref("wxFileTypeInfo");
15367 }
15368 if (SWIG_arg_fail(2)) SWIG_fail;
15369 }
15370 {
15371 PyThreadState* __tstate = wxPyBeginAllowThreads();
15372 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15373
15374 wxPyEndAllowThreads(__tstate);
15375 if (PyErr_Occurred()) SWIG_fail;
15376 }
15377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15378 return resultobj;
15379 fail:
15380 return NULL;
15381 }
15382
15383
15384 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15385 PyObject *resultobj;
15386 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15387 wxFileType *arg2 = (wxFileType *) 0 ;
15388 bool result;
15389 PyObject * obj0 = 0 ;
15390 PyObject * obj1 = 0 ;
15391 char *kwnames[] = {
15392 (char *) "self",(char *) "ft", NULL
15393 };
15394
15395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15397 if (SWIG_arg_fail(1)) SWIG_fail;
15398 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15399 if (SWIG_arg_fail(2)) SWIG_fail;
15400 {
15401 PyThreadState* __tstate = wxPyBeginAllowThreads();
15402 result = (bool)(arg1)->Unassociate(arg2);
15403
15404 wxPyEndAllowThreads(__tstate);
15405 if (PyErr_Occurred()) SWIG_fail;
15406 }
15407 {
15408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15409 }
15410 return resultobj;
15411 fail:
15412 return NULL;
15413 }
15414
15415
15416 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15417 PyObject *resultobj;
15418 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15419 PyObject * obj0 = 0 ;
15420 char *kwnames[] = {
15421 (char *) "self", NULL
15422 };
15423
15424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15426 if (SWIG_arg_fail(1)) SWIG_fail;
15427 {
15428 PyThreadState* __tstate = wxPyBeginAllowThreads();
15429 delete arg1;
15430
15431 wxPyEndAllowThreads(__tstate);
15432 if (PyErr_Occurred()) SWIG_fail;
15433 }
15434 Py_INCREF(Py_None); resultobj = Py_None;
15435 return resultobj;
15436 fail:
15437 return NULL;
15438 }
15439
15440
15441 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15442 PyObject *obj;
15443 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15444 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15445 Py_INCREF(obj);
15446 return Py_BuildValue((char *)"");
15447 }
15448 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15449 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15450 return 1;
15451 }
15452
15453
15454 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15455 PyObject *pyobj;
15456
15457 {
15458 #if wxUSE_UNICODE
15459 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15460 #else
15461 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15462 #endif
15463 }
15464 return pyobj;
15465 }
15466
15467
15468 static int _wrap_ART_MENU_set(PyObject *) {
15469 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15470 return 1;
15471 }
15472
15473
15474 static PyObject *_wrap_ART_MENU_get(void) {
15475 PyObject *pyobj;
15476
15477 {
15478 #if wxUSE_UNICODE
15479 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15480 #else
15481 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15482 #endif
15483 }
15484 return pyobj;
15485 }
15486
15487
15488 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15489 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15490 return 1;
15491 }
15492
15493
15494 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15495 PyObject *pyobj;
15496
15497 {
15498 #if wxUSE_UNICODE
15499 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15500 #else
15501 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15502 #endif
15503 }
15504 return pyobj;
15505 }
15506
15507
15508 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15509 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15510 return 1;
15511 }
15512
15513
15514 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15515 PyObject *pyobj;
15516
15517 {
15518 #if wxUSE_UNICODE
15519 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15520 #else
15521 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15522 #endif
15523 }
15524 return pyobj;
15525 }
15526
15527
15528 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15529 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15530 return 1;
15531 }
15532
15533
15534 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15535 PyObject *pyobj;
15536
15537 {
15538 #if wxUSE_UNICODE
15539 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15540 #else
15541 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15542 #endif
15543 }
15544 return pyobj;
15545 }
15546
15547
15548 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15549 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15550 return 1;
15551 }
15552
15553
15554 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15555 PyObject *pyobj;
15556
15557 {
15558 #if wxUSE_UNICODE
15559 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15560 #else
15561 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15562 #endif
15563 }
15564 return pyobj;
15565 }
15566
15567
15568 static int _wrap_ART_BUTTON_set(PyObject *) {
15569 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15570 return 1;
15571 }
15572
15573
15574 static PyObject *_wrap_ART_BUTTON_get(void) {
15575 PyObject *pyobj;
15576
15577 {
15578 #if wxUSE_UNICODE
15579 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15580 #else
15581 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15582 #endif
15583 }
15584 return pyobj;
15585 }
15586
15587
15588 static int _wrap_ART_OTHER_set(PyObject *) {
15589 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15590 return 1;
15591 }
15592
15593
15594 static PyObject *_wrap_ART_OTHER_get(void) {
15595 PyObject *pyobj;
15596
15597 {
15598 #if wxUSE_UNICODE
15599 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15600 #else
15601 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15602 #endif
15603 }
15604 return pyobj;
15605 }
15606
15607
15608 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15609 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15610 return 1;
15611 }
15612
15613
15614 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15615 PyObject *pyobj;
15616
15617 {
15618 #if wxUSE_UNICODE
15619 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15620 #else
15621 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15622 #endif
15623 }
15624 return pyobj;
15625 }
15626
15627
15628 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15629 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15630 return 1;
15631 }
15632
15633
15634 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15635 PyObject *pyobj;
15636
15637 {
15638 #if wxUSE_UNICODE
15639 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15640 #else
15641 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15642 #endif
15643 }
15644 return pyobj;
15645 }
15646
15647
15648 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15649 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15650 return 1;
15651 }
15652
15653
15654 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15655 PyObject *pyobj;
15656
15657 {
15658 #if wxUSE_UNICODE
15659 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15660 #else
15661 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15662 #endif
15663 }
15664 return pyobj;
15665 }
15666
15667
15668 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15669 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15670 return 1;
15671 }
15672
15673
15674 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15675 PyObject *pyobj;
15676
15677 {
15678 #if wxUSE_UNICODE
15679 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15680 #else
15681 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15682 #endif
15683 }
15684 return pyobj;
15685 }
15686
15687
15688 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15689 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15690 return 1;
15691 }
15692
15693
15694 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15695 PyObject *pyobj;
15696
15697 {
15698 #if wxUSE_UNICODE
15699 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15700 #else
15701 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15702 #endif
15703 }
15704 return pyobj;
15705 }
15706
15707
15708 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15709 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15710 return 1;
15711 }
15712
15713
15714 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15715 PyObject *pyobj;
15716
15717 {
15718 #if wxUSE_UNICODE
15719 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15720 #else
15721 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15722 #endif
15723 }
15724 return pyobj;
15725 }
15726
15727
15728 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15729 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15730 return 1;
15731 }
15732
15733
15734 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15735 PyObject *pyobj;
15736
15737 {
15738 #if wxUSE_UNICODE
15739 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15740 #else
15741 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15742 #endif
15743 }
15744 return pyobj;
15745 }
15746
15747
15748 static int _wrap_ART_GO_BACK_set(PyObject *) {
15749 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15750 return 1;
15751 }
15752
15753
15754 static PyObject *_wrap_ART_GO_BACK_get(void) {
15755 PyObject *pyobj;
15756
15757 {
15758 #if wxUSE_UNICODE
15759 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15760 #else
15761 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15762 #endif
15763 }
15764 return pyobj;
15765 }
15766
15767
15768 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15769 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15770 return 1;
15771 }
15772
15773
15774 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15775 PyObject *pyobj;
15776
15777 {
15778 #if wxUSE_UNICODE
15779 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15780 #else
15781 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15782 #endif
15783 }
15784 return pyobj;
15785 }
15786
15787
15788 static int _wrap_ART_GO_UP_set(PyObject *) {
15789 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15790 return 1;
15791 }
15792
15793
15794 static PyObject *_wrap_ART_GO_UP_get(void) {
15795 PyObject *pyobj;
15796
15797 {
15798 #if wxUSE_UNICODE
15799 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15800 #else
15801 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15802 #endif
15803 }
15804 return pyobj;
15805 }
15806
15807
15808 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15809 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15810 return 1;
15811 }
15812
15813
15814 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15815 PyObject *pyobj;
15816
15817 {
15818 #if wxUSE_UNICODE
15819 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15820 #else
15821 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15822 #endif
15823 }
15824 return pyobj;
15825 }
15826
15827
15828 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15829 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15830 return 1;
15831 }
15832
15833
15834 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15835 PyObject *pyobj;
15836
15837 {
15838 #if wxUSE_UNICODE
15839 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15840 #else
15841 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15842 #endif
15843 }
15844 return pyobj;
15845 }
15846
15847
15848 static int _wrap_ART_GO_HOME_set(PyObject *) {
15849 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15850 return 1;
15851 }
15852
15853
15854 static PyObject *_wrap_ART_GO_HOME_get(void) {
15855 PyObject *pyobj;
15856
15857 {
15858 #if wxUSE_UNICODE
15859 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15860 #else
15861 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15862 #endif
15863 }
15864 return pyobj;
15865 }
15866
15867
15868 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15869 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15870 return 1;
15871 }
15872
15873
15874 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15875 PyObject *pyobj;
15876
15877 {
15878 #if wxUSE_UNICODE
15879 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15880 #else
15881 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15882 #endif
15883 }
15884 return pyobj;
15885 }
15886
15887
15888 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15889 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15890 return 1;
15891 }
15892
15893
15894 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15895 PyObject *pyobj;
15896
15897 {
15898 #if wxUSE_UNICODE
15899 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15900 #else
15901 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15902 #endif
15903 }
15904 return pyobj;
15905 }
15906
15907
15908 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15909 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15910 return 1;
15911 }
15912
15913
15914 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15915 PyObject *pyobj;
15916
15917 {
15918 #if wxUSE_UNICODE
15919 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15920 #else
15921 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15922 #endif
15923 }
15924 return pyobj;
15925 }
15926
15927
15928 static int _wrap_ART_PRINT_set(PyObject *) {
15929 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15930 return 1;
15931 }
15932
15933
15934 static PyObject *_wrap_ART_PRINT_get(void) {
15935 PyObject *pyobj;
15936
15937 {
15938 #if wxUSE_UNICODE
15939 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15940 #else
15941 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15942 #endif
15943 }
15944 return pyobj;
15945 }
15946
15947
15948 static int _wrap_ART_HELP_set(PyObject *) {
15949 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15950 return 1;
15951 }
15952
15953
15954 static PyObject *_wrap_ART_HELP_get(void) {
15955 PyObject *pyobj;
15956
15957 {
15958 #if wxUSE_UNICODE
15959 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15960 #else
15961 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15962 #endif
15963 }
15964 return pyobj;
15965 }
15966
15967
15968 static int _wrap_ART_TIP_set(PyObject *) {
15969 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15970 return 1;
15971 }
15972
15973
15974 static PyObject *_wrap_ART_TIP_get(void) {
15975 PyObject *pyobj;
15976
15977 {
15978 #if wxUSE_UNICODE
15979 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15980 #else
15981 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15982 #endif
15983 }
15984 return pyobj;
15985 }
15986
15987
15988 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15989 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15990 return 1;
15991 }
15992
15993
15994 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15995 PyObject *pyobj;
15996
15997 {
15998 #if wxUSE_UNICODE
15999 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16000 #else
16001 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16002 #endif
16003 }
16004 return pyobj;
16005 }
16006
16007
16008 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16009 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16010 return 1;
16011 }
16012
16013
16014 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16015 PyObject *pyobj;
16016
16017 {
16018 #if wxUSE_UNICODE
16019 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16020 #else
16021 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16022 #endif
16023 }
16024 return pyobj;
16025 }
16026
16027
16028 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16029 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16030 return 1;
16031 }
16032
16033
16034 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16035 PyObject *pyobj;
16036
16037 {
16038 #if wxUSE_UNICODE
16039 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16040 #else
16041 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16042 #endif
16043 }
16044 return pyobj;
16045 }
16046
16047
16048 static int _wrap_ART_HARDDISK_set(PyObject *) {
16049 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16050 return 1;
16051 }
16052
16053
16054 static PyObject *_wrap_ART_HARDDISK_get(void) {
16055 PyObject *pyobj;
16056
16057 {
16058 #if wxUSE_UNICODE
16059 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16060 #else
16061 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16062 #endif
16063 }
16064 return pyobj;
16065 }
16066
16067
16068 static int _wrap_ART_FLOPPY_set(PyObject *) {
16069 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16070 return 1;
16071 }
16072
16073
16074 static PyObject *_wrap_ART_FLOPPY_get(void) {
16075 PyObject *pyobj;
16076
16077 {
16078 #if wxUSE_UNICODE
16079 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16080 #else
16081 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16082 #endif
16083 }
16084 return pyobj;
16085 }
16086
16087
16088 static int _wrap_ART_CDROM_set(PyObject *) {
16089 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16090 return 1;
16091 }
16092
16093
16094 static PyObject *_wrap_ART_CDROM_get(void) {
16095 PyObject *pyobj;
16096
16097 {
16098 #if wxUSE_UNICODE
16099 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16100 #else
16101 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16102 #endif
16103 }
16104 return pyobj;
16105 }
16106
16107
16108 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16109 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16110 return 1;
16111 }
16112
16113
16114 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16115 PyObject *pyobj;
16116
16117 {
16118 #if wxUSE_UNICODE
16119 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16120 #else
16121 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16122 #endif
16123 }
16124 return pyobj;
16125 }
16126
16127
16128 static int _wrap_ART_FOLDER_set(PyObject *) {
16129 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16130 return 1;
16131 }
16132
16133
16134 static PyObject *_wrap_ART_FOLDER_get(void) {
16135 PyObject *pyobj;
16136
16137 {
16138 #if wxUSE_UNICODE
16139 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16140 #else
16141 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16142 #endif
16143 }
16144 return pyobj;
16145 }
16146
16147
16148 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16149 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16150 return 1;
16151 }
16152
16153
16154 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16155 PyObject *pyobj;
16156
16157 {
16158 #if wxUSE_UNICODE
16159 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16160 #else
16161 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16162 #endif
16163 }
16164 return pyobj;
16165 }
16166
16167
16168 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16169 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16170 return 1;
16171 }
16172
16173
16174 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16175 PyObject *pyobj;
16176
16177 {
16178 #if wxUSE_UNICODE
16179 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16180 #else
16181 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16182 #endif
16183 }
16184 return pyobj;
16185 }
16186
16187
16188 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16189 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16190 return 1;
16191 }
16192
16193
16194 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16195 PyObject *pyobj;
16196
16197 {
16198 #if wxUSE_UNICODE
16199 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16200 #else
16201 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16202 #endif
16203 }
16204 return pyobj;
16205 }
16206
16207
16208 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16209 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16210 return 1;
16211 }
16212
16213
16214 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16215 PyObject *pyobj;
16216
16217 {
16218 #if wxUSE_UNICODE
16219 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16220 #else
16221 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16222 #endif
16223 }
16224 return pyobj;
16225 }
16226
16227
16228 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16229 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16230 return 1;
16231 }
16232
16233
16234 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16235 PyObject *pyobj;
16236
16237 {
16238 #if wxUSE_UNICODE
16239 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16240 #else
16241 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16242 #endif
16243 }
16244 return pyobj;
16245 }
16246
16247
16248 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16249 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16250 return 1;
16251 }
16252
16253
16254 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16255 PyObject *pyobj;
16256
16257 {
16258 #if wxUSE_UNICODE
16259 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16260 #else
16261 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16262 #endif
16263 }
16264 return pyobj;
16265 }
16266
16267
16268 static int _wrap_ART_ERROR_set(PyObject *) {
16269 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16270 return 1;
16271 }
16272
16273
16274 static PyObject *_wrap_ART_ERROR_get(void) {
16275 PyObject *pyobj;
16276
16277 {
16278 #if wxUSE_UNICODE
16279 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16280 #else
16281 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16282 #endif
16283 }
16284 return pyobj;
16285 }
16286
16287
16288 static int _wrap_ART_QUESTION_set(PyObject *) {
16289 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16290 return 1;
16291 }
16292
16293
16294 static PyObject *_wrap_ART_QUESTION_get(void) {
16295 PyObject *pyobj;
16296
16297 {
16298 #if wxUSE_UNICODE
16299 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16300 #else
16301 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16302 #endif
16303 }
16304 return pyobj;
16305 }
16306
16307
16308 static int _wrap_ART_WARNING_set(PyObject *) {
16309 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16310 return 1;
16311 }
16312
16313
16314 static PyObject *_wrap_ART_WARNING_get(void) {
16315 PyObject *pyobj;
16316
16317 {
16318 #if wxUSE_UNICODE
16319 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16320 #else
16321 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16322 #endif
16323 }
16324 return pyobj;
16325 }
16326
16327
16328 static int _wrap_ART_INFORMATION_set(PyObject *) {
16329 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16330 return 1;
16331 }
16332
16333
16334 static PyObject *_wrap_ART_INFORMATION_get(void) {
16335 PyObject *pyobj;
16336
16337 {
16338 #if wxUSE_UNICODE
16339 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16340 #else
16341 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16342 #endif
16343 }
16344 return pyobj;
16345 }
16346
16347
16348 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16349 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16350 return 1;
16351 }
16352
16353
16354 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16355 PyObject *pyobj;
16356
16357 {
16358 #if wxUSE_UNICODE
16359 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16360 #else
16361 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16362 #endif
16363 }
16364 return pyobj;
16365 }
16366
16367
16368 static int _wrap_ART_COPY_set(PyObject *) {
16369 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16370 return 1;
16371 }
16372
16373
16374 static PyObject *_wrap_ART_COPY_get(void) {
16375 PyObject *pyobj;
16376
16377 {
16378 #if wxUSE_UNICODE
16379 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16380 #else
16381 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16382 #endif
16383 }
16384 return pyobj;
16385 }
16386
16387
16388 static int _wrap_ART_CUT_set(PyObject *) {
16389 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16390 return 1;
16391 }
16392
16393
16394 static PyObject *_wrap_ART_CUT_get(void) {
16395 PyObject *pyobj;
16396
16397 {
16398 #if wxUSE_UNICODE
16399 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16400 #else
16401 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16402 #endif
16403 }
16404 return pyobj;
16405 }
16406
16407
16408 static int _wrap_ART_PASTE_set(PyObject *) {
16409 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16410 return 1;
16411 }
16412
16413
16414 static PyObject *_wrap_ART_PASTE_get(void) {
16415 PyObject *pyobj;
16416
16417 {
16418 #if wxUSE_UNICODE
16419 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16420 #else
16421 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16422 #endif
16423 }
16424 return pyobj;
16425 }
16426
16427
16428 static int _wrap_ART_DELETE_set(PyObject *) {
16429 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16430 return 1;
16431 }
16432
16433
16434 static PyObject *_wrap_ART_DELETE_get(void) {
16435 PyObject *pyobj;
16436
16437 {
16438 #if wxUSE_UNICODE
16439 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16440 #else
16441 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16442 #endif
16443 }
16444 return pyobj;
16445 }
16446
16447
16448 static int _wrap_ART_UNDO_set(PyObject *) {
16449 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16450 return 1;
16451 }
16452
16453
16454 static PyObject *_wrap_ART_UNDO_get(void) {
16455 PyObject *pyobj;
16456
16457 {
16458 #if wxUSE_UNICODE
16459 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16460 #else
16461 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16462 #endif
16463 }
16464 return pyobj;
16465 }
16466
16467
16468 static int _wrap_ART_REDO_set(PyObject *) {
16469 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16470 return 1;
16471 }
16472
16473
16474 static PyObject *_wrap_ART_REDO_get(void) {
16475 PyObject *pyobj;
16476
16477 {
16478 #if wxUSE_UNICODE
16479 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16480 #else
16481 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16482 #endif
16483 }
16484 return pyobj;
16485 }
16486
16487
16488 static int _wrap_ART_QUIT_set(PyObject *) {
16489 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16490 return 1;
16491 }
16492
16493
16494 static PyObject *_wrap_ART_QUIT_get(void) {
16495 PyObject *pyobj;
16496
16497 {
16498 #if wxUSE_UNICODE
16499 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16500 #else
16501 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16502 #endif
16503 }
16504 return pyobj;
16505 }
16506
16507
16508 static int _wrap_ART_FIND_set(PyObject *) {
16509 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16510 return 1;
16511 }
16512
16513
16514 static PyObject *_wrap_ART_FIND_get(void) {
16515 PyObject *pyobj;
16516
16517 {
16518 #if wxUSE_UNICODE
16519 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16520 #else
16521 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16522 #endif
16523 }
16524 return pyobj;
16525 }
16526
16527
16528 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16529 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16530 return 1;
16531 }
16532
16533
16534 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16535 PyObject *pyobj;
16536
16537 {
16538 #if wxUSE_UNICODE
16539 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16540 #else
16541 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16542 #endif
16543 }
16544 return pyobj;
16545 }
16546
16547
16548 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16549 PyObject *resultobj;
16550 wxPyArtProvider *result;
16551 char *kwnames[] = {
16552 NULL
16553 };
16554
16555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16556 {
16557 if (!wxPyCheckForApp()) SWIG_fail;
16558 PyThreadState* __tstate = wxPyBeginAllowThreads();
16559 result = (wxPyArtProvider *)new wxPyArtProvider();
16560
16561 wxPyEndAllowThreads(__tstate);
16562 if (PyErr_Occurred()) SWIG_fail;
16563 }
16564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16565 return resultobj;
16566 fail:
16567 return NULL;
16568 }
16569
16570
16571 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16572 PyObject *resultobj;
16573 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16574 PyObject *arg2 = (PyObject *) 0 ;
16575 PyObject *arg3 = (PyObject *) 0 ;
16576 PyObject * obj0 = 0 ;
16577 PyObject * obj1 = 0 ;
16578 PyObject * obj2 = 0 ;
16579 char *kwnames[] = {
16580 (char *) "self",(char *) "self",(char *) "_class", NULL
16581 };
16582
16583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16585 if (SWIG_arg_fail(1)) SWIG_fail;
16586 arg2 = obj1;
16587 arg3 = obj2;
16588 {
16589 PyThreadState* __tstate = wxPyBeginAllowThreads();
16590 (arg1)->_setCallbackInfo(arg2,arg3);
16591
16592 wxPyEndAllowThreads(__tstate);
16593 if (PyErr_Occurred()) SWIG_fail;
16594 }
16595 Py_INCREF(Py_None); resultobj = Py_None;
16596 return resultobj;
16597 fail:
16598 return NULL;
16599 }
16600
16601
16602 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16603 PyObject *resultobj;
16604 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16605 PyObject * obj0 = 0 ;
16606 char *kwnames[] = {
16607 (char *) "provider", NULL
16608 };
16609
16610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16612 if (SWIG_arg_fail(1)) SWIG_fail;
16613 {
16614 PyThreadState* __tstate = wxPyBeginAllowThreads();
16615 wxPyArtProvider::PushProvider(arg1);
16616
16617 wxPyEndAllowThreads(__tstate);
16618 if (PyErr_Occurred()) SWIG_fail;
16619 }
16620 Py_INCREF(Py_None); resultobj = Py_None;
16621 return resultobj;
16622 fail:
16623 return NULL;
16624 }
16625
16626
16627 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16628 PyObject *resultobj;
16629 bool result;
16630 char *kwnames[] = {
16631 NULL
16632 };
16633
16634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16635 {
16636 PyThreadState* __tstate = wxPyBeginAllowThreads();
16637 result = (bool)wxPyArtProvider::PopProvider();
16638
16639 wxPyEndAllowThreads(__tstate);
16640 if (PyErr_Occurred()) SWIG_fail;
16641 }
16642 {
16643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16644 }
16645 return resultobj;
16646 fail:
16647 return NULL;
16648 }
16649
16650
16651 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16652 PyObject *resultobj;
16653 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16654 bool result;
16655 PyObject * obj0 = 0 ;
16656 char *kwnames[] = {
16657 (char *) "provider", NULL
16658 };
16659
16660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16662 if (SWIG_arg_fail(1)) SWIG_fail;
16663 {
16664 PyThreadState* __tstate = wxPyBeginAllowThreads();
16665 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16666
16667 wxPyEndAllowThreads(__tstate);
16668 if (PyErr_Occurred()) SWIG_fail;
16669 }
16670 {
16671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16672 }
16673 return resultobj;
16674 fail:
16675 return NULL;
16676 }
16677
16678
16679 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16680 PyObject *resultobj;
16681 wxString *arg1 = 0 ;
16682 wxString const &arg2_defvalue = wxPyART_OTHER ;
16683 wxString *arg2 = (wxString *) &arg2_defvalue ;
16684 wxSize const &arg3_defvalue = wxDefaultSize ;
16685 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16686 wxBitmap result;
16687 bool temp1 = false ;
16688 bool temp2 = false ;
16689 wxSize temp3 ;
16690 PyObject * obj0 = 0 ;
16691 PyObject * obj1 = 0 ;
16692 PyObject * obj2 = 0 ;
16693 char *kwnames[] = {
16694 (char *) "id",(char *) "client",(char *) "size", NULL
16695 };
16696
16697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16698 {
16699 arg1 = wxString_in_helper(obj0);
16700 if (arg1 == NULL) SWIG_fail;
16701 temp1 = true;
16702 }
16703 if (obj1) {
16704 {
16705 arg2 = wxString_in_helper(obj1);
16706 if (arg2 == NULL) SWIG_fail;
16707 temp2 = true;
16708 }
16709 }
16710 if (obj2) {
16711 {
16712 arg3 = &temp3;
16713 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16714 }
16715 }
16716 {
16717 if (!wxPyCheckForApp()) SWIG_fail;
16718 PyThreadState* __tstate = wxPyBeginAllowThreads();
16719 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16720
16721 wxPyEndAllowThreads(__tstate);
16722 if (PyErr_Occurred()) SWIG_fail;
16723 }
16724 {
16725 wxBitmap * resultptr;
16726 resultptr = new wxBitmap((wxBitmap &)(result));
16727 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16728 }
16729 {
16730 if (temp1)
16731 delete arg1;
16732 }
16733 {
16734 if (temp2)
16735 delete arg2;
16736 }
16737 return resultobj;
16738 fail:
16739 {
16740 if (temp1)
16741 delete arg1;
16742 }
16743 {
16744 if (temp2)
16745 delete arg2;
16746 }
16747 return NULL;
16748 }
16749
16750
16751 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16752 PyObject *resultobj;
16753 wxString *arg1 = 0 ;
16754 wxString const &arg2_defvalue = wxPyART_OTHER ;
16755 wxString *arg2 = (wxString *) &arg2_defvalue ;
16756 wxSize const &arg3_defvalue = wxDefaultSize ;
16757 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16758 wxIcon result;
16759 bool temp1 = false ;
16760 bool temp2 = false ;
16761 wxSize temp3 ;
16762 PyObject * obj0 = 0 ;
16763 PyObject * obj1 = 0 ;
16764 PyObject * obj2 = 0 ;
16765 char *kwnames[] = {
16766 (char *) "id",(char *) "client",(char *) "size", NULL
16767 };
16768
16769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16770 {
16771 arg1 = wxString_in_helper(obj0);
16772 if (arg1 == NULL) SWIG_fail;
16773 temp1 = true;
16774 }
16775 if (obj1) {
16776 {
16777 arg2 = wxString_in_helper(obj1);
16778 if (arg2 == NULL) SWIG_fail;
16779 temp2 = true;
16780 }
16781 }
16782 if (obj2) {
16783 {
16784 arg3 = &temp3;
16785 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16786 }
16787 }
16788 {
16789 if (!wxPyCheckForApp()) SWIG_fail;
16790 PyThreadState* __tstate = wxPyBeginAllowThreads();
16791 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16792
16793 wxPyEndAllowThreads(__tstate);
16794 if (PyErr_Occurred()) SWIG_fail;
16795 }
16796 {
16797 wxIcon * resultptr;
16798 resultptr = new wxIcon((wxIcon &)(result));
16799 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16800 }
16801 {
16802 if (temp1)
16803 delete arg1;
16804 }
16805 {
16806 if (temp2)
16807 delete arg2;
16808 }
16809 return resultobj;
16810 fail:
16811 {
16812 if (temp1)
16813 delete arg1;
16814 }
16815 {
16816 if (temp2)
16817 delete arg2;
16818 }
16819 return NULL;
16820 }
16821
16822
16823 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16824 PyObject *resultobj;
16825 wxString *arg1 = 0 ;
16826 bool arg2 = (bool) false ;
16827 wxSize result;
16828 bool temp1 = false ;
16829 PyObject * obj0 = 0 ;
16830 PyObject * obj1 = 0 ;
16831 char *kwnames[] = {
16832 (char *) "client",(char *) "platform_dependent", NULL
16833 };
16834
16835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16836 {
16837 arg1 = wxString_in_helper(obj0);
16838 if (arg1 == NULL) SWIG_fail;
16839 temp1 = true;
16840 }
16841 if (obj1) {
16842 {
16843 arg2 = (bool)(SWIG_As_bool(obj1));
16844 if (SWIG_arg_fail(2)) SWIG_fail;
16845 }
16846 }
16847 {
16848 PyThreadState* __tstate = wxPyBeginAllowThreads();
16849 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16850
16851 wxPyEndAllowThreads(__tstate);
16852 if (PyErr_Occurred()) SWIG_fail;
16853 }
16854 {
16855 wxSize * resultptr;
16856 resultptr = new wxSize((wxSize &)(result));
16857 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16858 }
16859 {
16860 if (temp1)
16861 delete arg1;
16862 }
16863 return resultobj;
16864 fail:
16865 {
16866 if (temp1)
16867 delete arg1;
16868 }
16869 return NULL;
16870 }
16871
16872
16873 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16874 PyObject *resultobj;
16875 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16876 PyObject * obj0 = 0 ;
16877 char *kwnames[] = {
16878 (char *) "self", NULL
16879 };
16880
16881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16883 if (SWIG_arg_fail(1)) SWIG_fail;
16884 {
16885 PyThreadState* __tstate = wxPyBeginAllowThreads();
16886 wxPyArtProvider_Destroy(arg1);
16887
16888 wxPyEndAllowThreads(__tstate);
16889 if (PyErr_Occurred()) SWIG_fail;
16890 }
16891 Py_INCREF(Py_None); resultobj = Py_None;
16892 return resultobj;
16893 fail:
16894 return NULL;
16895 }
16896
16897
16898 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16899 PyObject *obj;
16900 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16901 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16902 Py_INCREF(obj);
16903 return Py_BuildValue((char *)"");
16904 }
16905 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16906 PyObject *resultobj;
16907 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16908 PyObject * obj0 = 0 ;
16909 char *kwnames[] = {
16910 (char *) "self", NULL
16911 };
16912
16913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16915 if (SWIG_arg_fail(1)) SWIG_fail;
16916 {
16917 PyThreadState* __tstate = wxPyBeginAllowThreads();
16918 delete arg1;
16919
16920 wxPyEndAllowThreads(__tstate);
16921 if (PyErr_Occurred()) SWIG_fail;
16922 }
16923 Py_INCREF(Py_None); resultobj = Py_None;
16924 return resultobj;
16925 fail:
16926 return NULL;
16927 }
16928
16929
16930 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16931 PyObject *resultobj;
16932 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16933 wxConfigBase *result;
16934 PyObject * obj0 = 0 ;
16935 char *kwnames[] = {
16936 (char *) "config", NULL
16937 };
16938
16939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
16941 if (SWIG_arg_fail(1)) SWIG_fail;
16942 {
16943 PyThreadState* __tstate = wxPyBeginAllowThreads();
16944 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16945
16946 wxPyEndAllowThreads(__tstate);
16947 if (PyErr_Occurred()) SWIG_fail;
16948 }
16949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16950 return resultobj;
16951 fail:
16952 return NULL;
16953 }
16954
16955
16956 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16957 PyObject *resultobj;
16958 bool arg1 = (bool) true ;
16959 wxConfigBase *result;
16960 PyObject * obj0 = 0 ;
16961 char *kwnames[] = {
16962 (char *) "createOnDemand", NULL
16963 };
16964
16965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16966 if (obj0) {
16967 {
16968 arg1 = (bool)(SWIG_As_bool(obj0));
16969 if (SWIG_arg_fail(1)) SWIG_fail;
16970 }
16971 }
16972 {
16973 PyThreadState* __tstate = wxPyBeginAllowThreads();
16974 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16975
16976 wxPyEndAllowThreads(__tstate);
16977 if (PyErr_Occurred()) SWIG_fail;
16978 }
16979 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16980 return resultobj;
16981 fail:
16982 return NULL;
16983 }
16984
16985
16986 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16987 PyObject *resultobj;
16988 wxConfigBase *result;
16989 char *kwnames[] = {
16990 NULL
16991 };
16992
16993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16994 {
16995 PyThreadState* __tstate = wxPyBeginAllowThreads();
16996 result = (wxConfigBase *)wxConfigBase::Create();
16997
16998 wxPyEndAllowThreads(__tstate);
16999 if (PyErr_Occurred()) SWIG_fail;
17000 }
17001 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17002 return resultobj;
17003 fail:
17004 return NULL;
17005 }
17006
17007
17008 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17009 PyObject *resultobj;
17010 char *kwnames[] = {
17011 NULL
17012 };
17013
17014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17015 {
17016 PyThreadState* __tstate = wxPyBeginAllowThreads();
17017 wxConfigBase::DontCreateOnDemand();
17018
17019 wxPyEndAllowThreads(__tstate);
17020 if (PyErr_Occurred()) SWIG_fail;
17021 }
17022 Py_INCREF(Py_None); resultobj = Py_None;
17023 return resultobj;
17024 fail:
17025 return NULL;
17026 }
17027
17028
17029 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17030 PyObject *resultobj;
17031 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17032 wxString *arg2 = 0 ;
17033 bool temp2 = false ;
17034 PyObject * obj0 = 0 ;
17035 PyObject * obj1 = 0 ;
17036 char *kwnames[] = {
17037 (char *) "self",(char *) "path", NULL
17038 };
17039
17040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17042 if (SWIG_arg_fail(1)) SWIG_fail;
17043 {
17044 arg2 = wxString_in_helper(obj1);
17045 if (arg2 == NULL) SWIG_fail;
17046 temp2 = true;
17047 }
17048 {
17049 PyThreadState* __tstate = wxPyBeginAllowThreads();
17050 (arg1)->SetPath((wxString const &)*arg2);
17051
17052 wxPyEndAllowThreads(__tstate);
17053 if (PyErr_Occurred()) SWIG_fail;
17054 }
17055 Py_INCREF(Py_None); resultobj = Py_None;
17056 {
17057 if (temp2)
17058 delete arg2;
17059 }
17060 return resultobj;
17061 fail:
17062 {
17063 if (temp2)
17064 delete arg2;
17065 }
17066 return NULL;
17067 }
17068
17069
17070 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17071 PyObject *resultobj;
17072 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17073 wxString *result;
17074 PyObject * obj0 = 0 ;
17075 char *kwnames[] = {
17076 (char *) "self", NULL
17077 };
17078
17079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17081 if (SWIG_arg_fail(1)) SWIG_fail;
17082 {
17083 PyThreadState* __tstate = wxPyBeginAllowThreads();
17084 {
17085 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17086 result = (wxString *) &_result_ref;
17087 }
17088
17089 wxPyEndAllowThreads(__tstate);
17090 if (PyErr_Occurred()) SWIG_fail;
17091 }
17092 {
17093 #if wxUSE_UNICODE
17094 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17095 #else
17096 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17097 #endif
17098 }
17099 return resultobj;
17100 fail:
17101 return NULL;
17102 }
17103
17104
17105 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17106 PyObject *resultobj;
17107 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17108 PyObject *result;
17109 PyObject * obj0 = 0 ;
17110 char *kwnames[] = {
17111 (char *) "self", NULL
17112 };
17113
17114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17116 if (SWIG_arg_fail(1)) SWIG_fail;
17117 {
17118 PyThreadState* __tstate = wxPyBeginAllowThreads();
17119 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17120
17121 wxPyEndAllowThreads(__tstate);
17122 if (PyErr_Occurred()) SWIG_fail;
17123 }
17124 resultobj = result;
17125 return resultobj;
17126 fail:
17127 return NULL;
17128 }
17129
17130
17131 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17132 PyObject *resultobj;
17133 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17134 long arg2 ;
17135 PyObject *result;
17136 PyObject * obj0 = 0 ;
17137 PyObject * obj1 = 0 ;
17138 char *kwnames[] = {
17139 (char *) "self",(char *) "index", NULL
17140 };
17141
17142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17144 if (SWIG_arg_fail(1)) SWIG_fail;
17145 {
17146 arg2 = (long)(SWIG_As_long(obj1));
17147 if (SWIG_arg_fail(2)) SWIG_fail;
17148 }
17149 {
17150 PyThreadState* __tstate = wxPyBeginAllowThreads();
17151 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17152
17153 wxPyEndAllowThreads(__tstate);
17154 if (PyErr_Occurred()) SWIG_fail;
17155 }
17156 resultobj = result;
17157 return resultobj;
17158 fail:
17159 return NULL;
17160 }
17161
17162
17163 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17164 PyObject *resultobj;
17165 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17166 PyObject *result;
17167 PyObject * obj0 = 0 ;
17168 char *kwnames[] = {
17169 (char *) "self", NULL
17170 };
17171
17172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17174 if (SWIG_arg_fail(1)) SWIG_fail;
17175 {
17176 PyThreadState* __tstate = wxPyBeginAllowThreads();
17177 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17178
17179 wxPyEndAllowThreads(__tstate);
17180 if (PyErr_Occurred()) SWIG_fail;
17181 }
17182 resultobj = result;
17183 return resultobj;
17184 fail:
17185 return NULL;
17186 }
17187
17188
17189 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17190 PyObject *resultobj;
17191 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17192 long arg2 ;
17193 PyObject *result;
17194 PyObject * obj0 = 0 ;
17195 PyObject * obj1 = 0 ;
17196 char *kwnames[] = {
17197 (char *) "self",(char *) "index", NULL
17198 };
17199
17200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17202 if (SWIG_arg_fail(1)) SWIG_fail;
17203 {
17204 arg2 = (long)(SWIG_As_long(obj1));
17205 if (SWIG_arg_fail(2)) SWIG_fail;
17206 }
17207 {
17208 PyThreadState* __tstate = wxPyBeginAllowThreads();
17209 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17210
17211 wxPyEndAllowThreads(__tstate);
17212 if (PyErr_Occurred()) SWIG_fail;
17213 }
17214 resultobj = result;
17215 return resultobj;
17216 fail:
17217 return NULL;
17218 }
17219
17220
17221 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17222 PyObject *resultobj;
17223 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17224 bool arg2 = (bool) false ;
17225 size_t result;
17226 PyObject * obj0 = 0 ;
17227 PyObject * obj1 = 0 ;
17228 char *kwnames[] = {
17229 (char *) "self",(char *) "recursive", NULL
17230 };
17231
17232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17234 if (SWIG_arg_fail(1)) SWIG_fail;
17235 if (obj1) {
17236 {
17237 arg2 = (bool)(SWIG_As_bool(obj1));
17238 if (SWIG_arg_fail(2)) SWIG_fail;
17239 }
17240 }
17241 {
17242 PyThreadState* __tstate = wxPyBeginAllowThreads();
17243 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17244
17245 wxPyEndAllowThreads(__tstate);
17246 if (PyErr_Occurred()) SWIG_fail;
17247 }
17248 {
17249 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17250 }
17251 return resultobj;
17252 fail:
17253 return NULL;
17254 }
17255
17256
17257 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17258 PyObject *resultobj;
17259 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17260 bool arg2 = (bool) false ;
17261 size_t result;
17262 PyObject * obj0 = 0 ;
17263 PyObject * obj1 = 0 ;
17264 char *kwnames[] = {
17265 (char *) "self",(char *) "recursive", NULL
17266 };
17267
17268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17270 if (SWIG_arg_fail(1)) SWIG_fail;
17271 if (obj1) {
17272 {
17273 arg2 = (bool)(SWIG_As_bool(obj1));
17274 if (SWIG_arg_fail(2)) SWIG_fail;
17275 }
17276 }
17277 {
17278 PyThreadState* __tstate = wxPyBeginAllowThreads();
17279 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17280
17281 wxPyEndAllowThreads(__tstate);
17282 if (PyErr_Occurred()) SWIG_fail;
17283 }
17284 {
17285 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17286 }
17287 return resultobj;
17288 fail:
17289 return NULL;
17290 }
17291
17292
17293 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17294 PyObject *resultobj;
17295 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17296 wxString *arg2 = 0 ;
17297 bool result;
17298 bool temp2 = false ;
17299 PyObject * obj0 = 0 ;
17300 PyObject * obj1 = 0 ;
17301 char *kwnames[] = {
17302 (char *) "self",(char *) "name", NULL
17303 };
17304
17305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17307 if (SWIG_arg_fail(1)) SWIG_fail;
17308 {
17309 arg2 = wxString_in_helper(obj1);
17310 if (arg2 == NULL) SWIG_fail;
17311 temp2 = true;
17312 }
17313 {
17314 PyThreadState* __tstate = wxPyBeginAllowThreads();
17315 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17316
17317 wxPyEndAllowThreads(__tstate);
17318 if (PyErr_Occurred()) SWIG_fail;
17319 }
17320 {
17321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17322 }
17323 {
17324 if (temp2)
17325 delete arg2;
17326 }
17327 return resultobj;
17328 fail:
17329 {
17330 if (temp2)
17331 delete arg2;
17332 }
17333 return NULL;
17334 }
17335
17336
17337 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17338 PyObject *resultobj;
17339 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17340 wxString *arg2 = 0 ;
17341 bool result;
17342 bool temp2 = false ;
17343 PyObject * obj0 = 0 ;
17344 PyObject * obj1 = 0 ;
17345 char *kwnames[] = {
17346 (char *) "self",(char *) "name", NULL
17347 };
17348
17349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17351 if (SWIG_arg_fail(1)) SWIG_fail;
17352 {
17353 arg2 = wxString_in_helper(obj1);
17354 if (arg2 == NULL) SWIG_fail;
17355 temp2 = true;
17356 }
17357 {
17358 PyThreadState* __tstate = wxPyBeginAllowThreads();
17359 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17360
17361 wxPyEndAllowThreads(__tstate);
17362 if (PyErr_Occurred()) SWIG_fail;
17363 }
17364 {
17365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17366 }
17367 {
17368 if (temp2)
17369 delete arg2;
17370 }
17371 return resultobj;
17372 fail:
17373 {
17374 if (temp2)
17375 delete arg2;
17376 }
17377 return NULL;
17378 }
17379
17380
17381 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17382 PyObject *resultobj;
17383 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17384 wxString *arg2 = 0 ;
17385 bool result;
17386 bool temp2 = false ;
17387 PyObject * obj0 = 0 ;
17388 PyObject * obj1 = 0 ;
17389 char *kwnames[] = {
17390 (char *) "self",(char *) "name", NULL
17391 };
17392
17393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17395 if (SWIG_arg_fail(1)) SWIG_fail;
17396 {
17397 arg2 = wxString_in_helper(obj1);
17398 if (arg2 == NULL) SWIG_fail;
17399 temp2 = true;
17400 }
17401 {
17402 PyThreadState* __tstate = wxPyBeginAllowThreads();
17403 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17404
17405 wxPyEndAllowThreads(__tstate);
17406 if (PyErr_Occurred()) SWIG_fail;
17407 }
17408 {
17409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17410 }
17411 {
17412 if (temp2)
17413 delete arg2;
17414 }
17415 return resultobj;
17416 fail:
17417 {
17418 if (temp2)
17419 delete arg2;
17420 }
17421 return NULL;
17422 }
17423
17424
17425 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17426 PyObject *resultobj;
17427 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17428 wxString *arg2 = 0 ;
17429 wxConfigBase::EntryType result;
17430 bool temp2 = false ;
17431 PyObject * obj0 = 0 ;
17432 PyObject * obj1 = 0 ;
17433 char *kwnames[] = {
17434 (char *) "self",(char *) "name", NULL
17435 };
17436
17437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17439 if (SWIG_arg_fail(1)) SWIG_fail;
17440 {
17441 arg2 = wxString_in_helper(obj1);
17442 if (arg2 == NULL) SWIG_fail;
17443 temp2 = true;
17444 }
17445 {
17446 PyThreadState* __tstate = wxPyBeginAllowThreads();
17447 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17448
17449 wxPyEndAllowThreads(__tstate);
17450 if (PyErr_Occurred()) SWIG_fail;
17451 }
17452 resultobj = SWIG_From_int((result));
17453 {
17454 if (temp2)
17455 delete arg2;
17456 }
17457 return resultobj;
17458 fail:
17459 {
17460 if (temp2)
17461 delete arg2;
17462 }
17463 return NULL;
17464 }
17465
17466
17467 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17468 PyObject *resultobj;
17469 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17470 wxString *arg2 = 0 ;
17471 wxString const &arg3_defvalue = wxPyEmptyString ;
17472 wxString *arg3 = (wxString *) &arg3_defvalue ;
17473 wxString result;
17474 bool temp2 = false ;
17475 bool temp3 = false ;
17476 PyObject * obj0 = 0 ;
17477 PyObject * obj1 = 0 ;
17478 PyObject * obj2 = 0 ;
17479 char *kwnames[] = {
17480 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17481 };
17482
17483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17485 if (SWIG_arg_fail(1)) SWIG_fail;
17486 {
17487 arg2 = wxString_in_helper(obj1);
17488 if (arg2 == NULL) SWIG_fail;
17489 temp2 = true;
17490 }
17491 if (obj2) {
17492 {
17493 arg3 = wxString_in_helper(obj2);
17494 if (arg3 == NULL) SWIG_fail;
17495 temp3 = true;
17496 }
17497 }
17498 {
17499 PyThreadState* __tstate = wxPyBeginAllowThreads();
17500 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17501
17502 wxPyEndAllowThreads(__tstate);
17503 if (PyErr_Occurred()) SWIG_fail;
17504 }
17505 {
17506 #if wxUSE_UNICODE
17507 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17508 #else
17509 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17510 #endif
17511 }
17512 {
17513 if (temp2)
17514 delete arg2;
17515 }
17516 {
17517 if (temp3)
17518 delete arg3;
17519 }
17520 return resultobj;
17521 fail:
17522 {
17523 if (temp2)
17524 delete arg2;
17525 }
17526 {
17527 if (temp3)
17528 delete arg3;
17529 }
17530 return NULL;
17531 }
17532
17533
17534 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17535 PyObject *resultobj;
17536 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17537 wxString *arg2 = 0 ;
17538 long arg3 = (long) 0 ;
17539 long result;
17540 bool temp2 = false ;
17541 PyObject * obj0 = 0 ;
17542 PyObject * obj1 = 0 ;
17543 PyObject * obj2 = 0 ;
17544 char *kwnames[] = {
17545 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17546 };
17547
17548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17550 if (SWIG_arg_fail(1)) SWIG_fail;
17551 {
17552 arg2 = wxString_in_helper(obj1);
17553 if (arg2 == NULL) SWIG_fail;
17554 temp2 = true;
17555 }
17556 if (obj2) {
17557 {
17558 arg3 = (long)(SWIG_As_long(obj2));
17559 if (SWIG_arg_fail(3)) SWIG_fail;
17560 }
17561 }
17562 {
17563 PyThreadState* __tstate = wxPyBeginAllowThreads();
17564 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17565
17566 wxPyEndAllowThreads(__tstate);
17567 if (PyErr_Occurred()) SWIG_fail;
17568 }
17569 {
17570 resultobj = SWIG_From_long((long)(result));
17571 }
17572 {
17573 if (temp2)
17574 delete arg2;
17575 }
17576 return resultobj;
17577 fail:
17578 {
17579 if (temp2)
17580 delete arg2;
17581 }
17582 return NULL;
17583 }
17584
17585
17586 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17587 PyObject *resultobj;
17588 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17589 wxString *arg2 = 0 ;
17590 double arg3 = (double) 0.0 ;
17591 double result;
17592 bool temp2 = false ;
17593 PyObject * obj0 = 0 ;
17594 PyObject * obj1 = 0 ;
17595 PyObject * obj2 = 0 ;
17596 char *kwnames[] = {
17597 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17598 };
17599
17600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17602 if (SWIG_arg_fail(1)) SWIG_fail;
17603 {
17604 arg2 = wxString_in_helper(obj1);
17605 if (arg2 == NULL) SWIG_fail;
17606 temp2 = true;
17607 }
17608 if (obj2) {
17609 {
17610 arg3 = (double)(SWIG_As_double(obj2));
17611 if (SWIG_arg_fail(3)) SWIG_fail;
17612 }
17613 }
17614 {
17615 PyThreadState* __tstate = wxPyBeginAllowThreads();
17616 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17617
17618 wxPyEndAllowThreads(__tstate);
17619 if (PyErr_Occurred()) SWIG_fail;
17620 }
17621 {
17622 resultobj = SWIG_From_double((double)(result));
17623 }
17624 {
17625 if (temp2)
17626 delete arg2;
17627 }
17628 return resultobj;
17629 fail:
17630 {
17631 if (temp2)
17632 delete arg2;
17633 }
17634 return NULL;
17635 }
17636
17637
17638 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17639 PyObject *resultobj;
17640 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17641 wxString *arg2 = 0 ;
17642 bool arg3 = (bool) false ;
17643 bool result;
17644 bool temp2 = false ;
17645 PyObject * obj0 = 0 ;
17646 PyObject * obj1 = 0 ;
17647 PyObject * obj2 = 0 ;
17648 char *kwnames[] = {
17649 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17650 };
17651
17652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17654 if (SWIG_arg_fail(1)) SWIG_fail;
17655 {
17656 arg2 = wxString_in_helper(obj1);
17657 if (arg2 == NULL) SWIG_fail;
17658 temp2 = true;
17659 }
17660 if (obj2) {
17661 {
17662 arg3 = (bool)(SWIG_As_bool(obj2));
17663 if (SWIG_arg_fail(3)) SWIG_fail;
17664 }
17665 }
17666 {
17667 PyThreadState* __tstate = wxPyBeginAllowThreads();
17668 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17669
17670 wxPyEndAllowThreads(__tstate);
17671 if (PyErr_Occurred()) SWIG_fail;
17672 }
17673 {
17674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17675 }
17676 {
17677 if (temp2)
17678 delete arg2;
17679 }
17680 return resultobj;
17681 fail:
17682 {
17683 if (temp2)
17684 delete arg2;
17685 }
17686 return NULL;
17687 }
17688
17689
17690 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17691 PyObject *resultobj;
17692 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17693 wxString *arg2 = 0 ;
17694 wxString *arg3 = 0 ;
17695 bool result;
17696 bool temp2 = false ;
17697 bool temp3 = false ;
17698 PyObject * obj0 = 0 ;
17699 PyObject * obj1 = 0 ;
17700 PyObject * obj2 = 0 ;
17701 char *kwnames[] = {
17702 (char *) "self",(char *) "key",(char *) "value", NULL
17703 };
17704
17705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17707 if (SWIG_arg_fail(1)) SWIG_fail;
17708 {
17709 arg2 = wxString_in_helper(obj1);
17710 if (arg2 == NULL) SWIG_fail;
17711 temp2 = true;
17712 }
17713 {
17714 arg3 = wxString_in_helper(obj2);
17715 if (arg3 == NULL) SWIG_fail;
17716 temp3 = true;
17717 }
17718 {
17719 PyThreadState* __tstate = wxPyBeginAllowThreads();
17720 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17721
17722 wxPyEndAllowThreads(__tstate);
17723 if (PyErr_Occurred()) SWIG_fail;
17724 }
17725 {
17726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17727 }
17728 {
17729 if (temp2)
17730 delete arg2;
17731 }
17732 {
17733 if (temp3)
17734 delete arg3;
17735 }
17736 return resultobj;
17737 fail:
17738 {
17739 if (temp2)
17740 delete arg2;
17741 }
17742 {
17743 if (temp3)
17744 delete arg3;
17745 }
17746 return NULL;
17747 }
17748
17749
17750 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17751 PyObject *resultobj;
17752 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17753 wxString *arg2 = 0 ;
17754 long arg3 ;
17755 bool result;
17756 bool temp2 = false ;
17757 PyObject * obj0 = 0 ;
17758 PyObject * obj1 = 0 ;
17759 PyObject * obj2 = 0 ;
17760 char *kwnames[] = {
17761 (char *) "self",(char *) "key",(char *) "value", NULL
17762 };
17763
17764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17766 if (SWIG_arg_fail(1)) SWIG_fail;
17767 {
17768 arg2 = wxString_in_helper(obj1);
17769 if (arg2 == NULL) SWIG_fail;
17770 temp2 = true;
17771 }
17772 {
17773 arg3 = (long)(SWIG_As_long(obj2));
17774 if (SWIG_arg_fail(3)) SWIG_fail;
17775 }
17776 {
17777 PyThreadState* __tstate = wxPyBeginAllowThreads();
17778 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17779
17780 wxPyEndAllowThreads(__tstate);
17781 if (PyErr_Occurred()) SWIG_fail;
17782 }
17783 {
17784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17785 }
17786 {
17787 if (temp2)
17788 delete arg2;
17789 }
17790 return resultobj;
17791 fail:
17792 {
17793 if (temp2)
17794 delete arg2;
17795 }
17796 return NULL;
17797 }
17798
17799
17800 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17801 PyObject *resultobj;
17802 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17803 wxString *arg2 = 0 ;
17804 double arg3 ;
17805 bool result;
17806 bool temp2 = false ;
17807 PyObject * obj0 = 0 ;
17808 PyObject * obj1 = 0 ;
17809 PyObject * obj2 = 0 ;
17810 char *kwnames[] = {
17811 (char *) "self",(char *) "key",(char *) "value", NULL
17812 };
17813
17814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17816 if (SWIG_arg_fail(1)) SWIG_fail;
17817 {
17818 arg2 = wxString_in_helper(obj1);
17819 if (arg2 == NULL) SWIG_fail;
17820 temp2 = true;
17821 }
17822 {
17823 arg3 = (double)(SWIG_As_double(obj2));
17824 if (SWIG_arg_fail(3)) SWIG_fail;
17825 }
17826 {
17827 PyThreadState* __tstate = wxPyBeginAllowThreads();
17828 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17829
17830 wxPyEndAllowThreads(__tstate);
17831 if (PyErr_Occurred()) SWIG_fail;
17832 }
17833 {
17834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17835 }
17836 {
17837 if (temp2)
17838 delete arg2;
17839 }
17840 return resultobj;
17841 fail:
17842 {
17843 if (temp2)
17844 delete arg2;
17845 }
17846 return NULL;
17847 }
17848
17849
17850 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17851 PyObject *resultobj;
17852 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17853 wxString *arg2 = 0 ;
17854 bool arg3 ;
17855 bool result;
17856 bool temp2 = false ;
17857 PyObject * obj0 = 0 ;
17858 PyObject * obj1 = 0 ;
17859 PyObject * obj2 = 0 ;
17860 char *kwnames[] = {
17861 (char *) "self",(char *) "key",(char *) "value", NULL
17862 };
17863
17864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17866 if (SWIG_arg_fail(1)) SWIG_fail;
17867 {
17868 arg2 = wxString_in_helper(obj1);
17869 if (arg2 == NULL) SWIG_fail;
17870 temp2 = true;
17871 }
17872 {
17873 arg3 = (bool)(SWIG_As_bool(obj2));
17874 if (SWIG_arg_fail(3)) SWIG_fail;
17875 }
17876 {
17877 PyThreadState* __tstate = wxPyBeginAllowThreads();
17878 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17879
17880 wxPyEndAllowThreads(__tstate);
17881 if (PyErr_Occurred()) SWIG_fail;
17882 }
17883 {
17884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17885 }
17886 {
17887 if (temp2)
17888 delete arg2;
17889 }
17890 return resultobj;
17891 fail:
17892 {
17893 if (temp2)
17894 delete arg2;
17895 }
17896 return NULL;
17897 }
17898
17899
17900 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17901 PyObject *resultobj;
17902 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17903 bool arg2 = (bool) false ;
17904 bool result;
17905 PyObject * obj0 = 0 ;
17906 PyObject * obj1 = 0 ;
17907 char *kwnames[] = {
17908 (char *) "self",(char *) "currentOnly", NULL
17909 };
17910
17911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17913 if (SWIG_arg_fail(1)) SWIG_fail;
17914 if (obj1) {
17915 {
17916 arg2 = (bool)(SWIG_As_bool(obj1));
17917 if (SWIG_arg_fail(2)) SWIG_fail;
17918 }
17919 }
17920 {
17921 PyThreadState* __tstate = wxPyBeginAllowThreads();
17922 result = (bool)(arg1)->Flush(arg2);
17923
17924 wxPyEndAllowThreads(__tstate);
17925 if (PyErr_Occurred()) SWIG_fail;
17926 }
17927 {
17928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17929 }
17930 return resultobj;
17931 fail:
17932 return NULL;
17933 }
17934
17935
17936 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17937 PyObject *resultobj;
17938 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17939 wxString *arg2 = 0 ;
17940 wxString *arg3 = 0 ;
17941 bool result;
17942 bool temp2 = false ;
17943 bool temp3 = false ;
17944 PyObject * obj0 = 0 ;
17945 PyObject * obj1 = 0 ;
17946 PyObject * obj2 = 0 ;
17947 char *kwnames[] = {
17948 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17949 };
17950
17951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17953 if (SWIG_arg_fail(1)) SWIG_fail;
17954 {
17955 arg2 = wxString_in_helper(obj1);
17956 if (arg2 == NULL) SWIG_fail;
17957 temp2 = true;
17958 }
17959 {
17960 arg3 = wxString_in_helper(obj2);
17961 if (arg3 == NULL) SWIG_fail;
17962 temp3 = true;
17963 }
17964 {
17965 PyThreadState* __tstate = wxPyBeginAllowThreads();
17966 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17967
17968 wxPyEndAllowThreads(__tstate);
17969 if (PyErr_Occurred()) SWIG_fail;
17970 }
17971 {
17972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17973 }
17974 {
17975 if (temp2)
17976 delete arg2;
17977 }
17978 {
17979 if (temp3)
17980 delete arg3;
17981 }
17982 return resultobj;
17983 fail:
17984 {
17985 if (temp2)
17986 delete arg2;
17987 }
17988 {
17989 if (temp3)
17990 delete arg3;
17991 }
17992 return NULL;
17993 }
17994
17995
17996 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17997 PyObject *resultobj;
17998 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17999 wxString *arg2 = 0 ;
18000 wxString *arg3 = 0 ;
18001 bool result;
18002 bool temp2 = false ;
18003 bool temp3 = false ;
18004 PyObject * obj0 = 0 ;
18005 PyObject * obj1 = 0 ;
18006 PyObject * obj2 = 0 ;
18007 char *kwnames[] = {
18008 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18009 };
18010
18011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
18012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18013 if (SWIG_arg_fail(1)) SWIG_fail;
18014 {
18015 arg2 = wxString_in_helper(obj1);
18016 if (arg2 == NULL) SWIG_fail;
18017 temp2 = true;
18018 }
18019 {
18020 arg3 = wxString_in_helper(obj2);
18021 if (arg3 == NULL) SWIG_fail;
18022 temp3 = true;
18023 }
18024 {
18025 PyThreadState* __tstate = wxPyBeginAllowThreads();
18026 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18027
18028 wxPyEndAllowThreads(__tstate);
18029 if (PyErr_Occurred()) SWIG_fail;
18030 }
18031 {
18032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18033 }
18034 {
18035 if (temp2)
18036 delete arg2;
18037 }
18038 {
18039 if (temp3)
18040 delete arg3;
18041 }
18042 return resultobj;
18043 fail:
18044 {
18045 if (temp2)
18046 delete arg2;
18047 }
18048 {
18049 if (temp3)
18050 delete arg3;
18051 }
18052 return NULL;
18053 }
18054
18055
18056 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18057 PyObject *resultobj;
18058 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18059 wxString *arg2 = 0 ;
18060 bool arg3 = (bool) true ;
18061 bool result;
18062 bool temp2 = false ;
18063 PyObject * obj0 = 0 ;
18064 PyObject * obj1 = 0 ;
18065 PyObject * obj2 = 0 ;
18066 char *kwnames[] = {
18067 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18068 };
18069
18070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18072 if (SWIG_arg_fail(1)) SWIG_fail;
18073 {
18074 arg2 = wxString_in_helper(obj1);
18075 if (arg2 == NULL) SWIG_fail;
18076 temp2 = true;
18077 }
18078 if (obj2) {
18079 {
18080 arg3 = (bool)(SWIG_As_bool(obj2));
18081 if (SWIG_arg_fail(3)) SWIG_fail;
18082 }
18083 }
18084 {
18085 PyThreadState* __tstate = wxPyBeginAllowThreads();
18086 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18087
18088 wxPyEndAllowThreads(__tstate);
18089 if (PyErr_Occurred()) SWIG_fail;
18090 }
18091 {
18092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18093 }
18094 {
18095 if (temp2)
18096 delete arg2;
18097 }
18098 return resultobj;
18099 fail:
18100 {
18101 if (temp2)
18102 delete arg2;
18103 }
18104 return NULL;
18105 }
18106
18107
18108 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18109 PyObject *resultobj;
18110 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18111 wxString *arg2 = 0 ;
18112 bool result;
18113 bool temp2 = false ;
18114 PyObject * obj0 = 0 ;
18115 PyObject * obj1 = 0 ;
18116 char *kwnames[] = {
18117 (char *) "self",(char *) "key", NULL
18118 };
18119
18120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18122 if (SWIG_arg_fail(1)) SWIG_fail;
18123 {
18124 arg2 = wxString_in_helper(obj1);
18125 if (arg2 == NULL) SWIG_fail;
18126 temp2 = true;
18127 }
18128 {
18129 PyThreadState* __tstate = wxPyBeginAllowThreads();
18130 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18131
18132 wxPyEndAllowThreads(__tstate);
18133 if (PyErr_Occurred()) SWIG_fail;
18134 }
18135 {
18136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18137 }
18138 {
18139 if (temp2)
18140 delete arg2;
18141 }
18142 return resultobj;
18143 fail:
18144 {
18145 if (temp2)
18146 delete arg2;
18147 }
18148 return NULL;
18149 }
18150
18151
18152 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18153 PyObject *resultobj;
18154 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18155 bool result;
18156 PyObject * obj0 = 0 ;
18157 char *kwnames[] = {
18158 (char *) "self", NULL
18159 };
18160
18161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18163 if (SWIG_arg_fail(1)) SWIG_fail;
18164 {
18165 PyThreadState* __tstate = wxPyBeginAllowThreads();
18166 result = (bool)(arg1)->DeleteAll();
18167
18168 wxPyEndAllowThreads(__tstate);
18169 if (PyErr_Occurred()) SWIG_fail;
18170 }
18171 {
18172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18173 }
18174 return resultobj;
18175 fail:
18176 return NULL;
18177 }
18178
18179
18180 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18181 PyObject *resultobj;
18182 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18183 bool arg2 = (bool) true ;
18184 PyObject * obj0 = 0 ;
18185 PyObject * obj1 = 0 ;
18186 char *kwnames[] = {
18187 (char *) "self",(char *) "doIt", NULL
18188 };
18189
18190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18192 if (SWIG_arg_fail(1)) SWIG_fail;
18193 if (obj1) {
18194 {
18195 arg2 = (bool)(SWIG_As_bool(obj1));
18196 if (SWIG_arg_fail(2)) SWIG_fail;
18197 }
18198 }
18199 {
18200 PyThreadState* __tstate = wxPyBeginAllowThreads();
18201 (arg1)->SetExpandEnvVars(arg2);
18202
18203 wxPyEndAllowThreads(__tstate);
18204 if (PyErr_Occurred()) SWIG_fail;
18205 }
18206 Py_INCREF(Py_None); resultobj = Py_None;
18207 return resultobj;
18208 fail:
18209 return NULL;
18210 }
18211
18212
18213 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18214 PyObject *resultobj;
18215 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18216 bool result;
18217 PyObject * obj0 = 0 ;
18218 char *kwnames[] = {
18219 (char *) "self", NULL
18220 };
18221
18222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18224 if (SWIG_arg_fail(1)) SWIG_fail;
18225 {
18226 PyThreadState* __tstate = wxPyBeginAllowThreads();
18227 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18228
18229 wxPyEndAllowThreads(__tstate);
18230 if (PyErr_Occurred()) SWIG_fail;
18231 }
18232 {
18233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18234 }
18235 return resultobj;
18236 fail:
18237 return NULL;
18238 }
18239
18240
18241 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18242 PyObject *resultobj;
18243 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18244 bool arg2 = (bool) true ;
18245 PyObject * obj0 = 0 ;
18246 PyObject * obj1 = 0 ;
18247 char *kwnames[] = {
18248 (char *) "self",(char *) "doIt", NULL
18249 };
18250
18251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18253 if (SWIG_arg_fail(1)) SWIG_fail;
18254 if (obj1) {
18255 {
18256 arg2 = (bool)(SWIG_As_bool(obj1));
18257 if (SWIG_arg_fail(2)) SWIG_fail;
18258 }
18259 }
18260 {
18261 PyThreadState* __tstate = wxPyBeginAllowThreads();
18262 (arg1)->SetRecordDefaults(arg2);
18263
18264 wxPyEndAllowThreads(__tstate);
18265 if (PyErr_Occurred()) SWIG_fail;
18266 }
18267 Py_INCREF(Py_None); resultobj = Py_None;
18268 return resultobj;
18269 fail:
18270 return NULL;
18271 }
18272
18273
18274 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18275 PyObject *resultobj;
18276 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18277 bool result;
18278 PyObject * obj0 = 0 ;
18279 char *kwnames[] = {
18280 (char *) "self", NULL
18281 };
18282
18283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18285 if (SWIG_arg_fail(1)) SWIG_fail;
18286 {
18287 PyThreadState* __tstate = wxPyBeginAllowThreads();
18288 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18289
18290 wxPyEndAllowThreads(__tstate);
18291 if (PyErr_Occurred()) SWIG_fail;
18292 }
18293 {
18294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18295 }
18296 return resultobj;
18297 fail:
18298 return NULL;
18299 }
18300
18301
18302 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18303 PyObject *resultobj;
18304 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18305 wxString *arg2 = 0 ;
18306 wxString result;
18307 bool temp2 = false ;
18308 PyObject * obj0 = 0 ;
18309 PyObject * obj1 = 0 ;
18310 char *kwnames[] = {
18311 (char *) "self",(char *) "str", NULL
18312 };
18313
18314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18316 if (SWIG_arg_fail(1)) SWIG_fail;
18317 {
18318 arg2 = wxString_in_helper(obj1);
18319 if (arg2 == NULL) SWIG_fail;
18320 temp2 = true;
18321 }
18322 {
18323 PyThreadState* __tstate = wxPyBeginAllowThreads();
18324 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18325
18326 wxPyEndAllowThreads(__tstate);
18327 if (PyErr_Occurred()) SWIG_fail;
18328 }
18329 {
18330 #if wxUSE_UNICODE
18331 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18332 #else
18333 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18334 #endif
18335 }
18336 {
18337 if (temp2)
18338 delete arg2;
18339 }
18340 return resultobj;
18341 fail:
18342 {
18343 if (temp2)
18344 delete arg2;
18345 }
18346 return NULL;
18347 }
18348
18349
18350 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18351 PyObject *resultobj;
18352 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18353 wxString result;
18354 PyObject * obj0 = 0 ;
18355 char *kwnames[] = {
18356 (char *) "self", NULL
18357 };
18358
18359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18361 if (SWIG_arg_fail(1)) SWIG_fail;
18362 {
18363 PyThreadState* __tstate = wxPyBeginAllowThreads();
18364 result = ((wxConfigBase const *)arg1)->GetAppName();
18365
18366 wxPyEndAllowThreads(__tstate);
18367 if (PyErr_Occurred()) SWIG_fail;
18368 }
18369 {
18370 #if wxUSE_UNICODE
18371 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18372 #else
18373 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18374 #endif
18375 }
18376 return resultobj;
18377 fail:
18378 return NULL;
18379 }
18380
18381
18382 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18383 PyObject *resultobj;
18384 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18385 wxString result;
18386 PyObject * obj0 = 0 ;
18387 char *kwnames[] = {
18388 (char *) "self", NULL
18389 };
18390
18391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18393 if (SWIG_arg_fail(1)) SWIG_fail;
18394 {
18395 PyThreadState* __tstate = wxPyBeginAllowThreads();
18396 result = ((wxConfigBase const *)arg1)->GetVendorName();
18397
18398 wxPyEndAllowThreads(__tstate);
18399 if (PyErr_Occurred()) SWIG_fail;
18400 }
18401 {
18402 #if wxUSE_UNICODE
18403 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18404 #else
18405 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18406 #endif
18407 }
18408 return resultobj;
18409 fail:
18410 return NULL;
18411 }
18412
18413
18414 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18415 PyObject *resultobj;
18416 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18417 wxString *arg2 = 0 ;
18418 bool temp2 = false ;
18419 PyObject * obj0 = 0 ;
18420 PyObject * obj1 = 0 ;
18421 char *kwnames[] = {
18422 (char *) "self",(char *) "appName", NULL
18423 };
18424
18425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18427 if (SWIG_arg_fail(1)) SWIG_fail;
18428 {
18429 arg2 = wxString_in_helper(obj1);
18430 if (arg2 == NULL) SWIG_fail;
18431 temp2 = true;
18432 }
18433 {
18434 PyThreadState* __tstate = wxPyBeginAllowThreads();
18435 (arg1)->SetAppName((wxString const &)*arg2);
18436
18437 wxPyEndAllowThreads(__tstate);
18438 if (PyErr_Occurred()) SWIG_fail;
18439 }
18440 Py_INCREF(Py_None); resultobj = Py_None;
18441 {
18442 if (temp2)
18443 delete arg2;
18444 }
18445 return resultobj;
18446 fail:
18447 {
18448 if (temp2)
18449 delete arg2;
18450 }
18451 return NULL;
18452 }
18453
18454
18455 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18456 PyObject *resultobj;
18457 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18458 wxString *arg2 = 0 ;
18459 bool temp2 = false ;
18460 PyObject * obj0 = 0 ;
18461 PyObject * obj1 = 0 ;
18462 char *kwnames[] = {
18463 (char *) "self",(char *) "vendorName", NULL
18464 };
18465
18466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18468 if (SWIG_arg_fail(1)) SWIG_fail;
18469 {
18470 arg2 = wxString_in_helper(obj1);
18471 if (arg2 == NULL) SWIG_fail;
18472 temp2 = true;
18473 }
18474 {
18475 PyThreadState* __tstate = wxPyBeginAllowThreads();
18476 (arg1)->SetVendorName((wxString const &)*arg2);
18477
18478 wxPyEndAllowThreads(__tstate);
18479 if (PyErr_Occurred()) SWIG_fail;
18480 }
18481 Py_INCREF(Py_None); resultobj = Py_None;
18482 {
18483 if (temp2)
18484 delete arg2;
18485 }
18486 return resultobj;
18487 fail:
18488 {
18489 if (temp2)
18490 delete arg2;
18491 }
18492 return NULL;
18493 }
18494
18495
18496 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18497 PyObject *resultobj;
18498 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18499 long arg2 ;
18500 PyObject * obj0 = 0 ;
18501 PyObject * obj1 = 0 ;
18502 char *kwnames[] = {
18503 (char *) "self",(char *) "style", NULL
18504 };
18505
18506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18508 if (SWIG_arg_fail(1)) SWIG_fail;
18509 {
18510 arg2 = (long)(SWIG_As_long(obj1));
18511 if (SWIG_arg_fail(2)) SWIG_fail;
18512 }
18513 {
18514 PyThreadState* __tstate = wxPyBeginAllowThreads();
18515 (arg1)->SetStyle(arg2);
18516
18517 wxPyEndAllowThreads(__tstate);
18518 if (PyErr_Occurred()) SWIG_fail;
18519 }
18520 Py_INCREF(Py_None); resultobj = Py_None;
18521 return resultobj;
18522 fail:
18523 return NULL;
18524 }
18525
18526
18527 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18528 PyObject *resultobj;
18529 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18530 long result;
18531 PyObject * obj0 = 0 ;
18532 char *kwnames[] = {
18533 (char *) "self", NULL
18534 };
18535
18536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18538 if (SWIG_arg_fail(1)) SWIG_fail;
18539 {
18540 PyThreadState* __tstate = wxPyBeginAllowThreads();
18541 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18542
18543 wxPyEndAllowThreads(__tstate);
18544 if (PyErr_Occurred()) SWIG_fail;
18545 }
18546 {
18547 resultobj = SWIG_From_long((long)(result));
18548 }
18549 return resultobj;
18550 fail:
18551 return NULL;
18552 }
18553
18554
18555 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18556 PyObject *obj;
18557 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18558 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18559 Py_INCREF(obj);
18560 return Py_BuildValue((char *)"");
18561 }
18562 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18563 PyObject *resultobj;
18564 wxString const &arg1_defvalue = wxPyEmptyString ;
18565 wxString *arg1 = (wxString *) &arg1_defvalue ;
18566 wxString const &arg2_defvalue = wxPyEmptyString ;
18567 wxString *arg2 = (wxString *) &arg2_defvalue ;
18568 wxString const &arg3_defvalue = wxPyEmptyString ;
18569 wxString *arg3 = (wxString *) &arg3_defvalue ;
18570 wxString const &arg4_defvalue = wxPyEmptyString ;
18571 wxString *arg4 = (wxString *) &arg4_defvalue ;
18572 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18573 wxConfig *result;
18574 bool temp1 = false ;
18575 bool temp2 = false ;
18576 bool temp3 = false ;
18577 bool temp4 = false ;
18578 PyObject * obj0 = 0 ;
18579 PyObject * obj1 = 0 ;
18580 PyObject * obj2 = 0 ;
18581 PyObject * obj3 = 0 ;
18582 PyObject * obj4 = 0 ;
18583 char *kwnames[] = {
18584 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18585 };
18586
18587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18588 if (obj0) {
18589 {
18590 arg1 = wxString_in_helper(obj0);
18591 if (arg1 == NULL) SWIG_fail;
18592 temp1 = true;
18593 }
18594 }
18595 if (obj1) {
18596 {
18597 arg2 = wxString_in_helper(obj1);
18598 if (arg2 == NULL) SWIG_fail;
18599 temp2 = true;
18600 }
18601 }
18602 if (obj2) {
18603 {
18604 arg3 = wxString_in_helper(obj2);
18605 if (arg3 == NULL) SWIG_fail;
18606 temp3 = true;
18607 }
18608 }
18609 if (obj3) {
18610 {
18611 arg4 = wxString_in_helper(obj3);
18612 if (arg4 == NULL) SWIG_fail;
18613 temp4 = true;
18614 }
18615 }
18616 if (obj4) {
18617 {
18618 arg5 = (long)(SWIG_As_long(obj4));
18619 if (SWIG_arg_fail(5)) SWIG_fail;
18620 }
18621 }
18622 {
18623 PyThreadState* __tstate = wxPyBeginAllowThreads();
18624 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18625
18626 wxPyEndAllowThreads(__tstate);
18627 if (PyErr_Occurred()) SWIG_fail;
18628 }
18629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18630 {
18631 if (temp1)
18632 delete arg1;
18633 }
18634 {
18635 if (temp2)
18636 delete arg2;
18637 }
18638 {
18639 if (temp3)
18640 delete arg3;
18641 }
18642 {
18643 if (temp4)
18644 delete arg4;
18645 }
18646 return resultobj;
18647 fail:
18648 {
18649 if (temp1)
18650 delete arg1;
18651 }
18652 {
18653 if (temp2)
18654 delete arg2;
18655 }
18656 {
18657 if (temp3)
18658 delete arg3;
18659 }
18660 {
18661 if (temp4)
18662 delete arg4;
18663 }
18664 return NULL;
18665 }
18666
18667
18668 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18669 PyObject *resultobj;
18670 wxConfig *arg1 = (wxConfig *) 0 ;
18671 PyObject * obj0 = 0 ;
18672 char *kwnames[] = {
18673 (char *) "self", NULL
18674 };
18675
18676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18678 if (SWIG_arg_fail(1)) SWIG_fail;
18679 {
18680 PyThreadState* __tstate = wxPyBeginAllowThreads();
18681 delete arg1;
18682
18683 wxPyEndAllowThreads(__tstate);
18684 if (PyErr_Occurred()) SWIG_fail;
18685 }
18686 Py_INCREF(Py_None); resultobj = Py_None;
18687 return resultobj;
18688 fail:
18689 return NULL;
18690 }
18691
18692
18693 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18694 PyObject *obj;
18695 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18696 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18697 Py_INCREF(obj);
18698 return Py_BuildValue((char *)"");
18699 }
18700 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18701 PyObject *resultobj;
18702 wxString const &arg1_defvalue = wxPyEmptyString ;
18703 wxString *arg1 = (wxString *) &arg1_defvalue ;
18704 wxString const &arg2_defvalue = wxPyEmptyString ;
18705 wxString *arg2 = (wxString *) &arg2_defvalue ;
18706 wxString const &arg3_defvalue = wxPyEmptyString ;
18707 wxString *arg3 = (wxString *) &arg3_defvalue ;
18708 wxString const &arg4_defvalue = wxPyEmptyString ;
18709 wxString *arg4 = (wxString *) &arg4_defvalue ;
18710 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18711 wxFileConfig *result;
18712 bool temp1 = false ;
18713 bool temp2 = false ;
18714 bool temp3 = false ;
18715 bool temp4 = false ;
18716 PyObject * obj0 = 0 ;
18717 PyObject * obj1 = 0 ;
18718 PyObject * obj2 = 0 ;
18719 PyObject * obj3 = 0 ;
18720 PyObject * obj4 = 0 ;
18721 char *kwnames[] = {
18722 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18723 };
18724
18725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18726 if (obj0) {
18727 {
18728 arg1 = wxString_in_helper(obj0);
18729 if (arg1 == NULL) SWIG_fail;
18730 temp1 = true;
18731 }
18732 }
18733 if (obj1) {
18734 {
18735 arg2 = wxString_in_helper(obj1);
18736 if (arg2 == NULL) SWIG_fail;
18737 temp2 = true;
18738 }
18739 }
18740 if (obj2) {
18741 {
18742 arg3 = wxString_in_helper(obj2);
18743 if (arg3 == NULL) SWIG_fail;
18744 temp3 = true;
18745 }
18746 }
18747 if (obj3) {
18748 {
18749 arg4 = wxString_in_helper(obj3);
18750 if (arg4 == NULL) SWIG_fail;
18751 temp4 = true;
18752 }
18753 }
18754 if (obj4) {
18755 {
18756 arg5 = (long)(SWIG_As_long(obj4));
18757 if (SWIG_arg_fail(5)) SWIG_fail;
18758 }
18759 }
18760 {
18761 PyThreadState* __tstate = wxPyBeginAllowThreads();
18762 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18763
18764 wxPyEndAllowThreads(__tstate);
18765 if (PyErr_Occurred()) SWIG_fail;
18766 }
18767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18768 {
18769 if (temp1)
18770 delete arg1;
18771 }
18772 {
18773 if (temp2)
18774 delete arg2;
18775 }
18776 {
18777 if (temp3)
18778 delete arg3;
18779 }
18780 {
18781 if (temp4)
18782 delete arg4;
18783 }
18784 return resultobj;
18785 fail:
18786 {
18787 if (temp1)
18788 delete arg1;
18789 }
18790 {
18791 if (temp2)
18792 delete arg2;
18793 }
18794 {
18795 if (temp3)
18796 delete arg3;
18797 }
18798 {
18799 if (temp4)
18800 delete arg4;
18801 }
18802 return NULL;
18803 }
18804
18805
18806 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18807 PyObject *resultobj;
18808 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18809 PyObject * obj0 = 0 ;
18810 char *kwnames[] = {
18811 (char *) "self", NULL
18812 };
18813
18814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18816 if (SWIG_arg_fail(1)) SWIG_fail;
18817 {
18818 PyThreadState* __tstate = wxPyBeginAllowThreads();
18819 delete arg1;
18820
18821 wxPyEndAllowThreads(__tstate);
18822 if (PyErr_Occurred()) SWIG_fail;
18823 }
18824 Py_INCREF(Py_None); resultobj = Py_None;
18825 return resultobj;
18826 fail:
18827 return NULL;
18828 }
18829
18830
18831 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18832 PyObject *obj;
18833 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18834 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18835 Py_INCREF(obj);
18836 return Py_BuildValue((char *)"");
18837 }
18838 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18839 PyObject *resultobj;
18840 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18841 wxString *arg2 = 0 ;
18842 wxConfigPathChanger *result;
18843 bool temp2 = false ;
18844 PyObject * obj0 = 0 ;
18845 PyObject * obj1 = 0 ;
18846 char *kwnames[] = {
18847 (char *) "config",(char *) "entry", NULL
18848 };
18849
18850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18852 if (SWIG_arg_fail(1)) SWIG_fail;
18853 {
18854 arg2 = wxString_in_helper(obj1);
18855 if (arg2 == NULL) SWIG_fail;
18856 temp2 = true;
18857 }
18858 {
18859 PyThreadState* __tstate = wxPyBeginAllowThreads();
18860 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18861
18862 wxPyEndAllowThreads(__tstate);
18863 if (PyErr_Occurred()) SWIG_fail;
18864 }
18865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18866 {
18867 if (temp2)
18868 delete arg2;
18869 }
18870 return resultobj;
18871 fail:
18872 {
18873 if (temp2)
18874 delete arg2;
18875 }
18876 return NULL;
18877 }
18878
18879
18880 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18881 PyObject *resultobj;
18882 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18883 PyObject * obj0 = 0 ;
18884 char *kwnames[] = {
18885 (char *) "self", NULL
18886 };
18887
18888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18890 if (SWIG_arg_fail(1)) SWIG_fail;
18891 {
18892 PyThreadState* __tstate = wxPyBeginAllowThreads();
18893 delete arg1;
18894
18895 wxPyEndAllowThreads(__tstate);
18896 if (PyErr_Occurred()) SWIG_fail;
18897 }
18898 Py_INCREF(Py_None); resultobj = Py_None;
18899 return resultobj;
18900 fail:
18901 return NULL;
18902 }
18903
18904
18905 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18906 PyObject *resultobj;
18907 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18908 wxString *result;
18909 PyObject * obj0 = 0 ;
18910 char *kwnames[] = {
18911 (char *) "self", NULL
18912 };
18913
18914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18916 if (SWIG_arg_fail(1)) SWIG_fail;
18917 {
18918 PyThreadState* __tstate = wxPyBeginAllowThreads();
18919 {
18920 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18921 result = (wxString *) &_result_ref;
18922 }
18923
18924 wxPyEndAllowThreads(__tstate);
18925 if (PyErr_Occurred()) SWIG_fail;
18926 }
18927 {
18928 #if wxUSE_UNICODE
18929 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18930 #else
18931 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18932 #endif
18933 }
18934 return resultobj;
18935 fail:
18936 return NULL;
18937 }
18938
18939
18940 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18941 PyObject *obj;
18942 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18943 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18944 Py_INCREF(obj);
18945 return Py_BuildValue((char *)"");
18946 }
18947 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18948 PyObject *resultobj;
18949 wxString *arg1 = 0 ;
18950 wxString result;
18951 bool temp1 = false ;
18952 PyObject * obj0 = 0 ;
18953 char *kwnames[] = {
18954 (char *) "sz", NULL
18955 };
18956
18957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18958 {
18959 arg1 = wxString_in_helper(obj0);
18960 if (arg1 == NULL) SWIG_fail;
18961 temp1 = true;
18962 }
18963 {
18964 PyThreadState* __tstate = wxPyBeginAllowThreads();
18965 result = wxExpandEnvVars((wxString const &)*arg1);
18966
18967 wxPyEndAllowThreads(__tstate);
18968 if (PyErr_Occurred()) SWIG_fail;
18969 }
18970 {
18971 #if wxUSE_UNICODE
18972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18973 #else
18974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18975 #endif
18976 }
18977 {
18978 if (temp1)
18979 delete arg1;
18980 }
18981 return resultobj;
18982 fail:
18983 {
18984 if (temp1)
18985 delete arg1;
18986 }
18987 return NULL;
18988 }
18989
18990
18991 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18992 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18993 return 1;
18994 }
18995
18996
18997 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18998 PyObject *pyobj;
18999
19000 {
19001 #if wxUSE_UNICODE
19002 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19003 #else
19004 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19005 #endif
19006 }
19007 return pyobj;
19008 }
19009
19010
19011 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19012 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19013 return 1;
19014 }
19015
19016
19017 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19018 PyObject *pyobj;
19019
19020 {
19021 #if wxUSE_UNICODE
19022 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19023 #else
19024 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19025 #endif
19026 }
19027 return pyobj;
19028 }
19029
19030
19031 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19032 PyObject *resultobj;
19033 wxDateTime::Country arg1 ;
19034 PyObject * obj0 = 0 ;
19035 char *kwnames[] = {
19036 (char *) "country", NULL
19037 };
19038
19039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19040 {
19041 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19042 if (SWIG_arg_fail(1)) SWIG_fail;
19043 }
19044 {
19045 PyThreadState* __tstate = wxPyBeginAllowThreads();
19046 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19047
19048 wxPyEndAllowThreads(__tstate);
19049 if (PyErr_Occurred()) SWIG_fail;
19050 }
19051 Py_INCREF(Py_None); resultobj = Py_None;
19052 return resultobj;
19053 fail:
19054 return NULL;
19055 }
19056
19057
19058 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19059 PyObject *resultobj;
19060 wxDateTime::Country result;
19061 char *kwnames[] = {
19062 NULL
19063 };
19064
19065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19066 {
19067 PyThreadState* __tstate = wxPyBeginAllowThreads();
19068 result = (wxDateTime::Country)wxDateTime::GetCountry();
19069
19070 wxPyEndAllowThreads(__tstate);
19071 if (PyErr_Occurred()) SWIG_fail;
19072 }
19073 resultobj = SWIG_From_int((result));
19074 return resultobj;
19075 fail:
19076 return NULL;
19077 }
19078
19079
19080 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19081 PyObject *resultobj;
19082 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19083 bool result;
19084 PyObject * obj0 = 0 ;
19085 char *kwnames[] = {
19086 (char *) "country", NULL
19087 };
19088
19089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19090 if (obj0) {
19091 {
19092 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19093 if (SWIG_arg_fail(1)) SWIG_fail;
19094 }
19095 }
19096 {
19097 PyThreadState* __tstate = wxPyBeginAllowThreads();
19098 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19099
19100 wxPyEndAllowThreads(__tstate);
19101 if (PyErr_Occurred()) SWIG_fail;
19102 }
19103 {
19104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19105 }
19106 return resultobj;
19107 fail:
19108 return NULL;
19109 }
19110
19111
19112 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19113 PyObject *resultobj;
19114 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19115 int result;
19116 PyObject * obj0 = 0 ;
19117 char *kwnames[] = {
19118 (char *) "cal", NULL
19119 };
19120
19121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19122 if (obj0) {
19123 {
19124 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19125 if (SWIG_arg_fail(1)) SWIG_fail;
19126 }
19127 }
19128 {
19129 PyThreadState* __tstate = wxPyBeginAllowThreads();
19130 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19131
19132 wxPyEndAllowThreads(__tstate);
19133 if (PyErr_Occurred()) SWIG_fail;
19134 }
19135 {
19136 resultobj = SWIG_From_int((int)(result));
19137 }
19138 return resultobj;
19139 fail:
19140 return NULL;
19141 }
19142
19143
19144 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19145 PyObject *resultobj;
19146 int arg1 ;
19147 int result;
19148 PyObject * obj0 = 0 ;
19149 char *kwnames[] = {
19150 (char *) "year", NULL
19151 };
19152
19153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19154 {
19155 arg1 = (int)(SWIG_As_int(obj0));
19156 if (SWIG_arg_fail(1)) SWIG_fail;
19157 }
19158 {
19159 PyThreadState* __tstate = wxPyBeginAllowThreads();
19160 result = (int)wxDateTime::ConvertYearToBC(arg1);
19161
19162 wxPyEndAllowThreads(__tstate);
19163 if (PyErr_Occurred()) SWIG_fail;
19164 }
19165 {
19166 resultobj = SWIG_From_int((int)(result));
19167 }
19168 return resultobj;
19169 fail:
19170 return NULL;
19171 }
19172
19173
19174 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19175 PyObject *resultobj;
19176 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19177 wxDateTime::Month result;
19178 PyObject * obj0 = 0 ;
19179 char *kwnames[] = {
19180 (char *) "cal", NULL
19181 };
19182
19183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19184 if (obj0) {
19185 {
19186 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19187 if (SWIG_arg_fail(1)) SWIG_fail;
19188 }
19189 }
19190 {
19191 PyThreadState* __tstate = wxPyBeginAllowThreads();
19192 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19193
19194 wxPyEndAllowThreads(__tstate);
19195 if (PyErr_Occurred()) SWIG_fail;
19196 }
19197 resultobj = SWIG_From_int((result));
19198 return resultobj;
19199 fail:
19200 return NULL;
19201 }
19202
19203
19204 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19205 PyObject *resultobj;
19206 int arg1 = (int) wxDateTime::Inv_Year ;
19207 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19208 bool result;
19209 PyObject * obj0 = 0 ;
19210 PyObject * obj1 = 0 ;
19211 char *kwnames[] = {
19212 (char *) "year",(char *) "cal", NULL
19213 };
19214
19215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19216 if (obj0) {
19217 {
19218 arg1 = (int)(SWIG_As_int(obj0));
19219 if (SWIG_arg_fail(1)) SWIG_fail;
19220 }
19221 }
19222 if (obj1) {
19223 {
19224 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19225 if (SWIG_arg_fail(2)) SWIG_fail;
19226 }
19227 }
19228 {
19229 PyThreadState* __tstate = wxPyBeginAllowThreads();
19230 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19231
19232 wxPyEndAllowThreads(__tstate);
19233 if (PyErr_Occurred()) SWIG_fail;
19234 }
19235 {
19236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19237 }
19238 return resultobj;
19239 fail:
19240 return NULL;
19241 }
19242
19243
19244 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19245 PyObject *resultobj;
19246 int arg1 = (int) wxDateTime::Inv_Year ;
19247 int result;
19248 PyObject * obj0 = 0 ;
19249 char *kwnames[] = {
19250 (char *) "year", NULL
19251 };
19252
19253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19254 if (obj0) {
19255 {
19256 arg1 = (int)(SWIG_As_int(obj0));
19257 if (SWIG_arg_fail(1)) SWIG_fail;
19258 }
19259 }
19260 {
19261 PyThreadState* __tstate = wxPyBeginAllowThreads();
19262 result = (int)wxDateTime::GetCentury(arg1);
19263
19264 wxPyEndAllowThreads(__tstate);
19265 if (PyErr_Occurred()) SWIG_fail;
19266 }
19267 {
19268 resultobj = SWIG_From_int((int)(result));
19269 }
19270 return resultobj;
19271 fail:
19272 return NULL;
19273 }
19274
19275
19276 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19277 PyObject *resultobj;
19278 int arg1 ;
19279 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19280 int result;
19281 PyObject * obj0 = 0 ;
19282 PyObject * obj1 = 0 ;
19283 char *kwnames[] = {
19284 (char *) "year",(char *) "cal", NULL
19285 };
19286
19287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19288 {
19289 arg1 = (int)(SWIG_As_int(obj0));
19290 if (SWIG_arg_fail(1)) SWIG_fail;
19291 }
19292 if (obj1) {
19293 {
19294 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19295 if (SWIG_arg_fail(2)) SWIG_fail;
19296 }
19297 }
19298 {
19299 PyThreadState* __tstate = wxPyBeginAllowThreads();
19300 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19301
19302 wxPyEndAllowThreads(__tstate);
19303 if (PyErr_Occurred()) SWIG_fail;
19304 }
19305 {
19306 resultobj = SWIG_From_int((int)(result));
19307 }
19308 return resultobj;
19309 fail:
19310 return NULL;
19311 }
19312
19313
19314 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19315 PyObject *resultobj;
19316 wxDateTime::Month arg1 ;
19317 int arg2 = (int) wxDateTime::Inv_Year ;
19318 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19319 int result;
19320 PyObject * obj0 = 0 ;
19321 PyObject * obj1 = 0 ;
19322 PyObject * obj2 = 0 ;
19323 char *kwnames[] = {
19324 (char *) "month",(char *) "year",(char *) "cal", NULL
19325 };
19326
19327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19328 {
19329 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19330 if (SWIG_arg_fail(1)) SWIG_fail;
19331 }
19332 if (obj1) {
19333 {
19334 arg2 = (int)(SWIG_As_int(obj1));
19335 if (SWIG_arg_fail(2)) SWIG_fail;
19336 }
19337 }
19338 if (obj2) {
19339 {
19340 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19341 if (SWIG_arg_fail(3)) SWIG_fail;
19342 }
19343 }
19344 {
19345 PyThreadState* __tstate = wxPyBeginAllowThreads();
19346 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19347
19348 wxPyEndAllowThreads(__tstate);
19349 if (PyErr_Occurred()) SWIG_fail;
19350 }
19351 {
19352 resultobj = SWIG_From_int((int)(result));
19353 }
19354 return resultobj;
19355 fail:
19356 return NULL;
19357 }
19358
19359
19360 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19361 PyObject *resultobj;
19362 wxDateTime::Month arg1 ;
19363 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19364 wxString result;
19365 PyObject * obj0 = 0 ;
19366 PyObject * obj1 = 0 ;
19367 char *kwnames[] = {
19368 (char *) "month",(char *) "flags", NULL
19369 };
19370
19371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19372 {
19373 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19374 if (SWIG_arg_fail(1)) SWIG_fail;
19375 }
19376 if (obj1) {
19377 {
19378 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19379 if (SWIG_arg_fail(2)) SWIG_fail;
19380 }
19381 }
19382 {
19383 PyThreadState* __tstate = wxPyBeginAllowThreads();
19384 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19385
19386 wxPyEndAllowThreads(__tstate);
19387 if (PyErr_Occurred()) SWIG_fail;
19388 }
19389 {
19390 #if wxUSE_UNICODE
19391 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19392 #else
19393 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19394 #endif
19395 }
19396 return resultobj;
19397 fail:
19398 return NULL;
19399 }
19400
19401
19402 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19403 PyObject *resultobj;
19404 wxDateTime::WeekDay arg1 ;
19405 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19406 wxString result;
19407 PyObject * obj0 = 0 ;
19408 PyObject * obj1 = 0 ;
19409 char *kwnames[] = {
19410 (char *) "weekday",(char *) "flags", NULL
19411 };
19412
19413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19414 {
19415 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19416 if (SWIG_arg_fail(1)) SWIG_fail;
19417 }
19418 if (obj1) {
19419 {
19420 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19421 if (SWIG_arg_fail(2)) SWIG_fail;
19422 }
19423 }
19424 {
19425 PyThreadState* __tstate = wxPyBeginAllowThreads();
19426 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19427
19428 wxPyEndAllowThreads(__tstate);
19429 if (PyErr_Occurred()) SWIG_fail;
19430 }
19431 {
19432 #if wxUSE_UNICODE
19433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19434 #else
19435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19436 #endif
19437 }
19438 return resultobj;
19439 fail:
19440 return NULL;
19441 }
19442
19443
19444 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19445 PyObject *resultobj;
19446 PyObject *result;
19447 char *kwnames[] = {
19448 NULL
19449 };
19450
19451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19452 {
19453 PyThreadState* __tstate = wxPyBeginAllowThreads();
19454 result = (PyObject *)DateTime_GetAmPmStrings();
19455
19456 wxPyEndAllowThreads(__tstate);
19457 if (PyErr_Occurred()) SWIG_fail;
19458 }
19459 resultobj = result;
19460 return resultobj;
19461 fail:
19462 return NULL;
19463 }
19464
19465
19466 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19467 PyObject *resultobj;
19468 int arg1 = (int) wxDateTime::Inv_Year ;
19469 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19470 bool result;
19471 PyObject * obj0 = 0 ;
19472 PyObject * obj1 = 0 ;
19473 char *kwnames[] = {
19474 (char *) "year",(char *) "country", NULL
19475 };
19476
19477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19478 if (obj0) {
19479 {
19480 arg1 = (int)(SWIG_As_int(obj0));
19481 if (SWIG_arg_fail(1)) SWIG_fail;
19482 }
19483 }
19484 if (obj1) {
19485 {
19486 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19487 if (SWIG_arg_fail(2)) SWIG_fail;
19488 }
19489 }
19490 {
19491 PyThreadState* __tstate = wxPyBeginAllowThreads();
19492 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19493
19494 wxPyEndAllowThreads(__tstate);
19495 if (PyErr_Occurred()) SWIG_fail;
19496 }
19497 {
19498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19499 }
19500 return resultobj;
19501 fail:
19502 return NULL;
19503 }
19504
19505
19506 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19507 PyObject *resultobj;
19508 int arg1 = (int) wxDateTime::Inv_Year ;
19509 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19510 wxDateTime result;
19511 PyObject * obj0 = 0 ;
19512 PyObject * obj1 = 0 ;
19513 char *kwnames[] = {
19514 (char *) "year",(char *) "country", NULL
19515 };
19516
19517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19518 if (obj0) {
19519 {
19520 arg1 = (int)(SWIG_As_int(obj0));
19521 if (SWIG_arg_fail(1)) SWIG_fail;
19522 }
19523 }
19524 if (obj1) {
19525 {
19526 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19527 if (SWIG_arg_fail(2)) SWIG_fail;
19528 }
19529 }
19530 {
19531 PyThreadState* __tstate = wxPyBeginAllowThreads();
19532 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19533
19534 wxPyEndAllowThreads(__tstate);
19535 if (PyErr_Occurred()) SWIG_fail;
19536 }
19537 {
19538 wxDateTime * resultptr;
19539 resultptr = new wxDateTime((wxDateTime &)(result));
19540 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19541 }
19542 return resultobj;
19543 fail:
19544 return NULL;
19545 }
19546
19547
19548 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19549 PyObject *resultobj;
19550 int arg1 = (int) wxDateTime::Inv_Year ;
19551 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19552 wxDateTime result;
19553 PyObject * obj0 = 0 ;
19554 PyObject * obj1 = 0 ;
19555 char *kwnames[] = {
19556 (char *) "year",(char *) "country", NULL
19557 };
19558
19559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19560 if (obj0) {
19561 {
19562 arg1 = (int)(SWIG_As_int(obj0));
19563 if (SWIG_arg_fail(1)) SWIG_fail;
19564 }
19565 }
19566 if (obj1) {
19567 {
19568 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19569 if (SWIG_arg_fail(2)) SWIG_fail;
19570 }
19571 }
19572 {
19573 PyThreadState* __tstate = wxPyBeginAllowThreads();
19574 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19575
19576 wxPyEndAllowThreads(__tstate);
19577 if (PyErr_Occurred()) SWIG_fail;
19578 }
19579 {
19580 wxDateTime * resultptr;
19581 resultptr = new wxDateTime((wxDateTime &)(result));
19582 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19583 }
19584 return resultobj;
19585 fail:
19586 return NULL;
19587 }
19588
19589
19590 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19591 PyObject *resultobj;
19592 wxDateTime result;
19593 char *kwnames[] = {
19594 NULL
19595 };
19596
19597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19598 {
19599 PyThreadState* __tstate = wxPyBeginAllowThreads();
19600 result = wxDateTime::Now();
19601
19602 wxPyEndAllowThreads(__tstate);
19603 if (PyErr_Occurred()) SWIG_fail;
19604 }
19605 {
19606 wxDateTime * resultptr;
19607 resultptr = new wxDateTime((wxDateTime &)(result));
19608 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19609 }
19610 return resultobj;
19611 fail:
19612 return NULL;
19613 }
19614
19615
19616 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19617 PyObject *resultobj;
19618 wxDateTime result;
19619 char *kwnames[] = {
19620 NULL
19621 };
19622
19623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19624 {
19625 PyThreadState* __tstate = wxPyBeginAllowThreads();
19626 result = wxDateTime::UNow();
19627
19628 wxPyEndAllowThreads(__tstate);
19629 if (PyErr_Occurred()) SWIG_fail;
19630 }
19631 {
19632 wxDateTime * resultptr;
19633 resultptr = new wxDateTime((wxDateTime &)(result));
19634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19635 }
19636 return resultobj;
19637 fail:
19638 return NULL;
19639 }
19640
19641
19642 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19643 PyObject *resultobj;
19644 wxDateTime result;
19645 char *kwnames[] = {
19646 NULL
19647 };
19648
19649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19650 {
19651 PyThreadState* __tstate = wxPyBeginAllowThreads();
19652 result = wxDateTime::Today();
19653
19654 wxPyEndAllowThreads(__tstate);
19655 if (PyErr_Occurred()) SWIG_fail;
19656 }
19657 {
19658 wxDateTime * resultptr;
19659 resultptr = new wxDateTime((wxDateTime &)(result));
19660 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19661 }
19662 return resultobj;
19663 fail:
19664 return NULL;
19665 }
19666
19667
19668 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19669 PyObject *resultobj;
19670 wxDateTime *result;
19671 char *kwnames[] = {
19672 NULL
19673 };
19674
19675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19676 {
19677 PyThreadState* __tstate = wxPyBeginAllowThreads();
19678 result = (wxDateTime *)new wxDateTime();
19679
19680 wxPyEndAllowThreads(__tstate);
19681 if (PyErr_Occurred()) SWIG_fail;
19682 }
19683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19684 return resultobj;
19685 fail:
19686 return NULL;
19687 }
19688
19689
19690 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19691 PyObject *resultobj;
19692 time_t arg1 ;
19693 wxDateTime *result;
19694 PyObject * obj0 = 0 ;
19695 char *kwnames[] = {
19696 (char *) "timet", NULL
19697 };
19698
19699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19700 {
19701 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19702 if (SWIG_arg_fail(1)) SWIG_fail;
19703 }
19704 {
19705 PyThreadState* __tstate = wxPyBeginAllowThreads();
19706 result = (wxDateTime *)new wxDateTime(arg1);
19707
19708 wxPyEndAllowThreads(__tstate);
19709 if (PyErr_Occurred()) SWIG_fail;
19710 }
19711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19712 return resultobj;
19713 fail:
19714 return NULL;
19715 }
19716
19717
19718 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19719 PyObject *resultobj;
19720 double arg1 ;
19721 wxDateTime *result;
19722 PyObject * obj0 = 0 ;
19723 char *kwnames[] = {
19724 (char *) "jdn", NULL
19725 };
19726
19727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19728 {
19729 arg1 = (double)(SWIG_As_double(obj0));
19730 if (SWIG_arg_fail(1)) SWIG_fail;
19731 }
19732 {
19733 PyThreadState* __tstate = wxPyBeginAllowThreads();
19734 result = (wxDateTime *)new wxDateTime(arg1);
19735
19736 wxPyEndAllowThreads(__tstate);
19737 if (PyErr_Occurred()) SWIG_fail;
19738 }
19739 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19740 return resultobj;
19741 fail:
19742 return NULL;
19743 }
19744
19745
19746 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19747 PyObject *resultobj;
19748 int arg1 ;
19749 int arg2 = (int) 0 ;
19750 int arg3 = (int) 0 ;
19751 int arg4 = (int) 0 ;
19752 wxDateTime *result;
19753 PyObject * obj0 = 0 ;
19754 PyObject * obj1 = 0 ;
19755 PyObject * obj2 = 0 ;
19756 PyObject * obj3 = 0 ;
19757 char *kwnames[] = {
19758 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19759 };
19760
19761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19762 {
19763 arg1 = (int)(SWIG_As_int(obj0));
19764 if (SWIG_arg_fail(1)) SWIG_fail;
19765 }
19766 if (obj1) {
19767 {
19768 arg2 = (int)(SWIG_As_int(obj1));
19769 if (SWIG_arg_fail(2)) SWIG_fail;
19770 }
19771 }
19772 if (obj2) {
19773 {
19774 arg3 = (int)(SWIG_As_int(obj2));
19775 if (SWIG_arg_fail(3)) SWIG_fail;
19776 }
19777 }
19778 if (obj3) {
19779 {
19780 arg4 = (int)(SWIG_As_int(obj3));
19781 if (SWIG_arg_fail(4)) SWIG_fail;
19782 }
19783 }
19784 {
19785 PyThreadState* __tstate = wxPyBeginAllowThreads();
19786 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19787
19788 wxPyEndAllowThreads(__tstate);
19789 if (PyErr_Occurred()) SWIG_fail;
19790 }
19791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19792 return resultobj;
19793 fail:
19794 return NULL;
19795 }
19796
19797
19798 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19799 PyObject *resultobj;
19800 int arg1 ;
19801 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19802 int arg3 = (int) wxDateTime::Inv_Year ;
19803 int arg4 = (int) 0 ;
19804 int arg5 = (int) 0 ;
19805 int arg6 = (int) 0 ;
19806 int arg7 = (int) 0 ;
19807 wxDateTime *result;
19808 PyObject * obj0 = 0 ;
19809 PyObject * obj1 = 0 ;
19810 PyObject * obj2 = 0 ;
19811 PyObject * obj3 = 0 ;
19812 PyObject * obj4 = 0 ;
19813 PyObject * obj5 = 0 ;
19814 PyObject * obj6 = 0 ;
19815 char *kwnames[] = {
19816 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19817 };
19818
19819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19820 {
19821 arg1 = (int)(SWIG_As_int(obj0));
19822 if (SWIG_arg_fail(1)) SWIG_fail;
19823 }
19824 if (obj1) {
19825 {
19826 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19827 if (SWIG_arg_fail(2)) SWIG_fail;
19828 }
19829 }
19830 if (obj2) {
19831 {
19832 arg3 = (int)(SWIG_As_int(obj2));
19833 if (SWIG_arg_fail(3)) SWIG_fail;
19834 }
19835 }
19836 if (obj3) {
19837 {
19838 arg4 = (int)(SWIG_As_int(obj3));
19839 if (SWIG_arg_fail(4)) SWIG_fail;
19840 }
19841 }
19842 if (obj4) {
19843 {
19844 arg5 = (int)(SWIG_As_int(obj4));
19845 if (SWIG_arg_fail(5)) SWIG_fail;
19846 }
19847 }
19848 if (obj5) {
19849 {
19850 arg6 = (int)(SWIG_As_int(obj5));
19851 if (SWIG_arg_fail(6)) SWIG_fail;
19852 }
19853 }
19854 if (obj6) {
19855 {
19856 arg7 = (int)(SWIG_As_int(obj6));
19857 if (SWIG_arg_fail(7)) SWIG_fail;
19858 }
19859 }
19860 {
19861 PyThreadState* __tstate = wxPyBeginAllowThreads();
19862 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19863
19864 wxPyEndAllowThreads(__tstate);
19865 if (PyErr_Occurred()) SWIG_fail;
19866 }
19867 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19868 return resultobj;
19869 fail:
19870 return NULL;
19871 }
19872
19873
19874 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19875 PyObject *resultobj;
19876 wxDateTime *arg1 = (wxDateTime *) 0 ;
19877 PyObject * obj0 = 0 ;
19878 char *kwnames[] = {
19879 (char *) "self", NULL
19880 };
19881
19882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19884 if (SWIG_arg_fail(1)) SWIG_fail;
19885 {
19886 PyThreadState* __tstate = wxPyBeginAllowThreads();
19887 delete arg1;
19888
19889 wxPyEndAllowThreads(__tstate);
19890 if (PyErr_Occurred()) SWIG_fail;
19891 }
19892 Py_INCREF(Py_None); resultobj = Py_None;
19893 return resultobj;
19894 fail:
19895 return NULL;
19896 }
19897
19898
19899 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19900 PyObject *resultobj;
19901 wxDateTime *arg1 = (wxDateTime *) 0 ;
19902 wxDateTime *result;
19903 PyObject * obj0 = 0 ;
19904 char *kwnames[] = {
19905 (char *) "self", NULL
19906 };
19907
19908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19910 if (SWIG_arg_fail(1)) SWIG_fail;
19911 {
19912 PyThreadState* __tstate = wxPyBeginAllowThreads();
19913 {
19914 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19915 result = (wxDateTime *) &_result_ref;
19916 }
19917
19918 wxPyEndAllowThreads(__tstate);
19919 if (PyErr_Occurred()) SWIG_fail;
19920 }
19921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19922 return resultobj;
19923 fail:
19924 return NULL;
19925 }
19926
19927
19928 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19929 PyObject *resultobj;
19930 wxDateTime *arg1 = (wxDateTime *) 0 ;
19931 time_t arg2 ;
19932 wxDateTime *result;
19933 PyObject * obj0 = 0 ;
19934 PyObject * obj1 = 0 ;
19935 char *kwnames[] = {
19936 (char *) "self",(char *) "timet", NULL
19937 };
19938
19939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19941 if (SWIG_arg_fail(1)) SWIG_fail;
19942 {
19943 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19944 if (SWIG_arg_fail(2)) SWIG_fail;
19945 }
19946 {
19947 PyThreadState* __tstate = wxPyBeginAllowThreads();
19948 {
19949 wxDateTime &_result_ref = (arg1)->Set(arg2);
19950 result = (wxDateTime *) &_result_ref;
19951 }
19952
19953 wxPyEndAllowThreads(__tstate);
19954 if (PyErr_Occurred()) SWIG_fail;
19955 }
19956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19957 return resultobj;
19958 fail:
19959 return NULL;
19960 }
19961
19962
19963 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19964 PyObject *resultobj;
19965 wxDateTime *arg1 = (wxDateTime *) 0 ;
19966 double arg2 ;
19967 wxDateTime *result;
19968 PyObject * obj0 = 0 ;
19969 PyObject * obj1 = 0 ;
19970 char *kwnames[] = {
19971 (char *) "self",(char *) "jdn", NULL
19972 };
19973
19974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19976 if (SWIG_arg_fail(1)) SWIG_fail;
19977 {
19978 arg2 = (double)(SWIG_As_double(obj1));
19979 if (SWIG_arg_fail(2)) SWIG_fail;
19980 }
19981 {
19982 PyThreadState* __tstate = wxPyBeginAllowThreads();
19983 {
19984 wxDateTime &_result_ref = (arg1)->Set(arg2);
19985 result = (wxDateTime *) &_result_ref;
19986 }
19987
19988 wxPyEndAllowThreads(__tstate);
19989 if (PyErr_Occurred()) SWIG_fail;
19990 }
19991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19992 return resultobj;
19993 fail:
19994 return NULL;
19995 }
19996
19997
19998 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19999 PyObject *resultobj;
20000 wxDateTime *arg1 = (wxDateTime *) 0 ;
20001 int arg2 ;
20002 int arg3 = (int) 0 ;
20003 int arg4 = (int) 0 ;
20004 int arg5 = (int) 0 ;
20005 wxDateTime *result;
20006 PyObject * obj0 = 0 ;
20007 PyObject * obj1 = 0 ;
20008 PyObject * obj2 = 0 ;
20009 PyObject * obj3 = 0 ;
20010 PyObject * obj4 = 0 ;
20011 char *kwnames[] = {
20012 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20013 };
20014
20015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20017 if (SWIG_arg_fail(1)) SWIG_fail;
20018 {
20019 arg2 = (int)(SWIG_As_int(obj1));
20020 if (SWIG_arg_fail(2)) SWIG_fail;
20021 }
20022 if (obj2) {
20023 {
20024 arg3 = (int)(SWIG_As_int(obj2));
20025 if (SWIG_arg_fail(3)) SWIG_fail;
20026 }
20027 }
20028 if (obj3) {
20029 {
20030 arg4 = (int)(SWIG_As_int(obj3));
20031 if (SWIG_arg_fail(4)) SWIG_fail;
20032 }
20033 }
20034 if (obj4) {
20035 {
20036 arg5 = (int)(SWIG_As_int(obj4));
20037 if (SWIG_arg_fail(5)) SWIG_fail;
20038 }
20039 }
20040 {
20041 PyThreadState* __tstate = wxPyBeginAllowThreads();
20042 {
20043 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20044 result = (wxDateTime *) &_result_ref;
20045 }
20046
20047 wxPyEndAllowThreads(__tstate);
20048 if (PyErr_Occurred()) SWIG_fail;
20049 }
20050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20051 return resultobj;
20052 fail:
20053 return NULL;
20054 }
20055
20056
20057 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20058 PyObject *resultobj;
20059 wxDateTime *arg1 = (wxDateTime *) 0 ;
20060 int arg2 ;
20061 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20062 int arg4 = (int) wxDateTime::Inv_Year ;
20063 int arg5 = (int) 0 ;
20064 int arg6 = (int) 0 ;
20065 int arg7 = (int) 0 ;
20066 int arg8 = (int) 0 ;
20067 wxDateTime *result;
20068 PyObject * obj0 = 0 ;
20069 PyObject * obj1 = 0 ;
20070 PyObject * obj2 = 0 ;
20071 PyObject * obj3 = 0 ;
20072 PyObject * obj4 = 0 ;
20073 PyObject * obj5 = 0 ;
20074 PyObject * obj6 = 0 ;
20075 PyObject * obj7 = 0 ;
20076 char *kwnames[] = {
20077 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20078 };
20079
20080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20082 if (SWIG_arg_fail(1)) SWIG_fail;
20083 {
20084 arg2 = (int)(SWIG_As_int(obj1));
20085 if (SWIG_arg_fail(2)) SWIG_fail;
20086 }
20087 if (obj2) {
20088 {
20089 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20090 if (SWIG_arg_fail(3)) SWIG_fail;
20091 }
20092 }
20093 if (obj3) {
20094 {
20095 arg4 = (int)(SWIG_As_int(obj3));
20096 if (SWIG_arg_fail(4)) SWIG_fail;
20097 }
20098 }
20099 if (obj4) {
20100 {
20101 arg5 = (int)(SWIG_As_int(obj4));
20102 if (SWIG_arg_fail(5)) SWIG_fail;
20103 }
20104 }
20105 if (obj5) {
20106 {
20107 arg6 = (int)(SWIG_As_int(obj5));
20108 if (SWIG_arg_fail(6)) SWIG_fail;
20109 }
20110 }
20111 if (obj6) {
20112 {
20113 arg7 = (int)(SWIG_As_int(obj6));
20114 if (SWIG_arg_fail(7)) SWIG_fail;
20115 }
20116 }
20117 if (obj7) {
20118 {
20119 arg8 = (int)(SWIG_As_int(obj7));
20120 if (SWIG_arg_fail(8)) SWIG_fail;
20121 }
20122 }
20123 {
20124 PyThreadState* __tstate = wxPyBeginAllowThreads();
20125 {
20126 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20127 result = (wxDateTime *) &_result_ref;
20128 }
20129
20130 wxPyEndAllowThreads(__tstate);
20131 if (PyErr_Occurred()) SWIG_fail;
20132 }
20133 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20134 return resultobj;
20135 fail:
20136 return NULL;
20137 }
20138
20139
20140 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20141 PyObject *resultobj;
20142 wxDateTime *arg1 = (wxDateTime *) 0 ;
20143 wxDateTime *result;
20144 PyObject * obj0 = 0 ;
20145 char *kwnames[] = {
20146 (char *) "self", NULL
20147 };
20148
20149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20151 if (SWIG_arg_fail(1)) SWIG_fail;
20152 {
20153 PyThreadState* __tstate = wxPyBeginAllowThreads();
20154 {
20155 wxDateTime &_result_ref = (arg1)->ResetTime();
20156 result = (wxDateTime *) &_result_ref;
20157 }
20158
20159 wxPyEndAllowThreads(__tstate);
20160 if (PyErr_Occurred()) SWIG_fail;
20161 }
20162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20163 return resultobj;
20164 fail:
20165 return NULL;
20166 }
20167
20168
20169 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20170 PyObject *resultobj;
20171 wxDateTime *arg1 = (wxDateTime *) 0 ;
20172 int arg2 ;
20173 wxDateTime *result;
20174 PyObject * obj0 = 0 ;
20175 PyObject * obj1 = 0 ;
20176 char *kwnames[] = {
20177 (char *) "self",(char *) "year", NULL
20178 };
20179
20180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20182 if (SWIG_arg_fail(1)) SWIG_fail;
20183 {
20184 arg2 = (int)(SWIG_As_int(obj1));
20185 if (SWIG_arg_fail(2)) SWIG_fail;
20186 }
20187 {
20188 PyThreadState* __tstate = wxPyBeginAllowThreads();
20189 {
20190 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20191 result = (wxDateTime *) &_result_ref;
20192 }
20193
20194 wxPyEndAllowThreads(__tstate);
20195 if (PyErr_Occurred()) SWIG_fail;
20196 }
20197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20198 return resultobj;
20199 fail:
20200 return NULL;
20201 }
20202
20203
20204 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20205 PyObject *resultobj;
20206 wxDateTime *arg1 = (wxDateTime *) 0 ;
20207 wxDateTime::Month arg2 ;
20208 wxDateTime *result;
20209 PyObject * obj0 = 0 ;
20210 PyObject * obj1 = 0 ;
20211 char *kwnames[] = {
20212 (char *) "self",(char *) "month", NULL
20213 };
20214
20215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20217 if (SWIG_arg_fail(1)) SWIG_fail;
20218 {
20219 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20220 if (SWIG_arg_fail(2)) SWIG_fail;
20221 }
20222 {
20223 PyThreadState* __tstate = wxPyBeginAllowThreads();
20224 {
20225 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20226 result = (wxDateTime *) &_result_ref;
20227 }
20228
20229 wxPyEndAllowThreads(__tstate);
20230 if (PyErr_Occurred()) SWIG_fail;
20231 }
20232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20233 return resultobj;
20234 fail:
20235 return NULL;
20236 }
20237
20238
20239 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20240 PyObject *resultobj;
20241 wxDateTime *arg1 = (wxDateTime *) 0 ;
20242 int arg2 ;
20243 wxDateTime *result;
20244 PyObject * obj0 = 0 ;
20245 PyObject * obj1 = 0 ;
20246 char *kwnames[] = {
20247 (char *) "self",(char *) "day", NULL
20248 };
20249
20250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20252 if (SWIG_arg_fail(1)) SWIG_fail;
20253 {
20254 arg2 = (int)(SWIG_As_int(obj1));
20255 if (SWIG_arg_fail(2)) SWIG_fail;
20256 }
20257 {
20258 PyThreadState* __tstate = wxPyBeginAllowThreads();
20259 {
20260 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20261 result = (wxDateTime *) &_result_ref;
20262 }
20263
20264 wxPyEndAllowThreads(__tstate);
20265 if (PyErr_Occurred()) SWIG_fail;
20266 }
20267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20268 return resultobj;
20269 fail:
20270 return NULL;
20271 }
20272
20273
20274 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20275 PyObject *resultobj;
20276 wxDateTime *arg1 = (wxDateTime *) 0 ;
20277 int arg2 ;
20278 wxDateTime *result;
20279 PyObject * obj0 = 0 ;
20280 PyObject * obj1 = 0 ;
20281 char *kwnames[] = {
20282 (char *) "self",(char *) "hour", NULL
20283 };
20284
20285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20287 if (SWIG_arg_fail(1)) SWIG_fail;
20288 {
20289 arg2 = (int)(SWIG_As_int(obj1));
20290 if (SWIG_arg_fail(2)) SWIG_fail;
20291 }
20292 {
20293 PyThreadState* __tstate = wxPyBeginAllowThreads();
20294 {
20295 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20296 result = (wxDateTime *) &_result_ref;
20297 }
20298
20299 wxPyEndAllowThreads(__tstate);
20300 if (PyErr_Occurred()) SWIG_fail;
20301 }
20302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20303 return resultobj;
20304 fail:
20305 return NULL;
20306 }
20307
20308
20309 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20310 PyObject *resultobj;
20311 wxDateTime *arg1 = (wxDateTime *) 0 ;
20312 int arg2 ;
20313 wxDateTime *result;
20314 PyObject * obj0 = 0 ;
20315 PyObject * obj1 = 0 ;
20316 char *kwnames[] = {
20317 (char *) "self",(char *) "minute", NULL
20318 };
20319
20320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20322 if (SWIG_arg_fail(1)) SWIG_fail;
20323 {
20324 arg2 = (int)(SWIG_As_int(obj1));
20325 if (SWIG_arg_fail(2)) SWIG_fail;
20326 }
20327 {
20328 PyThreadState* __tstate = wxPyBeginAllowThreads();
20329 {
20330 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20331 result = (wxDateTime *) &_result_ref;
20332 }
20333
20334 wxPyEndAllowThreads(__tstate);
20335 if (PyErr_Occurred()) SWIG_fail;
20336 }
20337 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20338 return resultobj;
20339 fail:
20340 return NULL;
20341 }
20342
20343
20344 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20345 PyObject *resultobj;
20346 wxDateTime *arg1 = (wxDateTime *) 0 ;
20347 int arg2 ;
20348 wxDateTime *result;
20349 PyObject * obj0 = 0 ;
20350 PyObject * obj1 = 0 ;
20351 char *kwnames[] = {
20352 (char *) "self",(char *) "second", NULL
20353 };
20354
20355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20357 if (SWIG_arg_fail(1)) SWIG_fail;
20358 {
20359 arg2 = (int)(SWIG_As_int(obj1));
20360 if (SWIG_arg_fail(2)) SWIG_fail;
20361 }
20362 {
20363 PyThreadState* __tstate = wxPyBeginAllowThreads();
20364 {
20365 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20366 result = (wxDateTime *) &_result_ref;
20367 }
20368
20369 wxPyEndAllowThreads(__tstate);
20370 if (PyErr_Occurred()) SWIG_fail;
20371 }
20372 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20373 return resultobj;
20374 fail:
20375 return NULL;
20376 }
20377
20378
20379 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20380 PyObject *resultobj;
20381 wxDateTime *arg1 = (wxDateTime *) 0 ;
20382 int arg2 ;
20383 wxDateTime *result;
20384 PyObject * obj0 = 0 ;
20385 PyObject * obj1 = 0 ;
20386 char *kwnames[] = {
20387 (char *) "self",(char *) "millisecond", NULL
20388 };
20389
20390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20392 if (SWIG_arg_fail(1)) SWIG_fail;
20393 {
20394 arg2 = (int)(SWIG_As_int(obj1));
20395 if (SWIG_arg_fail(2)) SWIG_fail;
20396 }
20397 {
20398 PyThreadState* __tstate = wxPyBeginAllowThreads();
20399 {
20400 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20401 result = (wxDateTime *) &_result_ref;
20402 }
20403
20404 wxPyEndAllowThreads(__tstate);
20405 if (PyErr_Occurred()) SWIG_fail;
20406 }
20407 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20408 return resultobj;
20409 fail:
20410 return NULL;
20411 }
20412
20413
20414 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20415 PyObject *resultobj;
20416 wxDateTime *arg1 = (wxDateTime *) 0 ;
20417 wxDateTime::WeekDay arg2 ;
20418 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20419 wxDateTime *result;
20420 PyObject * obj0 = 0 ;
20421 PyObject * obj1 = 0 ;
20422 PyObject * obj2 = 0 ;
20423 char *kwnames[] = {
20424 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20425 };
20426
20427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20429 if (SWIG_arg_fail(1)) SWIG_fail;
20430 {
20431 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20432 if (SWIG_arg_fail(2)) SWIG_fail;
20433 }
20434 if (obj2) {
20435 {
20436 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20437 if (SWIG_arg_fail(3)) SWIG_fail;
20438 }
20439 }
20440 {
20441 PyThreadState* __tstate = wxPyBeginAllowThreads();
20442 {
20443 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20444 result = (wxDateTime *) &_result_ref;
20445 }
20446
20447 wxPyEndAllowThreads(__tstate);
20448 if (PyErr_Occurred()) SWIG_fail;
20449 }
20450 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20451 return resultobj;
20452 fail:
20453 return NULL;
20454 }
20455
20456
20457 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20458 PyObject *resultobj;
20459 wxDateTime *arg1 = (wxDateTime *) 0 ;
20460 wxDateTime::WeekDay arg2 ;
20461 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20462 wxDateTime result;
20463 PyObject * obj0 = 0 ;
20464 PyObject * obj1 = 0 ;
20465 PyObject * obj2 = 0 ;
20466 char *kwnames[] = {
20467 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20468 };
20469
20470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20472 if (SWIG_arg_fail(1)) SWIG_fail;
20473 {
20474 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20475 if (SWIG_arg_fail(2)) SWIG_fail;
20476 }
20477 if (obj2) {
20478 {
20479 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20480 if (SWIG_arg_fail(3)) SWIG_fail;
20481 }
20482 }
20483 {
20484 PyThreadState* __tstate = wxPyBeginAllowThreads();
20485 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20486
20487 wxPyEndAllowThreads(__tstate);
20488 if (PyErr_Occurred()) SWIG_fail;
20489 }
20490 {
20491 wxDateTime * resultptr;
20492 resultptr = new wxDateTime((wxDateTime &)(result));
20493 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20494 }
20495 return resultobj;
20496 fail:
20497 return NULL;
20498 }
20499
20500
20501 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20502 PyObject *resultobj;
20503 wxDateTime *arg1 = (wxDateTime *) 0 ;
20504 wxDateTime::WeekDay arg2 ;
20505 wxDateTime *result;
20506 PyObject * obj0 = 0 ;
20507 PyObject * obj1 = 0 ;
20508 char *kwnames[] = {
20509 (char *) "self",(char *) "weekday", NULL
20510 };
20511
20512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20514 if (SWIG_arg_fail(1)) SWIG_fail;
20515 {
20516 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20517 if (SWIG_arg_fail(2)) SWIG_fail;
20518 }
20519 {
20520 PyThreadState* __tstate = wxPyBeginAllowThreads();
20521 {
20522 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20523 result = (wxDateTime *) &_result_ref;
20524 }
20525
20526 wxPyEndAllowThreads(__tstate);
20527 if (PyErr_Occurred()) SWIG_fail;
20528 }
20529 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20530 return resultobj;
20531 fail:
20532 return NULL;
20533 }
20534
20535
20536 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20537 PyObject *resultobj;
20538 wxDateTime *arg1 = (wxDateTime *) 0 ;
20539 wxDateTime::WeekDay arg2 ;
20540 wxDateTime result;
20541 PyObject * obj0 = 0 ;
20542 PyObject * obj1 = 0 ;
20543 char *kwnames[] = {
20544 (char *) "self",(char *) "weekday", NULL
20545 };
20546
20547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20549 if (SWIG_arg_fail(1)) SWIG_fail;
20550 {
20551 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20552 if (SWIG_arg_fail(2)) SWIG_fail;
20553 }
20554 {
20555 PyThreadState* __tstate = wxPyBeginAllowThreads();
20556 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20557
20558 wxPyEndAllowThreads(__tstate);
20559 if (PyErr_Occurred()) SWIG_fail;
20560 }
20561 {
20562 wxDateTime * resultptr;
20563 resultptr = new wxDateTime((wxDateTime &)(result));
20564 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20565 }
20566 return resultobj;
20567 fail:
20568 return NULL;
20569 }
20570
20571
20572 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20573 PyObject *resultobj;
20574 wxDateTime *arg1 = (wxDateTime *) 0 ;
20575 wxDateTime::WeekDay arg2 ;
20576 wxDateTime *result;
20577 PyObject * obj0 = 0 ;
20578 PyObject * obj1 = 0 ;
20579 char *kwnames[] = {
20580 (char *) "self",(char *) "weekday", NULL
20581 };
20582
20583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20585 if (SWIG_arg_fail(1)) SWIG_fail;
20586 {
20587 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20588 if (SWIG_arg_fail(2)) SWIG_fail;
20589 }
20590 {
20591 PyThreadState* __tstate = wxPyBeginAllowThreads();
20592 {
20593 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20594 result = (wxDateTime *) &_result_ref;
20595 }
20596
20597 wxPyEndAllowThreads(__tstate);
20598 if (PyErr_Occurred()) SWIG_fail;
20599 }
20600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20601 return resultobj;
20602 fail:
20603 return NULL;
20604 }
20605
20606
20607 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20608 PyObject *resultobj;
20609 wxDateTime *arg1 = (wxDateTime *) 0 ;
20610 wxDateTime::WeekDay arg2 ;
20611 wxDateTime result;
20612 PyObject * obj0 = 0 ;
20613 PyObject * obj1 = 0 ;
20614 char *kwnames[] = {
20615 (char *) "self",(char *) "weekday", NULL
20616 };
20617
20618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20620 if (SWIG_arg_fail(1)) SWIG_fail;
20621 {
20622 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20623 if (SWIG_arg_fail(2)) SWIG_fail;
20624 }
20625 {
20626 PyThreadState* __tstate = wxPyBeginAllowThreads();
20627 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20628
20629 wxPyEndAllowThreads(__tstate);
20630 if (PyErr_Occurred()) SWIG_fail;
20631 }
20632 {
20633 wxDateTime * resultptr;
20634 resultptr = new wxDateTime((wxDateTime &)(result));
20635 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20636 }
20637 return resultobj;
20638 fail:
20639 return NULL;
20640 }
20641
20642
20643 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20644 PyObject *resultobj;
20645 wxDateTime *arg1 = (wxDateTime *) 0 ;
20646 wxDateTime::WeekDay arg2 ;
20647 int arg3 = (int) 1 ;
20648 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20649 int arg5 = (int) wxDateTime::Inv_Year ;
20650 bool result;
20651 PyObject * obj0 = 0 ;
20652 PyObject * obj1 = 0 ;
20653 PyObject * obj2 = 0 ;
20654 PyObject * obj3 = 0 ;
20655 PyObject * obj4 = 0 ;
20656 char *kwnames[] = {
20657 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20658 };
20659
20660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20662 if (SWIG_arg_fail(1)) SWIG_fail;
20663 {
20664 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20665 if (SWIG_arg_fail(2)) SWIG_fail;
20666 }
20667 if (obj2) {
20668 {
20669 arg3 = (int)(SWIG_As_int(obj2));
20670 if (SWIG_arg_fail(3)) SWIG_fail;
20671 }
20672 }
20673 if (obj3) {
20674 {
20675 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20676 if (SWIG_arg_fail(4)) SWIG_fail;
20677 }
20678 }
20679 if (obj4) {
20680 {
20681 arg5 = (int)(SWIG_As_int(obj4));
20682 if (SWIG_arg_fail(5)) SWIG_fail;
20683 }
20684 }
20685 {
20686 PyThreadState* __tstate = wxPyBeginAllowThreads();
20687 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20688
20689 wxPyEndAllowThreads(__tstate);
20690 if (PyErr_Occurred()) SWIG_fail;
20691 }
20692 {
20693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20694 }
20695 return resultobj;
20696 fail:
20697 return NULL;
20698 }
20699
20700
20701 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20702 PyObject *resultobj;
20703 wxDateTime *arg1 = (wxDateTime *) 0 ;
20704 wxDateTime::WeekDay arg2 ;
20705 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20706 int arg4 = (int) wxDateTime::Inv_Year ;
20707 bool result;
20708 PyObject * obj0 = 0 ;
20709 PyObject * obj1 = 0 ;
20710 PyObject * obj2 = 0 ;
20711 PyObject * obj3 = 0 ;
20712 char *kwnames[] = {
20713 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20714 };
20715
20716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20718 if (SWIG_arg_fail(1)) SWIG_fail;
20719 {
20720 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20721 if (SWIG_arg_fail(2)) SWIG_fail;
20722 }
20723 if (obj2) {
20724 {
20725 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20726 if (SWIG_arg_fail(3)) SWIG_fail;
20727 }
20728 }
20729 if (obj3) {
20730 {
20731 arg4 = (int)(SWIG_As_int(obj3));
20732 if (SWIG_arg_fail(4)) SWIG_fail;
20733 }
20734 }
20735 {
20736 PyThreadState* __tstate = wxPyBeginAllowThreads();
20737 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20738
20739 wxPyEndAllowThreads(__tstate);
20740 if (PyErr_Occurred()) SWIG_fail;
20741 }
20742 {
20743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20744 }
20745 return resultobj;
20746 fail:
20747 return NULL;
20748 }
20749
20750
20751 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20752 PyObject *resultobj;
20753 wxDateTime *arg1 = (wxDateTime *) 0 ;
20754 wxDateTime::WeekDay arg2 ;
20755 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20756 int arg4 = (int) wxDateTime::Inv_Year ;
20757 wxDateTime result;
20758 PyObject * obj0 = 0 ;
20759 PyObject * obj1 = 0 ;
20760 PyObject * obj2 = 0 ;
20761 PyObject * obj3 = 0 ;
20762 char *kwnames[] = {
20763 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20764 };
20765
20766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20768 if (SWIG_arg_fail(1)) SWIG_fail;
20769 {
20770 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20771 if (SWIG_arg_fail(2)) SWIG_fail;
20772 }
20773 if (obj2) {
20774 {
20775 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20776 if (SWIG_arg_fail(3)) SWIG_fail;
20777 }
20778 }
20779 if (obj3) {
20780 {
20781 arg4 = (int)(SWIG_As_int(obj3));
20782 if (SWIG_arg_fail(4)) SWIG_fail;
20783 }
20784 }
20785 {
20786 PyThreadState* __tstate = wxPyBeginAllowThreads();
20787 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20788
20789 wxPyEndAllowThreads(__tstate);
20790 if (PyErr_Occurred()) SWIG_fail;
20791 }
20792 {
20793 wxDateTime * resultptr;
20794 resultptr = new wxDateTime((wxDateTime &)(result));
20795 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20796 }
20797 return resultobj;
20798 fail:
20799 return NULL;
20800 }
20801
20802
20803 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20804 PyObject *resultobj;
20805 wxDateTime *arg1 = (wxDateTime *) 0 ;
20806 int arg2 ;
20807 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20808 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20809 bool result;
20810 PyObject * obj0 = 0 ;
20811 PyObject * obj1 = 0 ;
20812 PyObject * obj2 = 0 ;
20813 PyObject * obj3 = 0 ;
20814 char *kwnames[] = {
20815 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20816 };
20817
20818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20820 if (SWIG_arg_fail(1)) SWIG_fail;
20821 {
20822 arg2 = (int)(SWIG_As_int(obj1));
20823 if (SWIG_arg_fail(2)) SWIG_fail;
20824 }
20825 if (obj2) {
20826 {
20827 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20828 if (SWIG_arg_fail(3)) SWIG_fail;
20829 }
20830 }
20831 if (obj3) {
20832 {
20833 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20834 if (SWIG_arg_fail(4)) SWIG_fail;
20835 }
20836 }
20837 {
20838 PyThreadState* __tstate = wxPyBeginAllowThreads();
20839 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20840
20841 wxPyEndAllowThreads(__tstate);
20842 if (PyErr_Occurred()) SWIG_fail;
20843 }
20844 {
20845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20846 }
20847 return resultobj;
20848 fail:
20849 return NULL;
20850 }
20851
20852
20853 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20854 PyObject *resultobj;
20855 wxDateTime *arg1 = (wxDateTime *) 0 ;
20856 int arg2 ;
20857 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20858 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20859 wxDateTime result;
20860 PyObject * obj0 = 0 ;
20861 PyObject * obj1 = 0 ;
20862 PyObject * obj2 = 0 ;
20863 PyObject * obj3 = 0 ;
20864 char *kwnames[] = {
20865 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20866 };
20867
20868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20870 if (SWIG_arg_fail(1)) SWIG_fail;
20871 {
20872 arg2 = (int)(SWIG_As_int(obj1));
20873 if (SWIG_arg_fail(2)) SWIG_fail;
20874 }
20875 if (obj2) {
20876 {
20877 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20878 if (SWIG_arg_fail(3)) SWIG_fail;
20879 }
20880 }
20881 if (obj3) {
20882 {
20883 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20884 if (SWIG_arg_fail(4)) SWIG_fail;
20885 }
20886 }
20887 {
20888 PyThreadState* __tstate = wxPyBeginAllowThreads();
20889 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20890
20891 wxPyEndAllowThreads(__tstate);
20892 if (PyErr_Occurred()) SWIG_fail;
20893 }
20894 {
20895 wxDateTime * resultptr;
20896 resultptr = new wxDateTime((wxDateTime &)(result));
20897 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20898 }
20899 return resultobj;
20900 fail:
20901 return NULL;
20902 }
20903
20904
20905 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20906 PyObject *resultobj;
20907 int arg1 ;
20908 int arg2 ;
20909 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20910 wxDateTime result;
20911 PyObject * obj0 = 0 ;
20912 PyObject * obj1 = 0 ;
20913 PyObject * obj2 = 0 ;
20914 char *kwnames[] = {
20915 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20916 };
20917
20918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20919 {
20920 arg1 = (int)(SWIG_As_int(obj0));
20921 if (SWIG_arg_fail(1)) SWIG_fail;
20922 }
20923 {
20924 arg2 = (int)(SWIG_As_int(obj1));
20925 if (SWIG_arg_fail(2)) SWIG_fail;
20926 }
20927 if (obj2) {
20928 {
20929 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20930 if (SWIG_arg_fail(3)) SWIG_fail;
20931 }
20932 }
20933 {
20934 PyThreadState* __tstate = wxPyBeginAllowThreads();
20935 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20936
20937 wxPyEndAllowThreads(__tstate);
20938 if (PyErr_Occurred()) SWIG_fail;
20939 }
20940 {
20941 wxDateTime * resultptr;
20942 resultptr = new wxDateTime((wxDateTime &)(result));
20943 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20944 }
20945 return resultobj;
20946 fail:
20947 return NULL;
20948 }
20949
20950
20951 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20952 PyObject *resultobj;
20953 wxDateTime *arg1 = (wxDateTime *) 0 ;
20954 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20955 int arg3 = (int) wxDateTime::Inv_Year ;
20956 wxDateTime *result;
20957 PyObject * obj0 = 0 ;
20958 PyObject * obj1 = 0 ;
20959 PyObject * obj2 = 0 ;
20960 char *kwnames[] = {
20961 (char *) "self",(char *) "month",(char *) "year", NULL
20962 };
20963
20964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20966 if (SWIG_arg_fail(1)) SWIG_fail;
20967 if (obj1) {
20968 {
20969 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20970 if (SWIG_arg_fail(2)) SWIG_fail;
20971 }
20972 }
20973 if (obj2) {
20974 {
20975 arg3 = (int)(SWIG_As_int(obj2));
20976 if (SWIG_arg_fail(3)) SWIG_fail;
20977 }
20978 }
20979 {
20980 PyThreadState* __tstate = wxPyBeginAllowThreads();
20981 {
20982 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20983 result = (wxDateTime *) &_result_ref;
20984 }
20985
20986 wxPyEndAllowThreads(__tstate);
20987 if (PyErr_Occurred()) SWIG_fail;
20988 }
20989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20990 return resultobj;
20991 fail:
20992 return NULL;
20993 }
20994
20995
20996 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20997 PyObject *resultobj;
20998 wxDateTime *arg1 = (wxDateTime *) 0 ;
20999 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21000 int arg3 = (int) wxDateTime::Inv_Year ;
21001 wxDateTime result;
21002 PyObject * obj0 = 0 ;
21003 PyObject * obj1 = 0 ;
21004 PyObject * obj2 = 0 ;
21005 char *kwnames[] = {
21006 (char *) "self",(char *) "month",(char *) "year", NULL
21007 };
21008
21009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21011 if (SWIG_arg_fail(1)) SWIG_fail;
21012 if (obj1) {
21013 {
21014 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21015 if (SWIG_arg_fail(2)) SWIG_fail;
21016 }
21017 }
21018 if (obj2) {
21019 {
21020 arg3 = (int)(SWIG_As_int(obj2));
21021 if (SWIG_arg_fail(3)) SWIG_fail;
21022 }
21023 }
21024 {
21025 PyThreadState* __tstate = wxPyBeginAllowThreads();
21026 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
21027
21028 wxPyEndAllowThreads(__tstate);
21029 if (PyErr_Occurred()) SWIG_fail;
21030 }
21031 {
21032 wxDateTime * resultptr;
21033 resultptr = new wxDateTime((wxDateTime &)(result));
21034 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21035 }
21036 return resultobj;
21037 fail:
21038 return NULL;
21039 }
21040
21041
21042 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21043 PyObject *resultobj;
21044 wxDateTime *arg1 = (wxDateTime *) 0 ;
21045 int arg2 ;
21046 wxDateTime *result;
21047 PyObject * obj0 = 0 ;
21048 PyObject * obj1 = 0 ;
21049 char *kwnames[] = {
21050 (char *) "self",(char *) "yday", NULL
21051 };
21052
21053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21055 if (SWIG_arg_fail(1)) SWIG_fail;
21056 {
21057 arg2 = (int)(SWIG_As_int(obj1));
21058 if (SWIG_arg_fail(2)) SWIG_fail;
21059 }
21060 {
21061 PyThreadState* __tstate = wxPyBeginAllowThreads();
21062 {
21063 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21064 result = (wxDateTime *) &_result_ref;
21065 }
21066
21067 wxPyEndAllowThreads(__tstate);
21068 if (PyErr_Occurred()) SWIG_fail;
21069 }
21070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21071 return resultobj;
21072 fail:
21073 return NULL;
21074 }
21075
21076
21077 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21078 PyObject *resultobj;
21079 wxDateTime *arg1 = (wxDateTime *) 0 ;
21080 int arg2 ;
21081 wxDateTime result;
21082 PyObject * obj0 = 0 ;
21083 PyObject * obj1 = 0 ;
21084 char *kwnames[] = {
21085 (char *) "self",(char *) "yday", NULL
21086 };
21087
21088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21090 if (SWIG_arg_fail(1)) SWIG_fail;
21091 {
21092 arg2 = (int)(SWIG_As_int(obj1));
21093 if (SWIG_arg_fail(2)) SWIG_fail;
21094 }
21095 {
21096 PyThreadState* __tstate = wxPyBeginAllowThreads();
21097 result = (arg1)->GetYearDay(arg2);
21098
21099 wxPyEndAllowThreads(__tstate);
21100 if (PyErr_Occurred()) SWIG_fail;
21101 }
21102 {
21103 wxDateTime * resultptr;
21104 resultptr = new wxDateTime((wxDateTime &)(result));
21105 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21106 }
21107 return resultobj;
21108 fail:
21109 return NULL;
21110 }
21111
21112
21113 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21114 PyObject *resultobj;
21115 wxDateTime *arg1 = (wxDateTime *) 0 ;
21116 double result;
21117 PyObject * obj0 = 0 ;
21118 char *kwnames[] = {
21119 (char *) "self", NULL
21120 };
21121
21122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21124 if (SWIG_arg_fail(1)) SWIG_fail;
21125 {
21126 PyThreadState* __tstate = wxPyBeginAllowThreads();
21127 result = (double)(arg1)->GetJulianDayNumber();
21128
21129 wxPyEndAllowThreads(__tstate);
21130 if (PyErr_Occurred()) SWIG_fail;
21131 }
21132 {
21133 resultobj = SWIG_From_double((double)(result));
21134 }
21135 return resultobj;
21136 fail:
21137 return NULL;
21138 }
21139
21140
21141 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21142 PyObject *resultobj;
21143 wxDateTime *arg1 = (wxDateTime *) 0 ;
21144 double result;
21145 PyObject * obj0 = 0 ;
21146 char *kwnames[] = {
21147 (char *) "self", NULL
21148 };
21149
21150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21152 if (SWIG_arg_fail(1)) SWIG_fail;
21153 {
21154 PyThreadState* __tstate = wxPyBeginAllowThreads();
21155 result = (double)(arg1)->GetJDN();
21156
21157 wxPyEndAllowThreads(__tstate);
21158 if (PyErr_Occurred()) SWIG_fail;
21159 }
21160 {
21161 resultobj = SWIG_From_double((double)(result));
21162 }
21163 return resultobj;
21164 fail:
21165 return NULL;
21166 }
21167
21168
21169 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21170 PyObject *resultobj;
21171 wxDateTime *arg1 = (wxDateTime *) 0 ;
21172 double result;
21173 PyObject * obj0 = 0 ;
21174 char *kwnames[] = {
21175 (char *) "self", NULL
21176 };
21177
21178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21180 if (SWIG_arg_fail(1)) SWIG_fail;
21181 {
21182 PyThreadState* __tstate = wxPyBeginAllowThreads();
21183 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21184
21185 wxPyEndAllowThreads(__tstate);
21186 if (PyErr_Occurred()) SWIG_fail;
21187 }
21188 {
21189 resultobj = SWIG_From_double((double)(result));
21190 }
21191 return resultobj;
21192 fail:
21193 return NULL;
21194 }
21195
21196
21197 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21198 PyObject *resultobj;
21199 wxDateTime *arg1 = (wxDateTime *) 0 ;
21200 double result;
21201 PyObject * obj0 = 0 ;
21202 char *kwnames[] = {
21203 (char *) "self", NULL
21204 };
21205
21206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21208 if (SWIG_arg_fail(1)) SWIG_fail;
21209 {
21210 PyThreadState* __tstate = wxPyBeginAllowThreads();
21211 result = (double)(arg1)->GetMJD();
21212
21213 wxPyEndAllowThreads(__tstate);
21214 if (PyErr_Occurred()) SWIG_fail;
21215 }
21216 {
21217 resultobj = SWIG_From_double((double)(result));
21218 }
21219 return resultobj;
21220 fail:
21221 return NULL;
21222 }
21223
21224
21225 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21226 PyObject *resultobj;
21227 wxDateTime *arg1 = (wxDateTime *) 0 ;
21228 double result;
21229 PyObject * obj0 = 0 ;
21230 char *kwnames[] = {
21231 (char *) "self", NULL
21232 };
21233
21234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21236 if (SWIG_arg_fail(1)) SWIG_fail;
21237 {
21238 PyThreadState* __tstate = wxPyBeginAllowThreads();
21239 result = (double)(arg1)->GetRataDie();
21240
21241 wxPyEndAllowThreads(__tstate);
21242 if (PyErr_Occurred()) SWIG_fail;
21243 }
21244 {
21245 resultobj = SWIG_From_double((double)(result));
21246 }
21247 return resultobj;
21248 fail:
21249 return NULL;
21250 }
21251
21252
21253 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21254 PyObject *resultobj;
21255 wxDateTime *arg1 = (wxDateTime *) 0 ;
21256 wxDateTime::TimeZone *arg2 = 0 ;
21257 bool arg3 = (bool) false ;
21258 wxDateTime result;
21259 bool temp2 = false ;
21260 PyObject * obj0 = 0 ;
21261 PyObject * obj1 = 0 ;
21262 PyObject * obj2 = 0 ;
21263 char *kwnames[] = {
21264 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21265 };
21266
21267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21269 if (SWIG_arg_fail(1)) SWIG_fail;
21270 {
21271 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21272 temp2 = true;
21273 }
21274 if (obj2) {
21275 {
21276 arg3 = (bool)(SWIG_As_bool(obj2));
21277 if (SWIG_arg_fail(3)) SWIG_fail;
21278 }
21279 }
21280 {
21281 PyThreadState* __tstate = wxPyBeginAllowThreads();
21282 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21283
21284 wxPyEndAllowThreads(__tstate);
21285 if (PyErr_Occurred()) SWIG_fail;
21286 }
21287 {
21288 wxDateTime * resultptr;
21289 resultptr = new wxDateTime((wxDateTime &)(result));
21290 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21291 }
21292 {
21293 if (temp2) delete arg2;
21294 }
21295 return resultobj;
21296 fail:
21297 {
21298 if (temp2) delete arg2;
21299 }
21300 return NULL;
21301 }
21302
21303
21304 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21305 PyObject *resultobj;
21306 wxDateTime *arg1 = (wxDateTime *) 0 ;
21307 wxDateTime::TimeZone *arg2 = 0 ;
21308 bool arg3 = (bool) false ;
21309 wxDateTime *result;
21310 bool temp2 = false ;
21311 PyObject * obj0 = 0 ;
21312 PyObject * obj1 = 0 ;
21313 PyObject * obj2 = 0 ;
21314 char *kwnames[] = {
21315 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21316 };
21317
21318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21320 if (SWIG_arg_fail(1)) SWIG_fail;
21321 {
21322 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21323 temp2 = true;
21324 }
21325 if (obj2) {
21326 {
21327 arg3 = (bool)(SWIG_As_bool(obj2));
21328 if (SWIG_arg_fail(3)) SWIG_fail;
21329 }
21330 }
21331 {
21332 PyThreadState* __tstate = wxPyBeginAllowThreads();
21333 {
21334 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21335 result = (wxDateTime *) &_result_ref;
21336 }
21337
21338 wxPyEndAllowThreads(__tstate);
21339 if (PyErr_Occurred()) SWIG_fail;
21340 }
21341 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21342 {
21343 if (temp2) delete arg2;
21344 }
21345 return resultobj;
21346 fail:
21347 {
21348 if (temp2) delete arg2;
21349 }
21350 return NULL;
21351 }
21352
21353
21354 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21355 PyObject *resultobj;
21356 wxDateTime *arg1 = (wxDateTime *) 0 ;
21357 bool arg2 = (bool) false ;
21358 wxDateTime result;
21359 PyObject * obj0 = 0 ;
21360 PyObject * obj1 = 0 ;
21361 char *kwnames[] = {
21362 (char *) "self",(char *) "noDST", NULL
21363 };
21364
21365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21367 if (SWIG_arg_fail(1)) SWIG_fail;
21368 if (obj1) {
21369 {
21370 arg2 = (bool)(SWIG_As_bool(obj1));
21371 if (SWIG_arg_fail(2)) SWIG_fail;
21372 }
21373 }
21374 {
21375 PyThreadState* __tstate = wxPyBeginAllowThreads();
21376 result = (arg1)->ToGMT(arg2);
21377
21378 wxPyEndAllowThreads(__tstate);
21379 if (PyErr_Occurred()) SWIG_fail;
21380 }
21381 {
21382 wxDateTime * resultptr;
21383 resultptr = new wxDateTime((wxDateTime &)(result));
21384 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21385 }
21386 return resultobj;
21387 fail:
21388 return NULL;
21389 }
21390
21391
21392 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21393 PyObject *resultobj;
21394 wxDateTime *arg1 = (wxDateTime *) 0 ;
21395 bool arg2 = (bool) false ;
21396 wxDateTime *result;
21397 PyObject * obj0 = 0 ;
21398 PyObject * obj1 = 0 ;
21399 char *kwnames[] = {
21400 (char *) "self",(char *) "noDST", NULL
21401 };
21402
21403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21405 if (SWIG_arg_fail(1)) SWIG_fail;
21406 if (obj1) {
21407 {
21408 arg2 = (bool)(SWIG_As_bool(obj1));
21409 if (SWIG_arg_fail(2)) SWIG_fail;
21410 }
21411 }
21412 {
21413 PyThreadState* __tstate = wxPyBeginAllowThreads();
21414 {
21415 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21416 result = (wxDateTime *) &_result_ref;
21417 }
21418
21419 wxPyEndAllowThreads(__tstate);
21420 if (PyErr_Occurred()) SWIG_fail;
21421 }
21422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21423 return resultobj;
21424 fail:
21425 return NULL;
21426 }
21427
21428
21429 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21430 PyObject *resultobj;
21431 wxDateTime *arg1 = (wxDateTime *) 0 ;
21432 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21433 int result;
21434 PyObject * obj0 = 0 ;
21435 PyObject * obj1 = 0 ;
21436 char *kwnames[] = {
21437 (char *) "self",(char *) "country", NULL
21438 };
21439
21440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21442 if (SWIG_arg_fail(1)) SWIG_fail;
21443 if (obj1) {
21444 {
21445 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21446 if (SWIG_arg_fail(2)) SWIG_fail;
21447 }
21448 }
21449 {
21450 PyThreadState* __tstate = wxPyBeginAllowThreads();
21451 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21452
21453 wxPyEndAllowThreads(__tstate);
21454 if (PyErr_Occurred()) SWIG_fail;
21455 }
21456 {
21457 resultobj = SWIG_From_int((int)(result));
21458 }
21459 return resultobj;
21460 fail:
21461 return NULL;
21462 }
21463
21464
21465 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21466 PyObject *resultobj;
21467 wxDateTime *arg1 = (wxDateTime *) 0 ;
21468 bool result;
21469 PyObject * obj0 = 0 ;
21470 char *kwnames[] = {
21471 (char *) "self", NULL
21472 };
21473
21474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21476 if (SWIG_arg_fail(1)) SWIG_fail;
21477 {
21478 PyThreadState* __tstate = wxPyBeginAllowThreads();
21479 result = (bool)((wxDateTime const *)arg1)->IsValid();
21480
21481 wxPyEndAllowThreads(__tstate);
21482 if (PyErr_Occurred()) SWIG_fail;
21483 }
21484 {
21485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21486 }
21487 return resultobj;
21488 fail:
21489 return NULL;
21490 }
21491
21492
21493 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21494 PyObject *resultobj;
21495 wxDateTime *arg1 = (wxDateTime *) 0 ;
21496 time_t result;
21497 PyObject * obj0 = 0 ;
21498 char *kwnames[] = {
21499 (char *) "self", NULL
21500 };
21501
21502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21504 if (SWIG_arg_fail(1)) SWIG_fail;
21505 {
21506 PyThreadState* __tstate = wxPyBeginAllowThreads();
21507 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21508
21509 wxPyEndAllowThreads(__tstate);
21510 if (PyErr_Occurred()) SWIG_fail;
21511 }
21512 {
21513 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21514 }
21515 return resultobj;
21516 fail:
21517 return NULL;
21518 }
21519
21520
21521 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21522 PyObject *resultobj;
21523 wxDateTime *arg1 = (wxDateTime *) 0 ;
21524 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21525 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21526 int result;
21527 bool temp2 = false ;
21528 PyObject * obj0 = 0 ;
21529 PyObject * obj1 = 0 ;
21530 char *kwnames[] = {
21531 (char *) "self",(char *) "tz", NULL
21532 };
21533
21534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21536 if (SWIG_arg_fail(1)) SWIG_fail;
21537 if (obj1) {
21538 {
21539 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21540 temp2 = true;
21541 }
21542 }
21543 {
21544 PyThreadState* __tstate = wxPyBeginAllowThreads();
21545 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21546
21547 wxPyEndAllowThreads(__tstate);
21548 if (PyErr_Occurred()) SWIG_fail;
21549 }
21550 {
21551 resultobj = SWIG_From_int((int)(result));
21552 }
21553 {
21554 if (temp2) delete arg2;
21555 }
21556 return resultobj;
21557 fail:
21558 {
21559 if (temp2) delete arg2;
21560 }
21561 return NULL;
21562 }
21563
21564
21565 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21566 PyObject *resultobj;
21567 wxDateTime *arg1 = (wxDateTime *) 0 ;
21568 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21569 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21570 wxDateTime::Month result;
21571 bool temp2 = false ;
21572 PyObject * obj0 = 0 ;
21573 PyObject * obj1 = 0 ;
21574 char *kwnames[] = {
21575 (char *) "self",(char *) "tz", NULL
21576 };
21577
21578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21580 if (SWIG_arg_fail(1)) SWIG_fail;
21581 if (obj1) {
21582 {
21583 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21584 temp2 = true;
21585 }
21586 }
21587 {
21588 PyThreadState* __tstate = wxPyBeginAllowThreads();
21589 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21590
21591 wxPyEndAllowThreads(__tstate);
21592 if (PyErr_Occurred()) SWIG_fail;
21593 }
21594 resultobj = SWIG_From_int((result));
21595 {
21596 if (temp2) delete arg2;
21597 }
21598 return resultobj;
21599 fail:
21600 {
21601 if (temp2) delete arg2;
21602 }
21603 return NULL;
21604 }
21605
21606
21607 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21608 PyObject *resultobj;
21609 wxDateTime *arg1 = (wxDateTime *) 0 ;
21610 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21611 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21612 int result;
21613 bool temp2 = false ;
21614 PyObject * obj0 = 0 ;
21615 PyObject * obj1 = 0 ;
21616 char *kwnames[] = {
21617 (char *) "self",(char *) "tz", NULL
21618 };
21619
21620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21622 if (SWIG_arg_fail(1)) SWIG_fail;
21623 if (obj1) {
21624 {
21625 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21626 temp2 = true;
21627 }
21628 }
21629 {
21630 PyThreadState* __tstate = wxPyBeginAllowThreads();
21631 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21632
21633 wxPyEndAllowThreads(__tstate);
21634 if (PyErr_Occurred()) SWIG_fail;
21635 }
21636 {
21637 resultobj = SWIG_From_int((int)(result));
21638 }
21639 {
21640 if (temp2) delete arg2;
21641 }
21642 return resultobj;
21643 fail:
21644 {
21645 if (temp2) delete arg2;
21646 }
21647 return NULL;
21648 }
21649
21650
21651 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21652 PyObject *resultobj;
21653 wxDateTime *arg1 = (wxDateTime *) 0 ;
21654 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21655 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21656 wxDateTime::WeekDay result;
21657 bool temp2 = false ;
21658 PyObject * obj0 = 0 ;
21659 PyObject * obj1 = 0 ;
21660 char *kwnames[] = {
21661 (char *) "self",(char *) "tz", NULL
21662 };
21663
21664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21666 if (SWIG_arg_fail(1)) SWIG_fail;
21667 if (obj1) {
21668 {
21669 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21670 temp2 = true;
21671 }
21672 }
21673 {
21674 PyThreadState* __tstate = wxPyBeginAllowThreads();
21675 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21676
21677 wxPyEndAllowThreads(__tstate);
21678 if (PyErr_Occurred()) SWIG_fail;
21679 }
21680 resultobj = SWIG_From_int((result));
21681 {
21682 if (temp2) delete arg2;
21683 }
21684 return resultobj;
21685 fail:
21686 {
21687 if (temp2) delete arg2;
21688 }
21689 return NULL;
21690 }
21691
21692
21693 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21694 PyObject *resultobj;
21695 wxDateTime *arg1 = (wxDateTime *) 0 ;
21696 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21697 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21698 int result;
21699 bool temp2 = false ;
21700 PyObject * obj0 = 0 ;
21701 PyObject * obj1 = 0 ;
21702 char *kwnames[] = {
21703 (char *) "self",(char *) "tz", NULL
21704 };
21705
21706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21708 if (SWIG_arg_fail(1)) SWIG_fail;
21709 if (obj1) {
21710 {
21711 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21712 temp2 = true;
21713 }
21714 }
21715 {
21716 PyThreadState* __tstate = wxPyBeginAllowThreads();
21717 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21718
21719 wxPyEndAllowThreads(__tstate);
21720 if (PyErr_Occurred()) SWIG_fail;
21721 }
21722 {
21723 resultobj = SWIG_From_int((int)(result));
21724 }
21725 {
21726 if (temp2) delete arg2;
21727 }
21728 return resultobj;
21729 fail:
21730 {
21731 if (temp2) delete arg2;
21732 }
21733 return NULL;
21734 }
21735
21736
21737 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21738 PyObject *resultobj;
21739 wxDateTime *arg1 = (wxDateTime *) 0 ;
21740 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21741 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21742 int result;
21743 bool temp2 = false ;
21744 PyObject * obj0 = 0 ;
21745 PyObject * obj1 = 0 ;
21746 char *kwnames[] = {
21747 (char *) "self",(char *) "tz", NULL
21748 };
21749
21750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21752 if (SWIG_arg_fail(1)) SWIG_fail;
21753 if (obj1) {
21754 {
21755 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21756 temp2 = true;
21757 }
21758 }
21759 {
21760 PyThreadState* __tstate = wxPyBeginAllowThreads();
21761 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21762
21763 wxPyEndAllowThreads(__tstate);
21764 if (PyErr_Occurred()) SWIG_fail;
21765 }
21766 {
21767 resultobj = SWIG_From_int((int)(result));
21768 }
21769 {
21770 if (temp2) delete arg2;
21771 }
21772 return resultobj;
21773 fail:
21774 {
21775 if (temp2) delete arg2;
21776 }
21777 return NULL;
21778 }
21779
21780
21781 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21782 PyObject *resultobj;
21783 wxDateTime *arg1 = (wxDateTime *) 0 ;
21784 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21785 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21786 int result;
21787 bool temp2 = false ;
21788 PyObject * obj0 = 0 ;
21789 PyObject * obj1 = 0 ;
21790 char *kwnames[] = {
21791 (char *) "self",(char *) "tz", NULL
21792 };
21793
21794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21796 if (SWIG_arg_fail(1)) SWIG_fail;
21797 if (obj1) {
21798 {
21799 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21800 temp2 = true;
21801 }
21802 }
21803 {
21804 PyThreadState* __tstate = wxPyBeginAllowThreads();
21805 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21806
21807 wxPyEndAllowThreads(__tstate);
21808 if (PyErr_Occurred()) SWIG_fail;
21809 }
21810 {
21811 resultobj = SWIG_From_int((int)(result));
21812 }
21813 {
21814 if (temp2) delete arg2;
21815 }
21816 return resultobj;
21817 fail:
21818 {
21819 if (temp2) delete arg2;
21820 }
21821 return NULL;
21822 }
21823
21824
21825 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21826 PyObject *resultobj;
21827 wxDateTime *arg1 = (wxDateTime *) 0 ;
21828 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21829 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21830 int result;
21831 bool temp2 = false ;
21832 PyObject * obj0 = 0 ;
21833 PyObject * obj1 = 0 ;
21834 char *kwnames[] = {
21835 (char *) "self",(char *) "tz", NULL
21836 };
21837
21838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21840 if (SWIG_arg_fail(1)) SWIG_fail;
21841 if (obj1) {
21842 {
21843 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21844 temp2 = true;
21845 }
21846 }
21847 {
21848 PyThreadState* __tstate = wxPyBeginAllowThreads();
21849 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21850
21851 wxPyEndAllowThreads(__tstate);
21852 if (PyErr_Occurred()) SWIG_fail;
21853 }
21854 {
21855 resultobj = SWIG_From_int((int)(result));
21856 }
21857 {
21858 if (temp2) delete arg2;
21859 }
21860 return resultobj;
21861 fail:
21862 {
21863 if (temp2) delete arg2;
21864 }
21865 return NULL;
21866 }
21867
21868
21869 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21870 PyObject *resultobj;
21871 wxDateTime *arg1 = (wxDateTime *) 0 ;
21872 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21873 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21874 int result;
21875 bool temp2 = false ;
21876 PyObject * obj0 = 0 ;
21877 PyObject * obj1 = 0 ;
21878 char *kwnames[] = {
21879 (char *) "self",(char *) "tz", NULL
21880 };
21881
21882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21884 if (SWIG_arg_fail(1)) SWIG_fail;
21885 if (obj1) {
21886 {
21887 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21888 temp2 = true;
21889 }
21890 }
21891 {
21892 PyThreadState* __tstate = wxPyBeginAllowThreads();
21893 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21894
21895 wxPyEndAllowThreads(__tstate);
21896 if (PyErr_Occurred()) SWIG_fail;
21897 }
21898 {
21899 resultobj = SWIG_From_int((int)(result));
21900 }
21901 {
21902 if (temp2) delete arg2;
21903 }
21904 return resultobj;
21905 fail:
21906 {
21907 if (temp2) delete arg2;
21908 }
21909 return NULL;
21910 }
21911
21912
21913 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21914 PyObject *resultobj;
21915 wxDateTime *arg1 = (wxDateTime *) 0 ;
21916 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21917 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21918 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21919 int result;
21920 bool temp3 = false ;
21921 PyObject * obj0 = 0 ;
21922 PyObject * obj1 = 0 ;
21923 PyObject * obj2 = 0 ;
21924 char *kwnames[] = {
21925 (char *) "self",(char *) "flags",(char *) "tz", NULL
21926 };
21927
21928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21930 if (SWIG_arg_fail(1)) SWIG_fail;
21931 if (obj1) {
21932 {
21933 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21934 if (SWIG_arg_fail(2)) SWIG_fail;
21935 }
21936 }
21937 if (obj2) {
21938 {
21939 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21940 temp3 = true;
21941 }
21942 }
21943 {
21944 PyThreadState* __tstate = wxPyBeginAllowThreads();
21945 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21946
21947 wxPyEndAllowThreads(__tstate);
21948 if (PyErr_Occurred()) SWIG_fail;
21949 }
21950 {
21951 resultobj = SWIG_From_int((int)(result));
21952 }
21953 {
21954 if (temp3) delete arg3;
21955 }
21956 return resultobj;
21957 fail:
21958 {
21959 if (temp3) delete arg3;
21960 }
21961 return NULL;
21962 }
21963
21964
21965 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21966 PyObject *resultobj;
21967 wxDateTime *arg1 = (wxDateTime *) 0 ;
21968 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21969 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21970 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21971 int result;
21972 bool temp3 = false ;
21973 PyObject * obj0 = 0 ;
21974 PyObject * obj1 = 0 ;
21975 PyObject * obj2 = 0 ;
21976 char *kwnames[] = {
21977 (char *) "self",(char *) "flags",(char *) "tz", NULL
21978 };
21979
21980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21982 if (SWIG_arg_fail(1)) SWIG_fail;
21983 if (obj1) {
21984 {
21985 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21986 if (SWIG_arg_fail(2)) SWIG_fail;
21987 }
21988 }
21989 if (obj2) {
21990 {
21991 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21992 temp3 = true;
21993 }
21994 }
21995 {
21996 PyThreadState* __tstate = wxPyBeginAllowThreads();
21997 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21998
21999 wxPyEndAllowThreads(__tstate);
22000 if (PyErr_Occurred()) SWIG_fail;
22001 }
22002 {
22003 resultobj = SWIG_From_int((int)(result));
22004 }
22005 {
22006 if (temp3) delete arg3;
22007 }
22008 return resultobj;
22009 fail:
22010 {
22011 if (temp3) delete arg3;
22012 }
22013 return NULL;
22014 }
22015
22016
22017 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
22018 PyObject *resultobj;
22019 wxDateTime *arg1 = (wxDateTime *) 0 ;
22020 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22021 bool result;
22022 PyObject * obj0 = 0 ;
22023 PyObject * obj1 = 0 ;
22024 char *kwnames[] = {
22025 (char *) "self",(char *) "country", NULL
22026 };
22027
22028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22030 if (SWIG_arg_fail(1)) SWIG_fail;
22031 if (obj1) {
22032 {
22033 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22034 if (SWIG_arg_fail(2)) SWIG_fail;
22035 }
22036 }
22037 {
22038 PyThreadState* __tstate = wxPyBeginAllowThreads();
22039 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22040
22041 wxPyEndAllowThreads(__tstate);
22042 if (PyErr_Occurred()) SWIG_fail;
22043 }
22044 {
22045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22046 }
22047 return resultobj;
22048 fail:
22049 return NULL;
22050 }
22051
22052
22053 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22054 PyObject *resultobj;
22055 wxDateTime *arg1 = (wxDateTime *) 0 ;
22056 wxDateTime *arg2 = 0 ;
22057 bool result;
22058 PyObject * obj0 = 0 ;
22059 PyObject * obj1 = 0 ;
22060 char *kwnames[] = {
22061 (char *) "self",(char *) "datetime", NULL
22062 };
22063
22064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22066 if (SWIG_arg_fail(1)) SWIG_fail;
22067 {
22068 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22069 if (SWIG_arg_fail(2)) SWIG_fail;
22070 if (arg2 == NULL) {
22071 SWIG_null_ref("wxDateTime");
22072 }
22073 if (SWIG_arg_fail(2)) SWIG_fail;
22074 }
22075 {
22076 PyThreadState* __tstate = wxPyBeginAllowThreads();
22077 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22078
22079 wxPyEndAllowThreads(__tstate);
22080 if (PyErr_Occurred()) SWIG_fail;
22081 }
22082 {
22083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22084 }
22085 return resultobj;
22086 fail:
22087 return NULL;
22088 }
22089
22090
22091 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22092 PyObject *resultobj;
22093 wxDateTime *arg1 = (wxDateTime *) 0 ;
22094 wxDateTime *arg2 = 0 ;
22095 bool result;
22096 PyObject * obj0 = 0 ;
22097 PyObject * obj1 = 0 ;
22098 char *kwnames[] = {
22099 (char *) "self",(char *) "datetime", NULL
22100 };
22101
22102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22104 if (SWIG_arg_fail(1)) SWIG_fail;
22105 {
22106 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22107 if (SWIG_arg_fail(2)) SWIG_fail;
22108 if (arg2 == NULL) {
22109 SWIG_null_ref("wxDateTime");
22110 }
22111 if (SWIG_arg_fail(2)) SWIG_fail;
22112 }
22113 {
22114 PyThreadState* __tstate = wxPyBeginAllowThreads();
22115 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22116
22117 wxPyEndAllowThreads(__tstate);
22118 if (PyErr_Occurred()) SWIG_fail;
22119 }
22120 {
22121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22122 }
22123 return resultobj;
22124 fail:
22125 return NULL;
22126 }
22127
22128
22129 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22130 PyObject *resultobj;
22131 wxDateTime *arg1 = (wxDateTime *) 0 ;
22132 wxDateTime *arg2 = 0 ;
22133 bool result;
22134 PyObject * obj0 = 0 ;
22135 PyObject * obj1 = 0 ;
22136 char *kwnames[] = {
22137 (char *) "self",(char *) "datetime", NULL
22138 };
22139
22140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22142 if (SWIG_arg_fail(1)) SWIG_fail;
22143 {
22144 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22145 if (SWIG_arg_fail(2)) SWIG_fail;
22146 if (arg2 == NULL) {
22147 SWIG_null_ref("wxDateTime");
22148 }
22149 if (SWIG_arg_fail(2)) SWIG_fail;
22150 }
22151 {
22152 PyThreadState* __tstate = wxPyBeginAllowThreads();
22153 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22154
22155 wxPyEndAllowThreads(__tstate);
22156 if (PyErr_Occurred()) SWIG_fail;
22157 }
22158 {
22159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22160 }
22161 return resultobj;
22162 fail:
22163 return NULL;
22164 }
22165
22166
22167 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22168 PyObject *resultobj;
22169 wxDateTime *arg1 = (wxDateTime *) 0 ;
22170 wxDateTime *arg2 = 0 ;
22171 wxDateTime *arg3 = 0 ;
22172 bool result;
22173 PyObject * obj0 = 0 ;
22174 PyObject * obj1 = 0 ;
22175 PyObject * obj2 = 0 ;
22176 char *kwnames[] = {
22177 (char *) "self",(char *) "t1",(char *) "t2", NULL
22178 };
22179
22180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22182 if (SWIG_arg_fail(1)) SWIG_fail;
22183 {
22184 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22185 if (SWIG_arg_fail(2)) SWIG_fail;
22186 if (arg2 == NULL) {
22187 SWIG_null_ref("wxDateTime");
22188 }
22189 if (SWIG_arg_fail(2)) SWIG_fail;
22190 }
22191 {
22192 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22193 if (SWIG_arg_fail(3)) SWIG_fail;
22194 if (arg3 == NULL) {
22195 SWIG_null_ref("wxDateTime");
22196 }
22197 if (SWIG_arg_fail(3)) SWIG_fail;
22198 }
22199 {
22200 PyThreadState* __tstate = wxPyBeginAllowThreads();
22201 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22202
22203 wxPyEndAllowThreads(__tstate);
22204 if (PyErr_Occurred()) SWIG_fail;
22205 }
22206 {
22207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22208 }
22209 return resultobj;
22210 fail:
22211 return NULL;
22212 }
22213
22214
22215 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22216 PyObject *resultobj;
22217 wxDateTime *arg1 = (wxDateTime *) 0 ;
22218 wxDateTime *arg2 = 0 ;
22219 wxDateTime *arg3 = 0 ;
22220 bool result;
22221 PyObject * obj0 = 0 ;
22222 PyObject * obj1 = 0 ;
22223 PyObject * obj2 = 0 ;
22224 char *kwnames[] = {
22225 (char *) "self",(char *) "t1",(char *) "t2", NULL
22226 };
22227
22228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22230 if (SWIG_arg_fail(1)) SWIG_fail;
22231 {
22232 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22233 if (SWIG_arg_fail(2)) SWIG_fail;
22234 if (arg2 == NULL) {
22235 SWIG_null_ref("wxDateTime");
22236 }
22237 if (SWIG_arg_fail(2)) SWIG_fail;
22238 }
22239 {
22240 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22241 if (SWIG_arg_fail(3)) SWIG_fail;
22242 if (arg3 == NULL) {
22243 SWIG_null_ref("wxDateTime");
22244 }
22245 if (SWIG_arg_fail(3)) SWIG_fail;
22246 }
22247 {
22248 PyThreadState* __tstate = wxPyBeginAllowThreads();
22249 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22250
22251 wxPyEndAllowThreads(__tstate);
22252 if (PyErr_Occurred()) SWIG_fail;
22253 }
22254 {
22255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22256 }
22257 return resultobj;
22258 fail:
22259 return NULL;
22260 }
22261
22262
22263 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22264 PyObject *resultobj;
22265 wxDateTime *arg1 = (wxDateTime *) 0 ;
22266 wxDateTime *arg2 = 0 ;
22267 bool result;
22268 PyObject * obj0 = 0 ;
22269 PyObject * obj1 = 0 ;
22270 char *kwnames[] = {
22271 (char *) "self",(char *) "dt", NULL
22272 };
22273
22274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22276 if (SWIG_arg_fail(1)) SWIG_fail;
22277 {
22278 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22279 if (SWIG_arg_fail(2)) SWIG_fail;
22280 if (arg2 == NULL) {
22281 SWIG_null_ref("wxDateTime");
22282 }
22283 if (SWIG_arg_fail(2)) SWIG_fail;
22284 }
22285 {
22286 PyThreadState* __tstate = wxPyBeginAllowThreads();
22287 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22288
22289 wxPyEndAllowThreads(__tstate);
22290 if (PyErr_Occurred()) SWIG_fail;
22291 }
22292 {
22293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22294 }
22295 return resultobj;
22296 fail:
22297 return NULL;
22298 }
22299
22300
22301 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22302 PyObject *resultobj;
22303 wxDateTime *arg1 = (wxDateTime *) 0 ;
22304 wxDateTime *arg2 = 0 ;
22305 bool result;
22306 PyObject * obj0 = 0 ;
22307 PyObject * obj1 = 0 ;
22308 char *kwnames[] = {
22309 (char *) "self",(char *) "dt", NULL
22310 };
22311
22312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22314 if (SWIG_arg_fail(1)) SWIG_fail;
22315 {
22316 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22317 if (SWIG_arg_fail(2)) SWIG_fail;
22318 if (arg2 == NULL) {
22319 SWIG_null_ref("wxDateTime");
22320 }
22321 if (SWIG_arg_fail(2)) SWIG_fail;
22322 }
22323 {
22324 PyThreadState* __tstate = wxPyBeginAllowThreads();
22325 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22326
22327 wxPyEndAllowThreads(__tstate);
22328 if (PyErr_Occurred()) SWIG_fail;
22329 }
22330 {
22331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22332 }
22333 return resultobj;
22334 fail:
22335 return NULL;
22336 }
22337
22338
22339 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22340 PyObject *resultobj;
22341 wxDateTime *arg1 = (wxDateTime *) 0 ;
22342 wxDateTime *arg2 = 0 ;
22343 wxTimeSpan *arg3 = 0 ;
22344 bool result;
22345 PyObject * obj0 = 0 ;
22346 PyObject * obj1 = 0 ;
22347 PyObject * obj2 = 0 ;
22348 char *kwnames[] = {
22349 (char *) "self",(char *) "dt",(char *) "ts", NULL
22350 };
22351
22352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22354 if (SWIG_arg_fail(1)) SWIG_fail;
22355 {
22356 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22357 if (SWIG_arg_fail(2)) SWIG_fail;
22358 if (arg2 == NULL) {
22359 SWIG_null_ref("wxDateTime");
22360 }
22361 if (SWIG_arg_fail(2)) SWIG_fail;
22362 }
22363 {
22364 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22365 if (SWIG_arg_fail(3)) SWIG_fail;
22366 if (arg3 == NULL) {
22367 SWIG_null_ref("wxTimeSpan");
22368 }
22369 if (SWIG_arg_fail(3)) SWIG_fail;
22370 }
22371 {
22372 PyThreadState* __tstate = wxPyBeginAllowThreads();
22373 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22374
22375 wxPyEndAllowThreads(__tstate);
22376 if (PyErr_Occurred()) SWIG_fail;
22377 }
22378 {
22379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22380 }
22381 return resultobj;
22382 fail:
22383 return NULL;
22384 }
22385
22386
22387 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22388 PyObject *resultobj;
22389 wxDateTime *arg1 = (wxDateTime *) 0 ;
22390 wxTimeSpan *arg2 = 0 ;
22391 wxDateTime *result;
22392 PyObject * obj0 = 0 ;
22393 PyObject * obj1 = 0 ;
22394 char *kwnames[] = {
22395 (char *) "self",(char *) "diff", NULL
22396 };
22397
22398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22400 if (SWIG_arg_fail(1)) SWIG_fail;
22401 {
22402 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22403 if (SWIG_arg_fail(2)) SWIG_fail;
22404 if (arg2 == NULL) {
22405 SWIG_null_ref("wxTimeSpan");
22406 }
22407 if (SWIG_arg_fail(2)) SWIG_fail;
22408 }
22409 {
22410 PyThreadState* __tstate = wxPyBeginAllowThreads();
22411 {
22412 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22413 result = (wxDateTime *) &_result_ref;
22414 }
22415
22416 wxPyEndAllowThreads(__tstate);
22417 if (PyErr_Occurred()) SWIG_fail;
22418 }
22419 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22420 return resultobj;
22421 fail:
22422 return NULL;
22423 }
22424
22425
22426 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22427 PyObject *resultobj;
22428 wxDateTime *arg1 = (wxDateTime *) 0 ;
22429 wxDateSpan *arg2 = 0 ;
22430 wxDateTime *result;
22431 PyObject * obj0 = 0 ;
22432 PyObject * obj1 = 0 ;
22433 char *kwnames[] = {
22434 (char *) "self",(char *) "diff", NULL
22435 };
22436
22437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22439 if (SWIG_arg_fail(1)) SWIG_fail;
22440 {
22441 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22442 if (SWIG_arg_fail(2)) SWIG_fail;
22443 if (arg2 == NULL) {
22444 SWIG_null_ref("wxDateSpan");
22445 }
22446 if (SWIG_arg_fail(2)) SWIG_fail;
22447 }
22448 {
22449 PyThreadState* __tstate = wxPyBeginAllowThreads();
22450 {
22451 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22452 result = (wxDateTime *) &_result_ref;
22453 }
22454
22455 wxPyEndAllowThreads(__tstate);
22456 if (PyErr_Occurred()) SWIG_fail;
22457 }
22458 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22459 return resultobj;
22460 fail:
22461 return NULL;
22462 }
22463
22464
22465 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22466 PyObject *resultobj;
22467 wxDateTime *arg1 = (wxDateTime *) 0 ;
22468 wxTimeSpan *arg2 = 0 ;
22469 wxDateTime *result;
22470 PyObject * obj0 = 0 ;
22471 PyObject * obj1 = 0 ;
22472 char *kwnames[] = {
22473 (char *) "self",(char *) "diff", NULL
22474 };
22475
22476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22478 if (SWIG_arg_fail(1)) SWIG_fail;
22479 {
22480 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22481 if (SWIG_arg_fail(2)) SWIG_fail;
22482 if (arg2 == NULL) {
22483 SWIG_null_ref("wxTimeSpan");
22484 }
22485 if (SWIG_arg_fail(2)) SWIG_fail;
22486 }
22487 {
22488 PyThreadState* __tstate = wxPyBeginAllowThreads();
22489 {
22490 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22491 result = (wxDateTime *) &_result_ref;
22492 }
22493
22494 wxPyEndAllowThreads(__tstate);
22495 if (PyErr_Occurred()) SWIG_fail;
22496 }
22497 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22498 return resultobj;
22499 fail:
22500 return NULL;
22501 }
22502
22503
22504 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22505 PyObject *resultobj;
22506 wxDateTime *arg1 = (wxDateTime *) 0 ;
22507 wxDateSpan *arg2 = 0 ;
22508 wxDateTime *result;
22509 PyObject * obj0 = 0 ;
22510 PyObject * obj1 = 0 ;
22511 char *kwnames[] = {
22512 (char *) "self",(char *) "diff", NULL
22513 };
22514
22515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22517 if (SWIG_arg_fail(1)) SWIG_fail;
22518 {
22519 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22520 if (SWIG_arg_fail(2)) SWIG_fail;
22521 if (arg2 == NULL) {
22522 SWIG_null_ref("wxDateSpan");
22523 }
22524 if (SWIG_arg_fail(2)) SWIG_fail;
22525 }
22526 {
22527 PyThreadState* __tstate = wxPyBeginAllowThreads();
22528 {
22529 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22530 result = (wxDateTime *) &_result_ref;
22531 }
22532
22533 wxPyEndAllowThreads(__tstate);
22534 if (PyErr_Occurred()) SWIG_fail;
22535 }
22536 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22537 return resultobj;
22538 fail:
22539 return NULL;
22540 }
22541
22542
22543 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22544 PyObject *resultobj;
22545 wxDateTime *arg1 = (wxDateTime *) 0 ;
22546 wxDateTime *arg2 = 0 ;
22547 wxTimeSpan result;
22548 PyObject * obj0 = 0 ;
22549 PyObject * obj1 = 0 ;
22550 char *kwnames[] = {
22551 (char *) "self",(char *) "dt", NULL
22552 };
22553
22554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22556 if (SWIG_arg_fail(1)) SWIG_fail;
22557 {
22558 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22559 if (SWIG_arg_fail(2)) SWIG_fail;
22560 if (arg2 == NULL) {
22561 SWIG_null_ref("wxDateTime");
22562 }
22563 if (SWIG_arg_fail(2)) SWIG_fail;
22564 }
22565 {
22566 PyThreadState* __tstate = wxPyBeginAllowThreads();
22567 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22568
22569 wxPyEndAllowThreads(__tstate);
22570 if (PyErr_Occurred()) SWIG_fail;
22571 }
22572 {
22573 wxTimeSpan * resultptr;
22574 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22575 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22576 }
22577 return resultobj;
22578 fail:
22579 return NULL;
22580 }
22581
22582
22583 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22584 PyObject *resultobj;
22585 wxDateTime *arg1 = (wxDateTime *) 0 ;
22586 wxTimeSpan *arg2 = 0 ;
22587 wxDateTime *result;
22588 PyObject * obj0 = 0 ;
22589 PyObject * obj1 = 0 ;
22590
22591 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22593 if (SWIG_arg_fail(1)) SWIG_fail;
22594 {
22595 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22596 if (SWIG_arg_fail(2)) SWIG_fail;
22597 if (arg2 == NULL) {
22598 SWIG_null_ref("wxTimeSpan");
22599 }
22600 if (SWIG_arg_fail(2)) SWIG_fail;
22601 }
22602 {
22603 PyThreadState* __tstate = wxPyBeginAllowThreads();
22604 {
22605 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22606 result = (wxDateTime *) &_result_ref;
22607 }
22608
22609 wxPyEndAllowThreads(__tstate);
22610 if (PyErr_Occurred()) SWIG_fail;
22611 }
22612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22613 return resultobj;
22614 fail:
22615 return NULL;
22616 }
22617
22618
22619 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22620 PyObject *resultobj;
22621 wxDateTime *arg1 = (wxDateTime *) 0 ;
22622 wxDateSpan *arg2 = 0 ;
22623 wxDateTime *result;
22624 PyObject * obj0 = 0 ;
22625 PyObject * obj1 = 0 ;
22626
22627 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22629 if (SWIG_arg_fail(1)) SWIG_fail;
22630 {
22631 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22632 if (SWIG_arg_fail(2)) SWIG_fail;
22633 if (arg2 == NULL) {
22634 SWIG_null_ref("wxDateSpan");
22635 }
22636 if (SWIG_arg_fail(2)) SWIG_fail;
22637 }
22638 {
22639 PyThreadState* __tstate = wxPyBeginAllowThreads();
22640 {
22641 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22642 result = (wxDateTime *) &_result_ref;
22643 }
22644
22645 wxPyEndAllowThreads(__tstate);
22646 if (PyErr_Occurred()) SWIG_fail;
22647 }
22648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22649 return resultobj;
22650 fail:
22651 return NULL;
22652 }
22653
22654
22655 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22656 int argc;
22657 PyObject *argv[3];
22658 int ii;
22659
22660 argc = PyObject_Length(args);
22661 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22662 argv[ii] = PyTuple_GetItem(args,ii);
22663 }
22664 if (argc == 2) {
22665 int _v;
22666 {
22667 void *ptr;
22668 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22669 _v = 0;
22670 PyErr_Clear();
22671 } else {
22672 _v = 1;
22673 }
22674 }
22675 if (_v) {
22676 {
22677 void *ptr = 0;
22678 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22679 _v = 0;
22680 PyErr_Clear();
22681 } else {
22682 _v = (ptr != 0);
22683 }
22684 }
22685 if (_v) {
22686 return _wrap_DateTime___iadd____SWIG_0(self,args);
22687 }
22688 }
22689 }
22690 if (argc == 2) {
22691 int _v;
22692 {
22693 void *ptr;
22694 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22695 _v = 0;
22696 PyErr_Clear();
22697 } else {
22698 _v = 1;
22699 }
22700 }
22701 if (_v) {
22702 {
22703 void *ptr = 0;
22704 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22705 _v = 0;
22706 PyErr_Clear();
22707 } else {
22708 _v = (ptr != 0);
22709 }
22710 }
22711 if (_v) {
22712 return _wrap_DateTime___iadd____SWIG_1(self,args);
22713 }
22714 }
22715 }
22716
22717 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22718 return NULL;
22719 }
22720
22721
22722 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22723 PyObject *resultobj;
22724 wxDateTime *arg1 = (wxDateTime *) 0 ;
22725 wxTimeSpan *arg2 = 0 ;
22726 wxDateTime *result;
22727 PyObject * obj0 = 0 ;
22728 PyObject * obj1 = 0 ;
22729
22730 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22732 if (SWIG_arg_fail(1)) SWIG_fail;
22733 {
22734 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22735 if (SWIG_arg_fail(2)) SWIG_fail;
22736 if (arg2 == NULL) {
22737 SWIG_null_ref("wxTimeSpan");
22738 }
22739 if (SWIG_arg_fail(2)) SWIG_fail;
22740 }
22741 {
22742 PyThreadState* __tstate = wxPyBeginAllowThreads();
22743 {
22744 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22745 result = (wxDateTime *) &_result_ref;
22746 }
22747
22748 wxPyEndAllowThreads(__tstate);
22749 if (PyErr_Occurred()) SWIG_fail;
22750 }
22751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22752 return resultobj;
22753 fail:
22754 return NULL;
22755 }
22756
22757
22758 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22759 PyObject *resultobj;
22760 wxDateTime *arg1 = (wxDateTime *) 0 ;
22761 wxDateSpan *arg2 = 0 ;
22762 wxDateTime *result;
22763 PyObject * obj0 = 0 ;
22764 PyObject * obj1 = 0 ;
22765
22766 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22768 if (SWIG_arg_fail(1)) SWIG_fail;
22769 {
22770 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22771 if (SWIG_arg_fail(2)) SWIG_fail;
22772 if (arg2 == NULL) {
22773 SWIG_null_ref("wxDateSpan");
22774 }
22775 if (SWIG_arg_fail(2)) SWIG_fail;
22776 }
22777 {
22778 PyThreadState* __tstate = wxPyBeginAllowThreads();
22779 {
22780 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22781 result = (wxDateTime *) &_result_ref;
22782 }
22783
22784 wxPyEndAllowThreads(__tstate);
22785 if (PyErr_Occurred()) SWIG_fail;
22786 }
22787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22788 return resultobj;
22789 fail:
22790 return NULL;
22791 }
22792
22793
22794 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22795 int argc;
22796 PyObject *argv[3];
22797 int ii;
22798
22799 argc = PyObject_Length(args);
22800 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22801 argv[ii] = PyTuple_GetItem(args,ii);
22802 }
22803 if (argc == 2) {
22804 int _v;
22805 {
22806 void *ptr;
22807 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22808 _v = 0;
22809 PyErr_Clear();
22810 } else {
22811 _v = 1;
22812 }
22813 }
22814 if (_v) {
22815 {
22816 void *ptr = 0;
22817 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22818 _v = 0;
22819 PyErr_Clear();
22820 } else {
22821 _v = (ptr != 0);
22822 }
22823 }
22824 if (_v) {
22825 return _wrap_DateTime___isub____SWIG_0(self,args);
22826 }
22827 }
22828 }
22829 if (argc == 2) {
22830 int _v;
22831 {
22832 void *ptr;
22833 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22834 _v = 0;
22835 PyErr_Clear();
22836 } else {
22837 _v = 1;
22838 }
22839 }
22840 if (_v) {
22841 {
22842 void *ptr = 0;
22843 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22844 _v = 0;
22845 PyErr_Clear();
22846 } else {
22847 _v = (ptr != 0);
22848 }
22849 }
22850 if (_v) {
22851 return _wrap_DateTime___isub____SWIG_1(self,args);
22852 }
22853 }
22854 }
22855
22856 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22857 return NULL;
22858 }
22859
22860
22861 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22862 PyObject *resultobj;
22863 wxDateTime *arg1 = (wxDateTime *) 0 ;
22864 wxTimeSpan *arg2 = 0 ;
22865 wxDateTime result;
22866 PyObject * obj0 = 0 ;
22867 PyObject * obj1 = 0 ;
22868
22869 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22871 if (SWIG_arg_fail(1)) SWIG_fail;
22872 {
22873 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22874 if (SWIG_arg_fail(2)) SWIG_fail;
22875 if (arg2 == NULL) {
22876 SWIG_null_ref("wxTimeSpan");
22877 }
22878 if (SWIG_arg_fail(2)) SWIG_fail;
22879 }
22880 {
22881 PyThreadState* __tstate = wxPyBeginAllowThreads();
22882 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22883
22884 wxPyEndAllowThreads(__tstate);
22885 if (PyErr_Occurred()) SWIG_fail;
22886 }
22887 {
22888 wxDateTime * resultptr;
22889 resultptr = new wxDateTime((wxDateTime &)(result));
22890 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22891 }
22892 return resultobj;
22893 fail:
22894 return NULL;
22895 }
22896
22897
22898 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22899 PyObject *resultobj;
22900 wxDateTime *arg1 = (wxDateTime *) 0 ;
22901 wxDateSpan *arg2 = 0 ;
22902 wxDateTime result;
22903 PyObject * obj0 = 0 ;
22904 PyObject * obj1 = 0 ;
22905
22906 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22908 if (SWIG_arg_fail(1)) SWIG_fail;
22909 {
22910 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22911 if (SWIG_arg_fail(2)) SWIG_fail;
22912 if (arg2 == NULL) {
22913 SWIG_null_ref("wxDateSpan");
22914 }
22915 if (SWIG_arg_fail(2)) SWIG_fail;
22916 }
22917 {
22918 PyThreadState* __tstate = wxPyBeginAllowThreads();
22919 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22920
22921 wxPyEndAllowThreads(__tstate);
22922 if (PyErr_Occurred()) SWIG_fail;
22923 }
22924 {
22925 wxDateTime * resultptr;
22926 resultptr = new wxDateTime((wxDateTime &)(result));
22927 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22928 }
22929 return resultobj;
22930 fail:
22931 return NULL;
22932 }
22933
22934
22935 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22936 int argc;
22937 PyObject *argv[3];
22938 int ii;
22939
22940 argc = PyObject_Length(args);
22941 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22942 argv[ii] = PyTuple_GetItem(args,ii);
22943 }
22944 if (argc == 2) {
22945 int _v;
22946 {
22947 void *ptr;
22948 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22949 _v = 0;
22950 PyErr_Clear();
22951 } else {
22952 _v = 1;
22953 }
22954 }
22955 if (_v) {
22956 {
22957 void *ptr = 0;
22958 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22959 _v = 0;
22960 PyErr_Clear();
22961 } else {
22962 _v = (ptr != 0);
22963 }
22964 }
22965 if (_v) {
22966 return _wrap_DateTime___add____SWIG_0(self,args);
22967 }
22968 }
22969 }
22970 if (argc == 2) {
22971 int _v;
22972 {
22973 void *ptr;
22974 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22975 _v = 0;
22976 PyErr_Clear();
22977 } else {
22978 _v = 1;
22979 }
22980 }
22981 if (_v) {
22982 {
22983 void *ptr = 0;
22984 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22985 _v = 0;
22986 PyErr_Clear();
22987 } else {
22988 _v = (ptr != 0);
22989 }
22990 }
22991 if (_v) {
22992 return _wrap_DateTime___add____SWIG_1(self,args);
22993 }
22994 }
22995 }
22996
22997 Py_INCREF(Py_NotImplemented);
22998 return Py_NotImplemented;
22999 }
23000
23001
23002 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
23003 PyObject *resultobj;
23004 wxDateTime *arg1 = (wxDateTime *) 0 ;
23005 wxDateTime *arg2 = 0 ;
23006 wxTimeSpan result;
23007 PyObject * obj0 = 0 ;
23008 PyObject * obj1 = 0 ;
23009
23010 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23012 if (SWIG_arg_fail(1)) SWIG_fail;
23013 {
23014 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23015 if (SWIG_arg_fail(2)) SWIG_fail;
23016 if (arg2 == NULL) {
23017 SWIG_null_ref("wxDateTime");
23018 }
23019 if (SWIG_arg_fail(2)) SWIG_fail;
23020 }
23021 {
23022 PyThreadState* __tstate = wxPyBeginAllowThreads();
23023 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
23024
23025 wxPyEndAllowThreads(__tstate);
23026 if (PyErr_Occurred()) SWIG_fail;
23027 }
23028 {
23029 wxTimeSpan * resultptr;
23030 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23031 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23032 }
23033 return resultobj;
23034 fail:
23035 return NULL;
23036 }
23037
23038
23039 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23040 PyObject *resultobj;
23041 wxDateTime *arg1 = (wxDateTime *) 0 ;
23042 wxTimeSpan *arg2 = 0 ;
23043 wxDateTime result;
23044 PyObject * obj0 = 0 ;
23045 PyObject * obj1 = 0 ;
23046
23047 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23049 if (SWIG_arg_fail(1)) SWIG_fail;
23050 {
23051 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23052 if (SWIG_arg_fail(2)) SWIG_fail;
23053 if (arg2 == NULL) {
23054 SWIG_null_ref("wxTimeSpan");
23055 }
23056 if (SWIG_arg_fail(2)) SWIG_fail;
23057 }
23058 {
23059 PyThreadState* __tstate = wxPyBeginAllowThreads();
23060 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23061
23062 wxPyEndAllowThreads(__tstate);
23063 if (PyErr_Occurred()) SWIG_fail;
23064 }
23065 {
23066 wxDateTime * resultptr;
23067 resultptr = new wxDateTime((wxDateTime &)(result));
23068 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23069 }
23070 return resultobj;
23071 fail:
23072 return NULL;
23073 }
23074
23075
23076 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23077 PyObject *resultobj;
23078 wxDateTime *arg1 = (wxDateTime *) 0 ;
23079 wxDateSpan *arg2 = 0 ;
23080 wxDateTime result;
23081 PyObject * obj0 = 0 ;
23082 PyObject * obj1 = 0 ;
23083
23084 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23086 if (SWIG_arg_fail(1)) SWIG_fail;
23087 {
23088 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23089 if (SWIG_arg_fail(2)) SWIG_fail;
23090 if (arg2 == NULL) {
23091 SWIG_null_ref("wxDateSpan");
23092 }
23093 if (SWIG_arg_fail(2)) SWIG_fail;
23094 }
23095 {
23096 PyThreadState* __tstate = wxPyBeginAllowThreads();
23097 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23098
23099 wxPyEndAllowThreads(__tstate);
23100 if (PyErr_Occurred()) SWIG_fail;
23101 }
23102 {
23103 wxDateTime * resultptr;
23104 resultptr = new wxDateTime((wxDateTime &)(result));
23105 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23106 }
23107 return resultobj;
23108 fail:
23109 return NULL;
23110 }
23111
23112
23113 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23114 int argc;
23115 PyObject *argv[3];
23116 int ii;
23117
23118 argc = PyObject_Length(args);
23119 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23120 argv[ii] = PyTuple_GetItem(args,ii);
23121 }
23122 if (argc == 2) {
23123 int _v;
23124 {
23125 void *ptr;
23126 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23127 _v = 0;
23128 PyErr_Clear();
23129 } else {
23130 _v = 1;
23131 }
23132 }
23133 if (_v) {
23134 {
23135 void *ptr = 0;
23136 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23137 _v = 0;
23138 PyErr_Clear();
23139 } else {
23140 _v = (ptr != 0);
23141 }
23142 }
23143 if (_v) {
23144 return _wrap_DateTime___sub____SWIG_0(self,args);
23145 }
23146 }
23147 }
23148 if (argc == 2) {
23149 int _v;
23150 {
23151 void *ptr;
23152 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23153 _v = 0;
23154 PyErr_Clear();
23155 } else {
23156 _v = 1;
23157 }
23158 }
23159 if (_v) {
23160 {
23161 void *ptr = 0;
23162 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23163 _v = 0;
23164 PyErr_Clear();
23165 } else {
23166 _v = (ptr != 0);
23167 }
23168 }
23169 if (_v) {
23170 return _wrap_DateTime___sub____SWIG_1(self,args);
23171 }
23172 }
23173 }
23174 if (argc == 2) {
23175 int _v;
23176 {
23177 void *ptr;
23178 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23179 _v = 0;
23180 PyErr_Clear();
23181 } else {
23182 _v = 1;
23183 }
23184 }
23185 if (_v) {
23186 {
23187 void *ptr = 0;
23188 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23189 _v = 0;
23190 PyErr_Clear();
23191 } else {
23192 _v = (ptr != 0);
23193 }
23194 }
23195 if (_v) {
23196 return _wrap_DateTime___sub____SWIG_2(self,args);
23197 }
23198 }
23199 }
23200
23201 Py_INCREF(Py_NotImplemented);
23202 return Py_NotImplemented;
23203 }
23204
23205
23206 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23207 PyObject *resultobj;
23208 wxDateTime *arg1 = (wxDateTime *) 0 ;
23209 wxDateTime *arg2 = (wxDateTime *) 0 ;
23210 bool result;
23211 PyObject * obj0 = 0 ;
23212 PyObject * obj1 = 0 ;
23213 char *kwnames[] = {
23214 (char *) "self",(char *) "other", NULL
23215 };
23216
23217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23219 if (SWIG_arg_fail(1)) SWIG_fail;
23220 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23221 if (SWIG_arg_fail(2)) SWIG_fail;
23222 {
23223 PyThreadState* __tstate = wxPyBeginAllowThreads();
23224 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23225
23226 wxPyEndAllowThreads(__tstate);
23227 if (PyErr_Occurred()) SWIG_fail;
23228 }
23229 {
23230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23231 }
23232 return resultobj;
23233 fail:
23234 return NULL;
23235 }
23236
23237
23238 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23239 PyObject *resultobj;
23240 wxDateTime *arg1 = (wxDateTime *) 0 ;
23241 wxDateTime *arg2 = (wxDateTime *) 0 ;
23242 bool result;
23243 PyObject * obj0 = 0 ;
23244 PyObject * obj1 = 0 ;
23245 char *kwnames[] = {
23246 (char *) "self",(char *) "other", NULL
23247 };
23248
23249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23251 if (SWIG_arg_fail(1)) SWIG_fail;
23252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23253 if (SWIG_arg_fail(2)) SWIG_fail;
23254 {
23255 PyThreadState* __tstate = wxPyBeginAllowThreads();
23256 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23257
23258 wxPyEndAllowThreads(__tstate);
23259 if (PyErr_Occurred()) SWIG_fail;
23260 }
23261 {
23262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23263 }
23264 return resultobj;
23265 fail:
23266 return NULL;
23267 }
23268
23269
23270 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23271 PyObject *resultobj;
23272 wxDateTime *arg1 = (wxDateTime *) 0 ;
23273 wxDateTime *arg2 = (wxDateTime *) 0 ;
23274 bool result;
23275 PyObject * obj0 = 0 ;
23276 PyObject * obj1 = 0 ;
23277 char *kwnames[] = {
23278 (char *) "self",(char *) "other", NULL
23279 };
23280
23281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23283 if (SWIG_arg_fail(1)) SWIG_fail;
23284 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23285 if (SWIG_arg_fail(2)) SWIG_fail;
23286 {
23287 PyThreadState* __tstate = wxPyBeginAllowThreads();
23288 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23289
23290 wxPyEndAllowThreads(__tstate);
23291 if (PyErr_Occurred()) SWIG_fail;
23292 }
23293 {
23294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23295 }
23296 return resultobj;
23297 fail:
23298 return NULL;
23299 }
23300
23301
23302 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23303 PyObject *resultobj;
23304 wxDateTime *arg1 = (wxDateTime *) 0 ;
23305 wxDateTime *arg2 = (wxDateTime *) 0 ;
23306 bool result;
23307 PyObject * obj0 = 0 ;
23308 PyObject * obj1 = 0 ;
23309 char *kwnames[] = {
23310 (char *) "self",(char *) "other", NULL
23311 };
23312
23313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23315 if (SWIG_arg_fail(1)) SWIG_fail;
23316 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23317 if (SWIG_arg_fail(2)) SWIG_fail;
23318 {
23319 PyThreadState* __tstate = wxPyBeginAllowThreads();
23320 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23321
23322 wxPyEndAllowThreads(__tstate);
23323 if (PyErr_Occurred()) SWIG_fail;
23324 }
23325 {
23326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23327 }
23328 return resultobj;
23329 fail:
23330 return NULL;
23331 }
23332
23333
23334 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23335 PyObject *resultobj;
23336 wxDateTime *arg1 = (wxDateTime *) 0 ;
23337 wxDateTime *arg2 = (wxDateTime *) 0 ;
23338 bool result;
23339 PyObject * obj0 = 0 ;
23340 PyObject * obj1 = 0 ;
23341 char *kwnames[] = {
23342 (char *) "self",(char *) "other", NULL
23343 };
23344
23345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23347 if (SWIG_arg_fail(1)) SWIG_fail;
23348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23349 if (SWIG_arg_fail(2)) SWIG_fail;
23350 {
23351 PyThreadState* __tstate = wxPyBeginAllowThreads();
23352 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23353
23354 wxPyEndAllowThreads(__tstate);
23355 if (PyErr_Occurred()) SWIG_fail;
23356 }
23357 {
23358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23359 }
23360 return resultobj;
23361 fail:
23362 return NULL;
23363 }
23364
23365
23366 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23367 PyObject *resultobj;
23368 wxDateTime *arg1 = (wxDateTime *) 0 ;
23369 wxDateTime *arg2 = (wxDateTime *) 0 ;
23370 bool result;
23371 PyObject * obj0 = 0 ;
23372 PyObject * obj1 = 0 ;
23373 char *kwnames[] = {
23374 (char *) "self",(char *) "other", NULL
23375 };
23376
23377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23379 if (SWIG_arg_fail(1)) SWIG_fail;
23380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23381 if (SWIG_arg_fail(2)) SWIG_fail;
23382 {
23383 PyThreadState* __tstate = wxPyBeginAllowThreads();
23384 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23385
23386 wxPyEndAllowThreads(__tstate);
23387 if (PyErr_Occurred()) SWIG_fail;
23388 }
23389 {
23390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23391 }
23392 return resultobj;
23393 fail:
23394 return NULL;
23395 }
23396
23397
23398 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23399 PyObject *resultobj;
23400 wxDateTime *arg1 = (wxDateTime *) 0 ;
23401 wxString *arg2 = 0 ;
23402 int result;
23403 bool temp2 = false ;
23404 PyObject * obj0 = 0 ;
23405 PyObject * obj1 = 0 ;
23406 char *kwnames[] = {
23407 (char *) "self",(char *) "date", NULL
23408 };
23409
23410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23412 if (SWIG_arg_fail(1)) SWIG_fail;
23413 {
23414 arg2 = wxString_in_helper(obj1);
23415 if (arg2 == NULL) SWIG_fail;
23416 temp2 = true;
23417 }
23418 {
23419 PyThreadState* __tstate = wxPyBeginAllowThreads();
23420 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23421
23422 wxPyEndAllowThreads(__tstate);
23423 if (PyErr_Occurred()) SWIG_fail;
23424 }
23425 {
23426 resultobj = SWIG_From_int((int)(result));
23427 }
23428 {
23429 if (temp2)
23430 delete arg2;
23431 }
23432 return resultobj;
23433 fail:
23434 {
23435 if (temp2)
23436 delete arg2;
23437 }
23438 return NULL;
23439 }
23440
23441
23442 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23443 PyObject *resultobj;
23444 wxDateTime *arg1 = (wxDateTime *) 0 ;
23445 wxString *arg2 = 0 ;
23446 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23447 wxString *arg3 = (wxString *) &arg3_defvalue ;
23448 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23449 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23450 int result;
23451 bool temp2 = false ;
23452 bool temp3 = false ;
23453 PyObject * obj0 = 0 ;
23454 PyObject * obj1 = 0 ;
23455 PyObject * obj2 = 0 ;
23456 PyObject * obj3 = 0 ;
23457 char *kwnames[] = {
23458 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23459 };
23460
23461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23463 if (SWIG_arg_fail(1)) SWIG_fail;
23464 {
23465 arg2 = wxString_in_helper(obj1);
23466 if (arg2 == NULL) SWIG_fail;
23467 temp2 = true;
23468 }
23469 if (obj2) {
23470 {
23471 arg3 = wxString_in_helper(obj2);
23472 if (arg3 == NULL) SWIG_fail;
23473 temp3 = true;
23474 }
23475 }
23476 if (obj3) {
23477 {
23478 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23479 if (SWIG_arg_fail(4)) SWIG_fail;
23480 if (arg4 == NULL) {
23481 SWIG_null_ref("wxDateTime");
23482 }
23483 if (SWIG_arg_fail(4)) SWIG_fail;
23484 }
23485 }
23486 {
23487 PyThreadState* __tstate = wxPyBeginAllowThreads();
23488 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23489
23490 wxPyEndAllowThreads(__tstate);
23491 if (PyErr_Occurred()) SWIG_fail;
23492 }
23493 {
23494 resultobj = SWIG_From_int((int)(result));
23495 }
23496 {
23497 if (temp2)
23498 delete arg2;
23499 }
23500 {
23501 if (temp3)
23502 delete arg3;
23503 }
23504 return resultobj;
23505 fail:
23506 {
23507 if (temp2)
23508 delete arg2;
23509 }
23510 {
23511 if (temp3)
23512 delete arg3;
23513 }
23514 return NULL;
23515 }
23516
23517
23518 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23519 PyObject *resultobj;
23520 wxDateTime *arg1 = (wxDateTime *) 0 ;
23521 wxString *arg2 = 0 ;
23522 int result;
23523 bool temp2 = false ;
23524 PyObject * obj0 = 0 ;
23525 PyObject * obj1 = 0 ;
23526 char *kwnames[] = {
23527 (char *) "self",(char *) "datetime", NULL
23528 };
23529
23530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23532 if (SWIG_arg_fail(1)) SWIG_fail;
23533 {
23534 arg2 = wxString_in_helper(obj1);
23535 if (arg2 == NULL) SWIG_fail;
23536 temp2 = true;
23537 }
23538 {
23539 PyThreadState* __tstate = wxPyBeginAllowThreads();
23540 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23541
23542 wxPyEndAllowThreads(__tstate);
23543 if (PyErr_Occurred()) SWIG_fail;
23544 }
23545 {
23546 resultobj = SWIG_From_int((int)(result));
23547 }
23548 {
23549 if (temp2)
23550 delete arg2;
23551 }
23552 return resultobj;
23553 fail:
23554 {
23555 if (temp2)
23556 delete arg2;
23557 }
23558 return NULL;
23559 }
23560
23561
23562 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23563 PyObject *resultobj;
23564 wxDateTime *arg1 = (wxDateTime *) 0 ;
23565 wxString *arg2 = 0 ;
23566 int result;
23567 bool temp2 = false ;
23568 PyObject * obj0 = 0 ;
23569 PyObject * obj1 = 0 ;
23570 char *kwnames[] = {
23571 (char *) "self",(char *) "date", NULL
23572 };
23573
23574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23576 if (SWIG_arg_fail(1)) SWIG_fail;
23577 {
23578 arg2 = wxString_in_helper(obj1);
23579 if (arg2 == NULL) SWIG_fail;
23580 temp2 = true;
23581 }
23582 {
23583 PyThreadState* __tstate = wxPyBeginAllowThreads();
23584 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23585
23586 wxPyEndAllowThreads(__tstate);
23587 if (PyErr_Occurred()) SWIG_fail;
23588 }
23589 {
23590 resultobj = SWIG_From_int((int)(result));
23591 }
23592 {
23593 if (temp2)
23594 delete arg2;
23595 }
23596 return resultobj;
23597 fail:
23598 {
23599 if (temp2)
23600 delete arg2;
23601 }
23602 return NULL;
23603 }
23604
23605
23606 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23607 PyObject *resultobj;
23608 wxDateTime *arg1 = (wxDateTime *) 0 ;
23609 wxString *arg2 = 0 ;
23610 int result;
23611 bool temp2 = false ;
23612 PyObject * obj0 = 0 ;
23613 PyObject * obj1 = 0 ;
23614 char *kwnames[] = {
23615 (char *) "self",(char *) "time", NULL
23616 };
23617
23618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23620 if (SWIG_arg_fail(1)) SWIG_fail;
23621 {
23622 arg2 = wxString_in_helper(obj1);
23623 if (arg2 == NULL) SWIG_fail;
23624 temp2 = true;
23625 }
23626 {
23627 PyThreadState* __tstate = wxPyBeginAllowThreads();
23628 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23629
23630 wxPyEndAllowThreads(__tstate);
23631 if (PyErr_Occurred()) SWIG_fail;
23632 }
23633 {
23634 resultobj = SWIG_From_int((int)(result));
23635 }
23636 {
23637 if (temp2)
23638 delete arg2;
23639 }
23640 return resultobj;
23641 fail:
23642 {
23643 if (temp2)
23644 delete arg2;
23645 }
23646 return NULL;
23647 }
23648
23649
23650 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23651 PyObject *resultobj;
23652 wxDateTime *arg1 = (wxDateTime *) 0 ;
23653 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23654 wxString *arg2 = (wxString *) &arg2_defvalue ;
23655 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23656 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23657 wxString result;
23658 bool temp2 = false ;
23659 bool temp3 = false ;
23660 PyObject * obj0 = 0 ;
23661 PyObject * obj1 = 0 ;
23662 PyObject * obj2 = 0 ;
23663 char *kwnames[] = {
23664 (char *) "self",(char *) "format",(char *) "tz", NULL
23665 };
23666
23667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23669 if (SWIG_arg_fail(1)) SWIG_fail;
23670 if (obj1) {
23671 {
23672 arg2 = wxString_in_helper(obj1);
23673 if (arg2 == NULL) SWIG_fail;
23674 temp2 = true;
23675 }
23676 }
23677 if (obj2) {
23678 {
23679 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23680 temp3 = true;
23681 }
23682 }
23683 {
23684 PyThreadState* __tstate = wxPyBeginAllowThreads();
23685 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23686
23687 wxPyEndAllowThreads(__tstate);
23688 if (PyErr_Occurred()) SWIG_fail;
23689 }
23690 {
23691 #if wxUSE_UNICODE
23692 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23693 #else
23694 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23695 #endif
23696 }
23697 {
23698 if (temp2)
23699 delete arg2;
23700 }
23701 {
23702 if (temp3) delete arg3;
23703 }
23704 return resultobj;
23705 fail:
23706 {
23707 if (temp2)
23708 delete arg2;
23709 }
23710 {
23711 if (temp3) delete arg3;
23712 }
23713 return NULL;
23714 }
23715
23716
23717 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23718 PyObject *resultobj;
23719 wxDateTime *arg1 = (wxDateTime *) 0 ;
23720 wxString result;
23721 PyObject * obj0 = 0 ;
23722 char *kwnames[] = {
23723 (char *) "self", NULL
23724 };
23725
23726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23728 if (SWIG_arg_fail(1)) SWIG_fail;
23729 {
23730 PyThreadState* __tstate = wxPyBeginAllowThreads();
23731 result = ((wxDateTime const *)arg1)->FormatDate();
23732
23733 wxPyEndAllowThreads(__tstate);
23734 if (PyErr_Occurred()) SWIG_fail;
23735 }
23736 {
23737 #if wxUSE_UNICODE
23738 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23739 #else
23740 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23741 #endif
23742 }
23743 return resultobj;
23744 fail:
23745 return NULL;
23746 }
23747
23748
23749 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23750 PyObject *resultobj;
23751 wxDateTime *arg1 = (wxDateTime *) 0 ;
23752 wxString result;
23753 PyObject * obj0 = 0 ;
23754 char *kwnames[] = {
23755 (char *) "self", NULL
23756 };
23757
23758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23760 if (SWIG_arg_fail(1)) SWIG_fail;
23761 {
23762 PyThreadState* __tstate = wxPyBeginAllowThreads();
23763 result = ((wxDateTime const *)arg1)->FormatTime();
23764
23765 wxPyEndAllowThreads(__tstate);
23766 if (PyErr_Occurred()) SWIG_fail;
23767 }
23768 {
23769 #if wxUSE_UNICODE
23770 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23771 #else
23772 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23773 #endif
23774 }
23775 return resultobj;
23776 fail:
23777 return NULL;
23778 }
23779
23780
23781 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23782 PyObject *resultobj;
23783 wxDateTime *arg1 = (wxDateTime *) 0 ;
23784 wxString result;
23785 PyObject * obj0 = 0 ;
23786 char *kwnames[] = {
23787 (char *) "self", NULL
23788 };
23789
23790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23792 if (SWIG_arg_fail(1)) SWIG_fail;
23793 {
23794 PyThreadState* __tstate = wxPyBeginAllowThreads();
23795 result = ((wxDateTime const *)arg1)->FormatISODate();
23796
23797 wxPyEndAllowThreads(__tstate);
23798 if (PyErr_Occurred()) SWIG_fail;
23799 }
23800 {
23801 #if wxUSE_UNICODE
23802 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23803 #else
23804 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23805 #endif
23806 }
23807 return resultobj;
23808 fail:
23809 return NULL;
23810 }
23811
23812
23813 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23814 PyObject *resultobj;
23815 wxDateTime *arg1 = (wxDateTime *) 0 ;
23816 wxString result;
23817 PyObject * obj0 = 0 ;
23818 char *kwnames[] = {
23819 (char *) "self", NULL
23820 };
23821
23822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23824 if (SWIG_arg_fail(1)) SWIG_fail;
23825 {
23826 PyThreadState* __tstate = wxPyBeginAllowThreads();
23827 result = ((wxDateTime const *)arg1)->FormatISOTime();
23828
23829 wxPyEndAllowThreads(__tstate);
23830 if (PyErr_Occurred()) SWIG_fail;
23831 }
23832 {
23833 #if wxUSE_UNICODE
23834 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23835 #else
23836 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23837 #endif
23838 }
23839 return resultobj;
23840 fail:
23841 return NULL;
23842 }
23843
23844
23845 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23846 PyObject *obj;
23847 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23848 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23849 Py_INCREF(obj);
23850 return Py_BuildValue((char *)"");
23851 }
23852 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23853 PyObject *resultobj;
23854 long arg1 ;
23855 wxTimeSpan result;
23856 PyObject * obj0 = 0 ;
23857 char *kwnames[] = {
23858 (char *) "sec", NULL
23859 };
23860
23861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23862 {
23863 arg1 = (long)(SWIG_As_long(obj0));
23864 if (SWIG_arg_fail(1)) SWIG_fail;
23865 }
23866 {
23867 PyThreadState* __tstate = wxPyBeginAllowThreads();
23868 result = wxTimeSpan::Seconds(arg1);
23869
23870 wxPyEndAllowThreads(__tstate);
23871 if (PyErr_Occurred()) SWIG_fail;
23872 }
23873 {
23874 wxTimeSpan * resultptr;
23875 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23876 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23877 }
23878 return resultobj;
23879 fail:
23880 return NULL;
23881 }
23882
23883
23884 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23885 PyObject *resultobj;
23886 wxTimeSpan result;
23887 char *kwnames[] = {
23888 NULL
23889 };
23890
23891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23892 {
23893 PyThreadState* __tstate = wxPyBeginAllowThreads();
23894 result = wxTimeSpan::Second();
23895
23896 wxPyEndAllowThreads(__tstate);
23897 if (PyErr_Occurred()) SWIG_fail;
23898 }
23899 {
23900 wxTimeSpan * resultptr;
23901 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23902 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23903 }
23904 return resultobj;
23905 fail:
23906 return NULL;
23907 }
23908
23909
23910 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23911 PyObject *resultobj;
23912 long arg1 ;
23913 wxTimeSpan result;
23914 PyObject * obj0 = 0 ;
23915 char *kwnames[] = {
23916 (char *) "min", NULL
23917 };
23918
23919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23920 {
23921 arg1 = (long)(SWIG_As_long(obj0));
23922 if (SWIG_arg_fail(1)) SWIG_fail;
23923 }
23924 {
23925 PyThreadState* __tstate = wxPyBeginAllowThreads();
23926 result = wxTimeSpan::Minutes(arg1);
23927
23928 wxPyEndAllowThreads(__tstate);
23929 if (PyErr_Occurred()) SWIG_fail;
23930 }
23931 {
23932 wxTimeSpan * resultptr;
23933 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23934 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23935 }
23936 return resultobj;
23937 fail:
23938 return NULL;
23939 }
23940
23941
23942 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23943 PyObject *resultobj;
23944 wxTimeSpan result;
23945 char *kwnames[] = {
23946 NULL
23947 };
23948
23949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23950 {
23951 PyThreadState* __tstate = wxPyBeginAllowThreads();
23952 result = wxTimeSpan::Minute();
23953
23954 wxPyEndAllowThreads(__tstate);
23955 if (PyErr_Occurred()) SWIG_fail;
23956 }
23957 {
23958 wxTimeSpan * resultptr;
23959 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23960 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23961 }
23962 return resultobj;
23963 fail:
23964 return NULL;
23965 }
23966
23967
23968 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23969 PyObject *resultobj;
23970 long arg1 ;
23971 wxTimeSpan result;
23972 PyObject * obj0 = 0 ;
23973 char *kwnames[] = {
23974 (char *) "hours", NULL
23975 };
23976
23977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23978 {
23979 arg1 = (long)(SWIG_As_long(obj0));
23980 if (SWIG_arg_fail(1)) SWIG_fail;
23981 }
23982 {
23983 PyThreadState* __tstate = wxPyBeginAllowThreads();
23984 result = wxTimeSpan::Hours(arg1);
23985
23986 wxPyEndAllowThreads(__tstate);
23987 if (PyErr_Occurred()) SWIG_fail;
23988 }
23989 {
23990 wxTimeSpan * resultptr;
23991 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23992 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23993 }
23994 return resultobj;
23995 fail:
23996 return NULL;
23997 }
23998
23999
24000 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
24001 PyObject *resultobj;
24002 wxTimeSpan result;
24003 char *kwnames[] = {
24004 NULL
24005 };
24006
24007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
24008 {
24009 PyThreadState* __tstate = wxPyBeginAllowThreads();
24010 result = wxTimeSpan::Hour();
24011
24012 wxPyEndAllowThreads(__tstate);
24013 if (PyErr_Occurred()) SWIG_fail;
24014 }
24015 {
24016 wxTimeSpan * resultptr;
24017 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24018 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24019 }
24020 return resultobj;
24021 fail:
24022 return NULL;
24023 }
24024
24025
24026 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24027 PyObject *resultobj;
24028 long arg1 ;
24029 wxTimeSpan result;
24030 PyObject * obj0 = 0 ;
24031 char *kwnames[] = {
24032 (char *) "days", NULL
24033 };
24034
24035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24036 {
24037 arg1 = (long)(SWIG_As_long(obj0));
24038 if (SWIG_arg_fail(1)) SWIG_fail;
24039 }
24040 {
24041 PyThreadState* __tstate = wxPyBeginAllowThreads();
24042 result = wxTimeSpan::Days(arg1);
24043
24044 wxPyEndAllowThreads(__tstate);
24045 if (PyErr_Occurred()) SWIG_fail;
24046 }
24047 {
24048 wxTimeSpan * resultptr;
24049 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24050 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24051 }
24052 return resultobj;
24053 fail:
24054 return NULL;
24055 }
24056
24057
24058 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24059 PyObject *resultobj;
24060 wxTimeSpan result;
24061 char *kwnames[] = {
24062 NULL
24063 };
24064
24065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24066 {
24067 PyThreadState* __tstate = wxPyBeginAllowThreads();
24068 result = wxTimeSpan::Day();
24069
24070 wxPyEndAllowThreads(__tstate);
24071 if (PyErr_Occurred()) SWIG_fail;
24072 }
24073 {
24074 wxTimeSpan * resultptr;
24075 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24076 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24077 }
24078 return resultobj;
24079 fail:
24080 return NULL;
24081 }
24082
24083
24084 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24085 PyObject *resultobj;
24086 long arg1 ;
24087 wxTimeSpan result;
24088 PyObject * obj0 = 0 ;
24089 char *kwnames[] = {
24090 (char *) "days", NULL
24091 };
24092
24093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24094 {
24095 arg1 = (long)(SWIG_As_long(obj0));
24096 if (SWIG_arg_fail(1)) SWIG_fail;
24097 }
24098 {
24099 PyThreadState* __tstate = wxPyBeginAllowThreads();
24100 result = wxTimeSpan::Weeks(arg1);
24101
24102 wxPyEndAllowThreads(__tstate);
24103 if (PyErr_Occurred()) SWIG_fail;
24104 }
24105 {
24106 wxTimeSpan * resultptr;
24107 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24108 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24109 }
24110 return resultobj;
24111 fail:
24112 return NULL;
24113 }
24114
24115
24116 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24117 PyObject *resultobj;
24118 wxTimeSpan result;
24119 char *kwnames[] = {
24120 NULL
24121 };
24122
24123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24124 {
24125 PyThreadState* __tstate = wxPyBeginAllowThreads();
24126 result = wxTimeSpan::Week();
24127
24128 wxPyEndAllowThreads(__tstate);
24129 if (PyErr_Occurred()) SWIG_fail;
24130 }
24131 {
24132 wxTimeSpan * resultptr;
24133 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24134 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24135 }
24136 return resultobj;
24137 fail:
24138 return NULL;
24139 }
24140
24141
24142 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24143 PyObject *resultobj;
24144 long arg1 = (long) 0 ;
24145 long arg2 = (long) 0 ;
24146 long arg3 = (long) 0 ;
24147 long arg4 = (long) 0 ;
24148 wxTimeSpan *result;
24149 PyObject * obj0 = 0 ;
24150 PyObject * obj1 = 0 ;
24151 PyObject * obj2 = 0 ;
24152 PyObject * obj3 = 0 ;
24153 char *kwnames[] = {
24154 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24155 };
24156
24157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24158 if (obj0) {
24159 {
24160 arg1 = (long)(SWIG_As_long(obj0));
24161 if (SWIG_arg_fail(1)) SWIG_fail;
24162 }
24163 }
24164 if (obj1) {
24165 {
24166 arg2 = (long)(SWIG_As_long(obj1));
24167 if (SWIG_arg_fail(2)) SWIG_fail;
24168 }
24169 }
24170 if (obj2) {
24171 {
24172 arg3 = (long)(SWIG_As_long(obj2));
24173 if (SWIG_arg_fail(3)) SWIG_fail;
24174 }
24175 }
24176 if (obj3) {
24177 {
24178 arg4 = (long)(SWIG_As_long(obj3));
24179 if (SWIG_arg_fail(4)) SWIG_fail;
24180 }
24181 }
24182 {
24183 PyThreadState* __tstate = wxPyBeginAllowThreads();
24184 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24185
24186 wxPyEndAllowThreads(__tstate);
24187 if (PyErr_Occurred()) SWIG_fail;
24188 }
24189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24190 return resultobj;
24191 fail:
24192 return NULL;
24193 }
24194
24195
24196 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24197 PyObject *resultobj;
24198 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24199 PyObject * obj0 = 0 ;
24200 char *kwnames[] = {
24201 (char *) "self", NULL
24202 };
24203
24204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24206 if (SWIG_arg_fail(1)) SWIG_fail;
24207 {
24208 PyThreadState* __tstate = wxPyBeginAllowThreads();
24209 delete arg1;
24210
24211 wxPyEndAllowThreads(__tstate);
24212 if (PyErr_Occurred()) SWIG_fail;
24213 }
24214 Py_INCREF(Py_None); resultobj = Py_None;
24215 return resultobj;
24216 fail:
24217 return NULL;
24218 }
24219
24220
24221 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24222 PyObject *resultobj;
24223 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24224 wxTimeSpan *arg2 = 0 ;
24225 wxTimeSpan *result;
24226 PyObject * obj0 = 0 ;
24227 PyObject * obj1 = 0 ;
24228 char *kwnames[] = {
24229 (char *) "self",(char *) "diff", NULL
24230 };
24231
24232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24234 if (SWIG_arg_fail(1)) SWIG_fail;
24235 {
24236 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24237 if (SWIG_arg_fail(2)) SWIG_fail;
24238 if (arg2 == NULL) {
24239 SWIG_null_ref("wxTimeSpan");
24240 }
24241 if (SWIG_arg_fail(2)) SWIG_fail;
24242 }
24243 {
24244 PyThreadState* __tstate = wxPyBeginAllowThreads();
24245 {
24246 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24247 result = (wxTimeSpan *) &_result_ref;
24248 }
24249
24250 wxPyEndAllowThreads(__tstate);
24251 if (PyErr_Occurred()) SWIG_fail;
24252 }
24253 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24254 return resultobj;
24255 fail:
24256 return NULL;
24257 }
24258
24259
24260 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24261 PyObject *resultobj;
24262 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24263 wxTimeSpan *arg2 = 0 ;
24264 wxTimeSpan *result;
24265 PyObject * obj0 = 0 ;
24266 PyObject * obj1 = 0 ;
24267 char *kwnames[] = {
24268 (char *) "self",(char *) "diff", NULL
24269 };
24270
24271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24273 if (SWIG_arg_fail(1)) SWIG_fail;
24274 {
24275 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24276 if (SWIG_arg_fail(2)) SWIG_fail;
24277 if (arg2 == NULL) {
24278 SWIG_null_ref("wxTimeSpan");
24279 }
24280 if (SWIG_arg_fail(2)) SWIG_fail;
24281 }
24282 {
24283 PyThreadState* __tstate = wxPyBeginAllowThreads();
24284 {
24285 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24286 result = (wxTimeSpan *) &_result_ref;
24287 }
24288
24289 wxPyEndAllowThreads(__tstate);
24290 if (PyErr_Occurred()) SWIG_fail;
24291 }
24292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24293 return resultobj;
24294 fail:
24295 return NULL;
24296 }
24297
24298
24299 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24300 PyObject *resultobj;
24301 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24302 int arg2 ;
24303 wxTimeSpan *result;
24304 PyObject * obj0 = 0 ;
24305 PyObject * obj1 = 0 ;
24306 char *kwnames[] = {
24307 (char *) "self",(char *) "n", NULL
24308 };
24309
24310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24312 if (SWIG_arg_fail(1)) SWIG_fail;
24313 {
24314 arg2 = (int)(SWIG_As_int(obj1));
24315 if (SWIG_arg_fail(2)) SWIG_fail;
24316 }
24317 {
24318 PyThreadState* __tstate = wxPyBeginAllowThreads();
24319 {
24320 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24321 result = (wxTimeSpan *) &_result_ref;
24322 }
24323
24324 wxPyEndAllowThreads(__tstate);
24325 if (PyErr_Occurred()) SWIG_fail;
24326 }
24327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24328 return resultobj;
24329 fail:
24330 return NULL;
24331 }
24332
24333
24334 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24335 PyObject *resultobj;
24336 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24337 wxTimeSpan *result;
24338 PyObject * obj0 = 0 ;
24339 char *kwnames[] = {
24340 (char *) "self", NULL
24341 };
24342
24343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24345 if (SWIG_arg_fail(1)) SWIG_fail;
24346 {
24347 PyThreadState* __tstate = wxPyBeginAllowThreads();
24348 {
24349 wxTimeSpan &_result_ref = (arg1)->Neg();
24350 result = (wxTimeSpan *) &_result_ref;
24351 }
24352
24353 wxPyEndAllowThreads(__tstate);
24354 if (PyErr_Occurred()) SWIG_fail;
24355 }
24356 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24357 return resultobj;
24358 fail:
24359 return NULL;
24360 }
24361
24362
24363 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24364 PyObject *resultobj;
24365 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24366 wxTimeSpan result;
24367 PyObject * obj0 = 0 ;
24368 char *kwnames[] = {
24369 (char *) "self", NULL
24370 };
24371
24372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24374 if (SWIG_arg_fail(1)) SWIG_fail;
24375 {
24376 PyThreadState* __tstate = wxPyBeginAllowThreads();
24377 result = ((wxTimeSpan const *)arg1)->Abs();
24378
24379 wxPyEndAllowThreads(__tstate);
24380 if (PyErr_Occurred()) SWIG_fail;
24381 }
24382 {
24383 wxTimeSpan * resultptr;
24384 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24385 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24386 }
24387 return resultobj;
24388 fail:
24389 return NULL;
24390 }
24391
24392
24393 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24394 PyObject *resultobj;
24395 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24396 wxTimeSpan *arg2 = 0 ;
24397 wxTimeSpan *result;
24398 PyObject * obj0 = 0 ;
24399 PyObject * obj1 = 0 ;
24400 char *kwnames[] = {
24401 (char *) "self",(char *) "diff", NULL
24402 };
24403
24404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24406 if (SWIG_arg_fail(1)) SWIG_fail;
24407 {
24408 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24409 if (SWIG_arg_fail(2)) SWIG_fail;
24410 if (arg2 == NULL) {
24411 SWIG_null_ref("wxTimeSpan");
24412 }
24413 if (SWIG_arg_fail(2)) SWIG_fail;
24414 }
24415 {
24416 PyThreadState* __tstate = wxPyBeginAllowThreads();
24417 {
24418 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24419 result = (wxTimeSpan *) &_result_ref;
24420 }
24421
24422 wxPyEndAllowThreads(__tstate);
24423 if (PyErr_Occurred()) SWIG_fail;
24424 }
24425 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24426 return resultobj;
24427 fail:
24428 return NULL;
24429 }
24430
24431
24432 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24433 PyObject *resultobj;
24434 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24435 wxTimeSpan *arg2 = 0 ;
24436 wxTimeSpan *result;
24437 PyObject * obj0 = 0 ;
24438 PyObject * obj1 = 0 ;
24439 char *kwnames[] = {
24440 (char *) "self",(char *) "diff", NULL
24441 };
24442
24443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24445 if (SWIG_arg_fail(1)) SWIG_fail;
24446 {
24447 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24448 if (SWIG_arg_fail(2)) SWIG_fail;
24449 if (arg2 == NULL) {
24450 SWIG_null_ref("wxTimeSpan");
24451 }
24452 if (SWIG_arg_fail(2)) SWIG_fail;
24453 }
24454 {
24455 PyThreadState* __tstate = wxPyBeginAllowThreads();
24456 {
24457 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24458 result = (wxTimeSpan *) &_result_ref;
24459 }
24460
24461 wxPyEndAllowThreads(__tstate);
24462 if (PyErr_Occurred()) SWIG_fail;
24463 }
24464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24465 return resultobj;
24466 fail:
24467 return NULL;
24468 }
24469
24470
24471 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24472 PyObject *resultobj;
24473 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24474 int arg2 ;
24475 wxTimeSpan *result;
24476 PyObject * obj0 = 0 ;
24477 PyObject * obj1 = 0 ;
24478 char *kwnames[] = {
24479 (char *) "self",(char *) "n", NULL
24480 };
24481
24482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24484 if (SWIG_arg_fail(1)) SWIG_fail;
24485 {
24486 arg2 = (int)(SWIG_As_int(obj1));
24487 if (SWIG_arg_fail(2)) SWIG_fail;
24488 }
24489 {
24490 PyThreadState* __tstate = wxPyBeginAllowThreads();
24491 {
24492 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24493 result = (wxTimeSpan *) &_result_ref;
24494 }
24495
24496 wxPyEndAllowThreads(__tstate);
24497 if (PyErr_Occurred()) SWIG_fail;
24498 }
24499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24500 return resultobj;
24501 fail:
24502 return NULL;
24503 }
24504
24505
24506 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24507 PyObject *resultobj;
24508 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24509 wxTimeSpan *result;
24510 PyObject * obj0 = 0 ;
24511 char *kwnames[] = {
24512 (char *) "self", NULL
24513 };
24514
24515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24517 if (SWIG_arg_fail(1)) SWIG_fail;
24518 {
24519 PyThreadState* __tstate = wxPyBeginAllowThreads();
24520 {
24521 wxTimeSpan &_result_ref = (arg1)->operator -();
24522 result = (wxTimeSpan *) &_result_ref;
24523 }
24524
24525 wxPyEndAllowThreads(__tstate);
24526 if (PyErr_Occurred()) SWIG_fail;
24527 }
24528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24529 return resultobj;
24530 fail:
24531 return NULL;
24532 }
24533
24534
24535 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24536 PyObject *resultobj;
24537 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24538 wxTimeSpan *arg2 = 0 ;
24539 wxTimeSpan result;
24540 PyObject * obj0 = 0 ;
24541 PyObject * obj1 = 0 ;
24542 char *kwnames[] = {
24543 (char *) "self",(char *) "other", NULL
24544 };
24545
24546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24548 if (SWIG_arg_fail(1)) SWIG_fail;
24549 {
24550 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24551 if (SWIG_arg_fail(2)) SWIG_fail;
24552 if (arg2 == NULL) {
24553 SWIG_null_ref("wxTimeSpan");
24554 }
24555 if (SWIG_arg_fail(2)) SWIG_fail;
24556 }
24557 {
24558 PyThreadState* __tstate = wxPyBeginAllowThreads();
24559 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24560
24561 wxPyEndAllowThreads(__tstate);
24562 if (PyErr_Occurred()) SWIG_fail;
24563 }
24564 {
24565 wxTimeSpan * resultptr;
24566 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24568 }
24569 return resultobj;
24570 fail:
24571 return NULL;
24572 }
24573
24574
24575 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24576 PyObject *resultobj;
24577 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24578 wxTimeSpan *arg2 = 0 ;
24579 wxTimeSpan result;
24580 PyObject * obj0 = 0 ;
24581 PyObject * obj1 = 0 ;
24582 char *kwnames[] = {
24583 (char *) "self",(char *) "other", NULL
24584 };
24585
24586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24588 if (SWIG_arg_fail(1)) SWIG_fail;
24589 {
24590 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24591 if (SWIG_arg_fail(2)) SWIG_fail;
24592 if (arg2 == NULL) {
24593 SWIG_null_ref("wxTimeSpan");
24594 }
24595 if (SWIG_arg_fail(2)) SWIG_fail;
24596 }
24597 {
24598 PyThreadState* __tstate = wxPyBeginAllowThreads();
24599 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24600
24601 wxPyEndAllowThreads(__tstate);
24602 if (PyErr_Occurred()) SWIG_fail;
24603 }
24604 {
24605 wxTimeSpan * resultptr;
24606 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24607 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24608 }
24609 return resultobj;
24610 fail:
24611 return NULL;
24612 }
24613
24614
24615 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24616 PyObject *resultobj;
24617 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24618 int arg2 ;
24619 wxTimeSpan result;
24620 PyObject * obj0 = 0 ;
24621 PyObject * obj1 = 0 ;
24622 char *kwnames[] = {
24623 (char *) "self",(char *) "n", NULL
24624 };
24625
24626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24628 if (SWIG_arg_fail(1)) SWIG_fail;
24629 {
24630 arg2 = (int)(SWIG_As_int(obj1));
24631 if (SWIG_arg_fail(2)) SWIG_fail;
24632 }
24633 {
24634 PyThreadState* __tstate = wxPyBeginAllowThreads();
24635 result = wxTimeSpan___mul__(arg1,arg2);
24636
24637 wxPyEndAllowThreads(__tstate);
24638 if (PyErr_Occurred()) SWIG_fail;
24639 }
24640 {
24641 wxTimeSpan * resultptr;
24642 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24643 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24644 }
24645 return resultobj;
24646 fail:
24647 return NULL;
24648 }
24649
24650
24651 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24652 PyObject *resultobj;
24653 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24654 int arg2 ;
24655 wxTimeSpan result;
24656 PyObject * obj0 = 0 ;
24657 PyObject * obj1 = 0 ;
24658 char *kwnames[] = {
24659 (char *) "self",(char *) "n", NULL
24660 };
24661
24662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24664 if (SWIG_arg_fail(1)) SWIG_fail;
24665 {
24666 arg2 = (int)(SWIG_As_int(obj1));
24667 if (SWIG_arg_fail(2)) SWIG_fail;
24668 }
24669 {
24670 PyThreadState* __tstate = wxPyBeginAllowThreads();
24671 result = wxTimeSpan___rmul__(arg1,arg2);
24672
24673 wxPyEndAllowThreads(__tstate);
24674 if (PyErr_Occurred()) SWIG_fail;
24675 }
24676 {
24677 wxTimeSpan * resultptr;
24678 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24679 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24680 }
24681 return resultobj;
24682 fail:
24683 return NULL;
24684 }
24685
24686
24687 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24688 PyObject *resultobj;
24689 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24690 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24691 bool result;
24692 PyObject * obj0 = 0 ;
24693 PyObject * obj1 = 0 ;
24694 char *kwnames[] = {
24695 (char *) "self",(char *) "other", NULL
24696 };
24697
24698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24700 if (SWIG_arg_fail(1)) SWIG_fail;
24701 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24702 if (SWIG_arg_fail(2)) SWIG_fail;
24703 {
24704 PyThreadState* __tstate = wxPyBeginAllowThreads();
24705 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24706
24707 wxPyEndAllowThreads(__tstate);
24708 if (PyErr_Occurred()) SWIG_fail;
24709 }
24710 {
24711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24712 }
24713 return resultobj;
24714 fail:
24715 return NULL;
24716 }
24717
24718
24719 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24720 PyObject *resultobj;
24721 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24722 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24723 bool result;
24724 PyObject * obj0 = 0 ;
24725 PyObject * obj1 = 0 ;
24726 char *kwnames[] = {
24727 (char *) "self",(char *) "other", NULL
24728 };
24729
24730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24732 if (SWIG_arg_fail(1)) SWIG_fail;
24733 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24734 if (SWIG_arg_fail(2)) SWIG_fail;
24735 {
24736 PyThreadState* __tstate = wxPyBeginAllowThreads();
24737 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24738
24739 wxPyEndAllowThreads(__tstate);
24740 if (PyErr_Occurred()) SWIG_fail;
24741 }
24742 {
24743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24744 }
24745 return resultobj;
24746 fail:
24747 return NULL;
24748 }
24749
24750
24751 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24752 PyObject *resultobj;
24753 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24754 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24755 bool result;
24756 PyObject * obj0 = 0 ;
24757 PyObject * obj1 = 0 ;
24758 char *kwnames[] = {
24759 (char *) "self",(char *) "other", NULL
24760 };
24761
24762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24764 if (SWIG_arg_fail(1)) SWIG_fail;
24765 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24766 if (SWIG_arg_fail(2)) SWIG_fail;
24767 {
24768 PyThreadState* __tstate = wxPyBeginAllowThreads();
24769 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24770
24771 wxPyEndAllowThreads(__tstate);
24772 if (PyErr_Occurred()) SWIG_fail;
24773 }
24774 {
24775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24776 }
24777 return resultobj;
24778 fail:
24779 return NULL;
24780 }
24781
24782
24783 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24784 PyObject *resultobj;
24785 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24786 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24787 bool result;
24788 PyObject * obj0 = 0 ;
24789 PyObject * obj1 = 0 ;
24790 char *kwnames[] = {
24791 (char *) "self",(char *) "other", NULL
24792 };
24793
24794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24796 if (SWIG_arg_fail(1)) SWIG_fail;
24797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24798 if (SWIG_arg_fail(2)) SWIG_fail;
24799 {
24800 PyThreadState* __tstate = wxPyBeginAllowThreads();
24801 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24802
24803 wxPyEndAllowThreads(__tstate);
24804 if (PyErr_Occurred()) SWIG_fail;
24805 }
24806 {
24807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24808 }
24809 return resultobj;
24810 fail:
24811 return NULL;
24812 }
24813
24814
24815 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24816 PyObject *resultobj;
24817 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24818 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24819 bool result;
24820 PyObject * obj0 = 0 ;
24821 PyObject * obj1 = 0 ;
24822 char *kwnames[] = {
24823 (char *) "self",(char *) "other", NULL
24824 };
24825
24826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24828 if (SWIG_arg_fail(1)) SWIG_fail;
24829 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24830 if (SWIG_arg_fail(2)) SWIG_fail;
24831 {
24832 PyThreadState* __tstate = wxPyBeginAllowThreads();
24833 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24834
24835 wxPyEndAllowThreads(__tstate);
24836 if (PyErr_Occurred()) SWIG_fail;
24837 }
24838 {
24839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24840 }
24841 return resultobj;
24842 fail:
24843 return NULL;
24844 }
24845
24846
24847 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24848 PyObject *resultobj;
24849 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24850 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24851 bool result;
24852 PyObject * obj0 = 0 ;
24853 PyObject * obj1 = 0 ;
24854 char *kwnames[] = {
24855 (char *) "self",(char *) "other", NULL
24856 };
24857
24858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24860 if (SWIG_arg_fail(1)) SWIG_fail;
24861 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24862 if (SWIG_arg_fail(2)) SWIG_fail;
24863 {
24864 PyThreadState* __tstate = wxPyBeginAllowThreads();
24865 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24866
24867 wxPyEndAllowThreads(__tstate);
24868 if (PyErr_Occurred()) SWIG_fail;
24869 }
24870 {
24871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24872 }
24873 return resultobj;
24874 fail:
24875 return NULL;
24876 }
24877
24878
24879 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24880 PyObject *resultobj;
24881 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24882 bool result;
24883 PyObject * obj0 = 0 ;
24884 char *kwnames[] = {
24885 (char *) "self", NULL
24886 };
24887
24888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24890 if (SWIG_arg_fail(1)) SWIG_fail;
24891 {
24892 PyThreadState* __tstate = wxPyBeginAllowThreads();
24893 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24894
24895 wxPyEndAllowThreads(__tstate);
24896 if (PyErr_Occurred()) SWIG_fail;
24897 }
24898 {
24899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24900 }
24901 return resultobj;
24902 fail:
24903 return NULL;
24904 }
24905
24906
24907 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24908 PyObject *resultobj;
24909 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24910 bool result;
24911 PyObject * obj0 = 0 ;
24912 char *kwnames[] = {
24913 (char *) "self", NULL
24914 };
24915
24916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24918 if (SWIG_arg_fail(1)) SWIG_fail;
24919 {
24920 PyThreadState* __tstate = wxPyBeginAllowThreads();
24921 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24922
24923 wxPyEndAllowThreads(__tstate);
24924 if (PyErr_Occurred()) SWIG_fail;
24925 }
24926 {
24927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24928 }
24929 return resultobj;
24930 fail:
24931 return NULL;
24932 }
24933
24934
24935 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24936 PyObject *resultobj;
24937 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24938 bool result;
24939 PyObject * obj0 = 0 ;
24940 char *kwnames[] = {
24941 (char *) "self", NULL
24942 };
24943
24944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24946 if (SWIG_arg_fail(1)) SWIG_fail;
24947 {
24948 PyThreadState* __tstate = wxPyBeginAllowThreads();
24949 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24950
24951 wxPyEndAllowThreads(__tstate);
24952 if (PyErr_Occurred()) SWIG_fail;
24953 }
24954 {
24955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24956 }
24957 return resultobj;
24958 fail:
24959 return NULL;
24960 }
24961
24962
24963 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24964 PyObject *resultobj;
24965 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24966 wxTimeSpan *arg2 = 0 ;
24967 bool result;
24968 PyObject * obj0 = 0 ;
24969 PyObject * obj1 = 0 ;
24970 char *kwnames[] = {
24971 (char *) "self",(char *) "ts", NULL
24972 };
24973
24974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24976 if (SWIG_arg_fail(1)) SWIG_fail;
24977 {
24978 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24979 if (SWIG_arg_fail(2)) SWIG_fail;
24980 if (arg2 == NULL) {
24981 SWIG_null_ref("wxTimeSpan");
24982 }
24983 if (SWIG_arg_fail(2)) SWIG_fail;
24984 }
24985 {
24986 PyThreadState* __tstate = wxPyBeginAllowThreads();
24987 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24988
24989 wxPyEndAllowThreads(__tstate);
24990 if (PyErr_Occurred()) SWIG_fail;
24991 }
24992 {
24993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24994 }
24995 return resultobj;
24996 fail:
24997 return NULL;
24998 }
24999
25000
25001 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
25002 PyObject *resultobj;
25003 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25004 wxTimeSpan *arg2 = 0 ;
25005 bool result;
25006 PyObject * obj0 = 0 ;
25007 PyObject * obj1 = 0 ;
25008 char *kwnames[] = {
25009 (char *) "self",(char *) "ts", NULL
25010 };
25011
25012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
25013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25014 if (SWIG_arg_fail(1)) SWIG_fail;
25015 {
25016 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25017 if (SWIG_arg_fail(2)) SWIG_fail;
25018 if (arg2 == NULL) {
25019 SWIG_null_ref("wxTimeSpan");
25020 }
25021 if (SWIG_arg_fail(2)) SWIG_fail;
25022 }
25023 {
25024 PyThreadState* __tstate = wxPyBeginAllowThreads();
25025 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
25026
25027 wxPyEndAllowThreads(__tstate);
25028 if (PyErr_Occurred()) SWIG_fail;
25029 }
25030 {
25031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25032 }
25033 return resultobj;
25034 fail:
25035 return NULL;
25036 }
25037
25038
25039 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25040 PyObject *resultobj;
25041 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25042 wxTimeSpan *arg2 = 0 ;
25043 bool result;
25044 PyObject * obj0 = 0 ;
25045 PyObject * obj1 = 0 ;
25046 char *kwnames[] = {
25047 (char *) "self",(char *) "t", NULL
25048 };
25049
25050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25052 if (SWIG_arg_fail(1)) SWIG_fail;
25053 {
25054 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25055 if (SWIG_arg_fail(2)) SWIG_fail;
25056 if (arg2 == NULL) {
25057 SWIG_null_ref("wxTimeSpan");
25058 }
25059 if (SWIG_arg_fail(2)) SWIG_fail;
25060 }
25061 {
25062 PyThreadState* __tstate = wxPyBeginAllowThreads();
25063 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25064
25065 wxPyEndAllowThreads(__tstate);
25066 if (PyErr_Occurred()) SWIG_fail;
25067 }
25068 {
25069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25070 }
25071 return resultobj;
25072 fail:
25073 return NULL;
25074 }
25075
25076
25077 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25078 PyObject *resultobj;
25079 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25080 int result;
25081 PyObject * obj0 = 0 ;
25082 char *kwnames[] = {
25083 (char *) "self", NULL
25084 };
25085
25086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25088 if (SWIG_arg_fail(1)) SWIG_fail;
25089 {
25090 PyThreadState* __tstate = wxPyBeginAllowThreads();
25091 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25092
25093 wxPyEndAllowThreads(__tstate);
25094 if (PyErr_Occurred()) SWIG_fail;
25095 }
25096 {
25097 resultobj = SWIG_From_int((int)(result));
25098 }
25099 return resultobj;
25100 fail:
25101 return NULL;
25102 }
25103
25104
25105 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25106 PyObject *resultobj;
25107 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25108 int result;
25109 PyObject * obj0 = 0 ;
25110 char *kwnames[] = {
25111 (char *) "self", NULL
25112 };
25113
25114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25116 if (SWIG_arg_fail(1)) SWIG_fail;
25117 {
25118 PyThreadState* __tstate = wxPyBeginAllowThreads();
25119 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25120
25121 wxPyEndAllowThreads(__tstate);
25122 if (PyErr_Occurred()) SWIG_fail;
25123 }
25124 {
25125 resultobj = SWIG_From_int((int)(result));
25126 }
25127 return resultobj;
25128 fail:
25129 return NULL;
25130 }
25131
25132
25133 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25134 PyObject *resultobj;
25135 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25136 int result;
25137 PyObject * obj0 = 0 ;
25138 char *kwnames[] = {
25139 (char *) "self", NULL
25140 };
25141
25142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25144 if (SWIG_arg_fail(1)) SWIG_fail;
25145 {
25146 PyThreadState* __tstate = wxPyBeginAllowThreads();
25147 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25148
25149 wxPyEndAllowThreads(__tstate);
25150 if (PyErr_Occurred()) SWIG_fail;
25151 }
25152 {
25153 resultobj = SWIG_From_int((int)(result));
25154 }
25155 return resultobj;
25156 fail:
25157 return NULL;
25158 }
25159
25160
25161 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25162 PyObject *resultobj;
25163 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25164 int result;
25165 PyObject * obj0 = 0 ;
25166 char *kwnames[] = {
25167 (char *) "self", NULL
25168 };
25169
25170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25172 if (SWIG_arg_fail(1)) SWIG_fail;
25173 {
25174 PyThreadState* __tstate = wxPyBeginAllowThreads();
25175 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25176
25177 wxPyEndAllowThreads(__tstate);
25178 if (PyErr_Occurred()) SWIG_fail;
25179 }
25180 {
25181 resultobj = SWIG_From_int((int)(result));
25182 }
25183 return resultobj;
25184 fail:
25185 return NULL;
25186 }
25187
25188
25189 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25190 PyObject *resultobj;
25191 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25192 wxLongLong result;
25193 PyObject * obj0 = 0 ;
25194 char *kwnames[] = {
25195 (char *) "self", NULL
25196 };
25197
25198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25200 if (SWIG_arg_fail(1)) SWIG_fail;
25201 {
25202 PyThreadState* __tstate = wxPyBeginAllowThreads();
25203 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25204
25205 wxPyEndAllowThreads(__tstate);
25206 if (PyErr_Occurred()) SWIG_fail;
25207 }
25208 {
25209 PyObject *hi, *lo, *shifter, *shifted;
25210 hi = PyLong_FromLong( (&result)->GetHi() );
25211 lo = PyLong_FromLong( (&result)->GetLo() );
25212 shifter = PyLong_FromLong(32);
25213 shifted = PyNumber_Lshift(hi, shifter);
25214 resultobj = PyNumber_Or(shifted, lo);
25215 Py_DECREF(hi);
25216 Py_DECREF(lo);
25217 Py_DECREF(shifter);
25218 Py_DECREF(shifted);
25219 }
25220 return resultobj;
25221 fail:
25222 return NULL;
25223 }
25224
25225
25226 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25227 PyObject *resultobj;
25228 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25229 wxLongLong result;
25230 PyObject * obj0 = 0 ;
25231 char *kwnames[] = {
25232 (char *) "self", NULL
25233 };
25234
25235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25237 if (SWIG_arg_fail(1)) SWIG_fail;
25238 {
25239 PyThreadState* __tstate = wxPyBeginAllowThreads();
25240 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25241
25242 wxPyEndAllowThreads(__tstate);
25243 if (PyErr_Occurred()) SWIG_fail;
25244 }
25245 {
25246 PyObject *hi, *lo, *shifter, *shifted;
25247 hi = PyLong_FromLong( (&result)->GetHi() );
25248 lo = PyLong_FromLong( (&result)->GetLo() );
25249 shifter = PyLong_FromLong(32);
25250 shifted = PyNumber_Lshift(hi, shifter);
25251 resultobj = PyNumber_Or(shifted, lo);
25252 Py_DECREF(hi);
25253 Py_DECREF(lo);
25254 Py_DECREF(shifter);
25255 Py_DECREF(shifted);
25256 }
25257 return resultobj;
25258 fail:
25259 return NULL;
25260 }
25261
25262
25263 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25264 PyObject *resultobj;
25265 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25266 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25267 wxString *arg2 = (wxString *) &arg2_defvalue ;
25268 wxString result;
25269 bool temp2 = false ;
25270 PyObject * obj0 = 0 ;
25271 PyObject * obj1 = 0 ;
25272 char *kwnames[] = {
25273 (char *) "self",(char *) "format", NULL
25274 };
25275
25276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25278 if (SWIG_arg_fail(1)) SWIG_fail;
25279 if (obj1) {
25280 {
25281 arg2 = wxString_in_helper(obj1);
25282 if (arg2 == NULL) SWIG_fail;
25283 temp2 = true;
25284 }
25285 }
25286 {
25287 PyThreadState* __tstate = wxPyBeginAllowThreads();
25288 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25289
25290 wxPyEndAllowThreads(__tstate);
25291 if (PyErr_Occurred()) SWIG_fail;
25292 }
25293 {
25294 #if wxUSE_UNICODE
25295 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25296 #else
25297 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25298 #endif
25299 }
25300 {
25301 if (temp2)
25302 delete arg2;
25303 }
25304 return resultobj;
25305 fail:
25306 {
25307 if (temp2)
25308 delete arg2;
25309 }
25310 return NULL;
25311 }
25312
25313
25314 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25315 PyObject *obj;
25316 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25317 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25318 Py_INCREF(obj);
25319 return Py_BuildValue((char *)"");
25320 }
25321 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25322 PyObject *resultobj;
25323 int arg1 = (int) 0 ;
25324 int arg2 = (int) 0 ;
25325 int arg3 = (int) 0 ;
25326 int arg4 = (int) 0 ;
25327 wxDateSpan *result;
25328 PyObject * obj0 = 0 ;
25329 PyObject * obj1 = 0 ;
25330 PyObject * obj2 = 0 ;
25331 PyObject * obj3 = 0 ;
25332 char *kwnames[] = {
25333 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25334 };
25335
25336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25337 if (obj0) {
25338 {
25339 arg1 = (int)(SWIG_As_int(obj0));
25340 if (SWIG_arg_fail(1)) SWIG_fail;
25341 }
25342 }
25343 if (obj1) {
25344 {
25345 arg2 = (int)(SWIG_As_int(obj1));
25346 if (SWIG_arg_fail(2)) SWIG_fail;
25347 }
25348 }
25349 if (obj2) {
25350 {
25351 arg3 = (int)(SWIG_As_int(obj2));
25352 if (SWIG_arg_fail(3)) SWIG_fail;
25353 }
25354 }
25355 if (obj3) {
25356 {
25357 arg4 = (int)(SWIG_As_int(obj3));
25358 if (SWIG_arg_fail(4)) SWIG_fail;
25359 }
25360 }
25361 {
25362 PyThreadState* __tstate = wxPyBeginAllowThreads();
25363 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25364
25365 wxPyEndAllowThreads(__tstate);
25366 if (PyErr_Occurred()) SWIG_fail;
25367 }
25368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25369 return resultobj;
25370 fail:
25371 return NULL;
25372 }
25373
25374
25375 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25376 PyObject *resultobj;
25377 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25378 PyObject * obj0 = 0 ;
25379 char *kwnames[] = {
25380 (char *) "self", NULL
25381 };
25382
25383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25385 if (SWIG_arg_fail(1)) SWIG_fail;
25386 {
25387 PyThreadState* __tstate = wxPyBeginAllowThreads();
25388 delete arg1;
25389
25390 wxPyEndAllowThreads(__tstate);
25391 if (PyErr_Occurred()) SWIG_fail;
25392 }
25393 Py_INCREF(Py_None); resultobj = Py_None;
25394 return resultobj;
25395 fail:
25396 return NULL;
25397 }
25398
25399
25400 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25401 PyObject *resultobj;
25402 int arg1 ;
25403 wxDateSpan result;
25404 PyObject * obj0 = 0 ;
25405 char *kwnames[] = {
25406 (char *) "days", NULL
25407 };
25408
25409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25410 {
25411 arg1 = (int)(SWIG_As_int(obj0));
25412 if (SWIG_arg_fail(1)) SWIG_fail;
25413 }
25414 {
25415 PyThreadState* __tstate = wxPyBeginAllowThreads();
25416 result = wxDateSpan::Days(arg1);
25417
25418 wxPyEndAllowThreads(__tstate);
25419 if (PyErr_Occurred()) SWIG_fail;
25420 }
25421 {
25422 wxDateSpan * resultptr;
25423 resultptr = new wxDateSpan((wxDateSpan &)(result));
25424 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25425 }
25426 return resultobj;
25427 fail:
25428 return NULL;
25429 }
25430
25431
25432 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25433 PyObject *resultobj;
25434 wxDateSpan result;
25435 char *kwnames[] = {
25436 NULL
25437 };
25438
25439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25440 {
25441 PyThreadState* __tstate = wxPyBeginAllowThreads();
25442 result = wxDateSpan::Day();
25443
25444 wxPyEndAllowThreads(__tstate);
25445 if (PyErr_Occurred()) SWIG_fail;
25446 }
25447 {
25448 wxDateSpan * resultptr;
25449 resultptr = new wxDateSpan((wxDateSpan &)(result));
25450 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25451 }
25452 return resultobj;
25453 fail:
25454 return NULL;
25455 }
25456
25457
25458 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25459 PyObject *resultobj;
25460 int arg1 ;
25461 wxDateSpan result;
25462 PyObject * obj0 = 0 ;
25463 char *kwnames[] = {
25464 (char *) "weeks", NULL
25465 };
25466
25467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25468 {
25469 arg1 = (int)(SWIG_As_int(obj0));
25470 if (SWIG_arg_fail(1)) SWIG_fail;
25471 }
25472 {
25473 PyThreadState* __tstate = wxPyBeginAllowThreads();
25474 result = wxDateSpan::Weeks(arg1);
25475
25476 wxPyEndAllowThreads(__tstate);
25477 if (PyErr_Occurred()) SWIG_fail;
25478 }
25479 {
25480 wxDateSpan * resultptr;
25481 resultptr = new wxDateSpan((wxDateSpan &)(result));
25482 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25483 }
25484 return resultobj;
25485 fail:
25486 return NULL;
25487 }
25488
25489
25490 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25491 PyObject *resultobj;
25492 wxDateSpan result;
25493 char *kwnames[] = {
25494 NULL
25495 };
25496
25497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25498 {
25499 PyThreadState* __tstate = wxPyBeginAllowThreads();
25500 result = wxDateSpan::Week();
25501
25502 wxPyEndAllowThreads(__tstate);
25503 if (PyErr_Occurred()) SWIG_fail;
25504 }
25505 {
25506 wxDateSpan * resultptr;
25507 resultptr = new wxDateSpan((wxDateSpan &)(result));
25508 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25509 }
25510 return resultobj;
25511 fail:
25512 return NULL;
25513 }
25514
25515
25516 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25517 PyObject *resultobj;
25518 int arg1 ;
25519 wxDateSpan result;
25520 PyObject * obj0 = 0 ;
25521 char *kwnames[] = {
25522 (char *) "mon", NULL
25523 };
25524
25525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25526 {
25527 arg1 = (int)(SWIG_As_int(obj0));
25528 if (SWIG_arg_fail(1)) SWIG_fail;
25529 }
25530 {
25531 PyThreadState* __tstate = wxPyBeginAllowThreads();
25532 result = wxDateSpan::Months(arg1);
25533
25534 wxPyEndAllowThreads(__tstate);
25535 if (PyErr_Occurred()) SWIG_fail;
25536 }
25537 {
25538 wxDateSpan * resultptr;
25539 resultptr = new wxDateSpan((wxDateSpan &)(result));
25540 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25541 }
25542 return resultobj;
25543 fail:
25544 return NULL;
25545 }
25546
25547
25548 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25549 PyObject *resultobj;
25550 wxDateSpan result;
25551 char *kwnames[] = {
25552 NULL
25553 };
25554
25555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25556 {
25557 PyThreadState* __tstate = wxPyBeginAllowThreads();
25558 result = wxDateSpan::Month();
25559
25560 wxPyEndAllowThreads(__tstate);
25561 if (PyErr_Occurred()) SWIG_fail;
25562 }
25563 {
25564 wxDateSpan * resultptr;
25565 resultptr = new wxDateSpan((wxDateSpan &)(result));
25566 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25567 }
25568 return resultobj;
25569 fail:
25570 return NULL;
25571 }
25572
25573
25574 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25575 PyObject *resultobj;
25576 int arg1 ;
25577 wxDateSpan result;
25578 PyObject * obj0 = 0 ;
25579 char *kwnames[] = {
25580 (char *) "years", NULL
25581 };
25582
25583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25584 {
25585 arg1 = (int)(SWIG_As_int(obj0));
25586 if (SWIG_arg_fail(1)) SWIG_fail;
25587 }
25588 {
25589 PyThreadState* __tstate = wxPyBeginAllowThreads();
25590 result = wxDateSpan::Years(arg1);
25591
25592 wxPyEndAllowThreads(__tstate);
25593 if (PyErr_Occurred()) SWIG_fail;
25594 }
25595 {
25596 wxDateSpan * resultptr;
25597 resultptr = new wxDateSpan((wxDateSpan &)(result));
25598 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25599 }
25600 return resultobj;
25601 fail:
25602 return NULL;
25603 }
25604
25605
25606 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25607 PyObject *resultobj;
25608 wxDateSpan result;
25609 char *kwnames[] = {
25610 NULL
25611 };
25612
25613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25614 {
25615 PyThreadState* __tstate = wxPyBeginAllowThreads();
25616 result = wxDateSpan::Year();
25617
25618 wxPyEndAllowThreads(__tstate);
25619 if (PyErr_Occurred()) SWIG_fail;
25620 }
25621 {
25622 wxDateSpan * resultptr;
25623 resultptr = new wxDateSpan((wxDateSpan &)(result));
25624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25625 }
25626 return resultobj;
25627 fail:
25628 return NULL;
25629 }
25630
25631
25632 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25633 PyObject *resultobj;
25634 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25635 int arg2 ;
25636 wxDateSpan *result;
25637 PyObject * obj0 = 0 ;
25638 PyObject * obj1 = 0 ;
25639 char *kwnames[] = {
25640 (char *) "self",(char *) "n", NULL
25641 };
25642
25643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25645 if (SWIG_arg_fail(1)) SWIG_fail;
25646 {
25647 arg2 = (int)(SWIG_As_int(obj1));
25648 if (SWIG_arg_fail(2)) SWIG_fail;
25649 }
25650 {
25651 PyThreadState* __tstate = wxPyBeginAllowThreads();
25652 {
25653 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25654 result = (wxDateSpan *) &_result_ref;
25655 }
25656
25657 wxPyEndAllowThreads(__tstate);
25658 if (PyErr_Occurred()) SWIG_fail;
25659 }
25660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25661 return resultobj;
25662 fail:
25663 return NULL;
25664 }
25665
25666
25667 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25668 PyObject *resultobj;
25669 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25670 int arg2 ;
25671 wxDateSpan *result;
25672 PyObject * obj0 = 0 ;
25673 PyObject * obj1 = 0 ;
25674 char *kwnames[] = {
25675 (char *) "self",(char *) "n", NULL
25676 };
25677
25678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25680 if (SWIG_arg_fail(1)) SWIG_fail;
25681 {
25682 arg2 = (int)(SWIG_As_int(obj1));
25683 if (SWIG_arg_fail(2)) SWIG_fail;
25684 }
25685 {
25686 PyThreadState* __tstate = wxPyBeginAllowThreads();
25687 {
25688 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25689 result = (wxDateSpan *) &_result_ref;
25690 }
25691
25692 wxPyEndAllowThreads(__tstate);
25693 if (PyErr_Occurred()) SWIG_fail;
25694 }
25695 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25696 return resultobj;
25697 fail:
25698 return NULL;
25699 }
25700
25701
25702 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25703 PyObject *resultobj;
25704 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25705 int arg2 ;
25706 wxDateSpan *result;
25707 PyObject * obj0 = 0 ;
25708 PyObject * obj1 = 0 ;
25709 char *kwnames[] = {
25710 (char *) "self",(char *) "n", NULL
25711 };
25712
25713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25715 if (SWIG_arg_fail(1)) SWIG_fail;
25716 {
25717 arg2 = (int)(SWIG_As_int(obj1));
25718 if (SWIG_arg_fail(2)) SWIG_fail;
25719 }
25720 {
25721 PyThreadState* __tstate = wxPyBeginAllowThreads();
25722 {
25723 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25724 result = (wxDateSpan *) &_result_ref;
25725 }
25726
25727 wxPyEndAllowThreads(__tstate);
25728 if (PyErr_Occurred()) SWIG_fail;
25729 }
25730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25731 return resultobj;
25732 fail:
25733 return NULL;
25734 }
25735
25736
25737 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25738 PyObject *resultobj;
25739 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25740 int arg2 ;
25741 wxDateSpan *result;
25742 PyObject * obj0 = 0 ;
25743 PyObject * obj1 = 0 ;
25744 char *kwnames[] = {
25745 (char *) "self",(char *) "n", NULL
25746 };
25747
25748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25750 if (SWIG_arg_fail(1)) SWIG_fail;
25751 {
25752 arg2 = (int)(SWIG_As_int(obj1));
25753 if (SWIG_arg_fail(2)) SWIG_fail;
25754 }
25755 {
25756 PyThreadState* __tstate = wxPyBeginAllowThreads();
25757 {
25758 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25759 result = (wxDateSpan *) &_result_ref;
25760 }
25761
25762 wxPyEndAllowThreads(__tstate);
25763 if (PyErr_Occurred()) SWIG_fail;
25764 }
25765 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25766 return resultobj;
25767 fail:
25768 return NULL;
25769 }
25770
25771
25772 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25773 PyObject *resultobj;
25774 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25775 int result;
25776 PyObject * obj0 = 0 ;
25777 char *kwnames[] = {
25778 (char *) "self", NULL
25779 };
25780
25781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25783 if (SWIG_arg_fail(1)) SWIG_fail;
25784 {
25785 PyThreadState* __tstate = wxPyBeginAllowThreads();
25786 result = (int)((wxDateSpan const *)arg1)->GetYears();
25787
25788 wxPyEndAllowThreads(__tstate);
25789 if (PyErr_Occurred()) SWIG_fail;
25790 }
25791 {
25792 resultobj = SWIG_From_int((int)(result));
25793 }
25794 return resultobj;
25795 fail:
25796 return NULL;
25797 }
25798
25799
25800 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25801 PyObject *resultobj;
25802 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25803 int result;
25804 PyObject * obj0 = 0 ;
25805 char *kwnames[] = {
25806 (char *) "self", NULL
25807 };
25808
25809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25811 if (SWIG_arg_fail(1)) SWIG_fail;
25812 {
25813 PyThreadState* __tstate = wxPyBeginAllowThreads();
25814 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25815
25816 wxPyEndAllowThreads(__tstate);
25817 if (PyErr_Occurred()) SWIG_fail;
25818 }
25819 {
25820 resultobj = SWIG_From_int((int)(result));
25821 }
25822 return resultobj;
25823 fail:
25824 return NULL;
25825 }
25826
25827
25828 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25829 PyObject *resultobj;
25830 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25831 int result;
25832 PyObject * obj0 = 0 ;
25833 char *kwnames[] = {
25834 (char *) "self", NULL
25835 };
25836
25837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25839 if (SWIG_arg_fail(1)) SWIG_fail;
25840 {
25841 PyThreadState* __tstate = wxPyBeginAllowThreads();
25842 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25843
25844 wxPyEndAllowThreads(__tstate);
25845 if (PyErr_Occurred()) SWIG_fail;
25846 }
25847 {
25848 resultobj = SWIG_From_int((int)(result));
25849 }
25850 return resultobj;
25851 fail:
25852 return NULL;
25853 }
25854
25855
25856 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25857 PyObject *resultobj;
25858 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25859 int result;
25860 PyObject * obj0 = 0 ;
25861 char *kwnames[] = {
25862 (char *) "self", NULL
25863 };
25864
25865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25867 if (SWIG_arg_fail(1)) SWIG_fail;
25868 {
25869 PyThreadState* __tstate = wxPyBeginAllowThreads();
25870 result = (int)((wxDateSpan const *)arg1)->GetDays();
25871
25872 wxPyEndAllowThreads(__tstate);
25873 if (PyErr_Occurred()) SWIG_fail;
25874 }
25875 {
25876 resultobj = SWIG_From_int((int)(result));
25877 }
25878 return resultobj;
25879 fail:
25880 return NULL;
25881 }
25882
25883
25884 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25885 PyObject *resultobj;
25886 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25887 int result;
25888 PyObject * obj0 = 0 ;
25889 char *kwnames[] = {
25890 (char *) "self", NULL
25891 };
25892
25893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25895 if (SWIG_arg_fail(1)) SWIG_fail;
25896 {
25897 PyThreadState* __tstate = wxPyBeginAllowThreads();
25898 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25899
25900 wxPyEndAllowThreads(__tstate);
25901 if (PyErr_Occurred()) SWIG_fail;
25902 }
25903 {
25904 resultobj = SWIG_From_int((int)(result));
25905 }
25906 return resultobj;
25907 fail:
25908 return NULL;
25909 }
25910
25911
25912 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25913 PyObject *resultobj;
25914 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25915 wxDateSpan *arg2 = 0 ;
25916 wxDateSpan *result;
25917 PyObject * obj0 = 0 ;
25918 PyObject * obj1 = 0 ;
25919 char *kwnames[] = {
25920 (char *) "self",(char *) "other", NULL
25921 };
25922
25923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25925 if (SWIG_arg_fail(1)) SWIG_fail;
25926 {
25927 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25928 if (SWIG_arg_fail(2)) SWIG_fail;
25929 if (arg2 == NULL) {
25930 SWIG_null_ref("wxDateSpan");
25931 }
25932 if (SWIG_arg_fail(2)) SWIG_fail;
25933 }
25934 {
25935 PyThreadState* __tstate = wxPyBeginAllowThreads();
25936 {
25937 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25938 result = (wxDateSpan *) &_result_ref;
25939 }
25940
25941 wxPyEndAllowThreads(__tstate);
25942 if (PyErr_Occurred()) SWIG_fail;
25943 }
25944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25945 return resultobj;
25946 fail:
25947 return NULL;
25948 }
25949
25950
25951 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25952 PyObject *resultobj;
25953 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25954 wxDateSpan *arg2 = 0 ;
25955 wxDateSpan *result;
25956 PyObject * obj0 = 0 ;
25957 PyObject * obj1 = 0 ;
25958 char *kwnames[] = {
25959 (char *) "self",(char *) "other", NULL
25960 };
25961
25962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25964 if (SWIG_arg_fail(1)) SWIG_fail;
25965 {
25966 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25967 if (SWIG_arg_fail(2)) SWIG_fail;
25968 if (arg2 == NULL) {
25969 SWIG_null_ref("wxDateSpan");
25970 }
25971 if (SWIG_arg_fail(2)) SWIG_fail;
25972 }
25973 {
25974 PyThreadState* __tstate = wxPyBeginAllowThreads();
25975 {
25976 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25977 result = (wxDateSpan *) &_result_ref;
25978 }
25979
25980 wxPyEndAllowThreads(__tstate);
25981 if (PyErr_Occurred()) SWIG_fail;
25982 }
25983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25984 return resultobj;
25985 fail:
25986 return NULL;
25987 }
25988
25989
25990 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25991 PyObject *resultobj;
25992 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25993 wxDateSpan *result;
25994 PyObject * obj0 = 0 ;
25995 char *kwnames[] = {
25996 (char *) "self", NULL
25997 };
25998
25999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
26000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26001 if (SWIG_arg_fail(1)) SWIG_fail;
26002 {
26003 PyThreadState* __tstate = wxPyBeginAllowThreads();
26004 {
26005 wxDateSpan &_result_ref = (arg1)->Neg();
26006 result = (wxDateSpan *) &_result_ref;
26007 }
26008
26009 wxPyEndAllowThreads(__tstate);
26010 if (PyErr_Occurred()) SWIG_fail;
26011 }
26012 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26013 return resultobj;
26014 fail:
26015 return NULL;
26016 }
26017
26018
26019 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
26020 PyObject *resultobj;
26021 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26022 int arg2 ;
26023 wxDateSpan *result;
26024 PyObject * obj0 = 0 ;
26025 PyObject * obj1 = 0 ;
26026 char *kwnames[] = {
26027 (char *) "self",(char *) "factor", NULL
26028 };
26029
26030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
26031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26032 if (SWIG_arg_fail(1)) SWIG_fail;
26033 {
26034 arg2 = (int)(SWIG_As_int(obj1));
26035 if (SWIG_arg_fail(2)) SWIG_fail;
26036 }
26037 {
26038 PyThreadState* __tstate = wxPyBeginAllowThreads();
26039 {
26040 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26041 result = (wxDateSpan *) &_result_ref;
26042 }
26043
26044 wxPyEndAllowThreads(__tstate);
26045 if (PyErr_Occurred()) SWIG_fail;
26046 }
26047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26048 return resultobj;
26049 fail:
26050 return NULL;
26051 }
26052
26053
26054 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26055 PyObject *resultobj;
26056 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26057 wxDateSpan *arg2 = 0 ;
26058 wxDateSpan *result;
26059 PyObject * obj0 = 0 ;
26060 PyObject * obj1 = 0 ;
26061 char *kwnames[] = {
26062 (char *) "self",(char *) "other", NULL
26063 };
26064
26065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26067 if (SWIG_arg_fail(1)) SWIG_fail;
26068 {
26069 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26070 if (SWIG_arg_fail(2)) SWIG_fail;
26071 if (arg2 == NULL) {
26072 SWIG_null_ref("wxDateSpan");
26073 }
26074 if (SWIG_arg_fail(2)) SWIG_fail;
26075 }
26076 {
26077 PyThreadState* __tstate = wxPyBeginAllowThreads();
26078 {
26079 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26080 result = (wxDateSpan *) &_result_ref;
26081 }
26082
26083 wxPyEndAllowThreads(__tstate);
26084 if (PyErr_Occurred()) SWIG_fail;
26085 }
26086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26087 return resultobj;
26088 fail:
26089 return NULL;
26090 }
26091
26092
26093 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26094 PyObject *resultobj;
26095 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26096 wxDateSpan *arg2 = 0 ;
26097 wxDateSpan *result;
26098 PyObject * obj0 = 0 ;
26099 PyObject * obj1 = 0 ;
26100 char *kwnames[] = {
26101 (char *) "self",(char *) "other", NULL
26102 };
26103
26104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26106 if (SWIG_arg_fail(1)) SWIG_fail;
26107 {
26108 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26109 if (SWIG_arg_fail(2)) SWIG_fail;
26110 if (arg2 == NULL) {
26111 SWIG_null_ref("wxDateSpan");
26112 }
26113 if (SWIG_arg_fail(2)) SWIG_fail;
26114 }
26115 {
26116 PyThreadState* __tstate = wxPyBeginAllowThreads();
26117 {
26118 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26119 result = (wxDateSpan *) &_result_ref;
26120 }
26121
26122 wxPyEndAllowThreads(__tstate);
26123 if (PyErr_Occurred()) SWIG_fail;
26124 }
26125 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26126 return resultobj;
26127 fail:
26128 return NULL;
26129 }
26130
26131
26132 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26133 PyObject *resultobj;
26134 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26135 wxDateSpan *result;
26136 PyObject * obj0 = 0 ;
26137 char *kwnames[] = {
26138 (char *) "self", NULL
26139 };
26140
26141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26143 if (SWIG_arg_fail(1)) SWIG_fail;
26144 {
26145 PyThreadState* __tstate = wxPyBeginAllowThreads();
26146 {
26147 wxDateSpan &_result_ref = (arg1)->operator -();
26148 result = (wxDateSpan *) &_result_ref;
26149 }
26150
26151 wxPyEndAllowThreads(__tstate);
26152 if (PyErr_Occurred()) SWIG_fail;
26153 }
26154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26155 return resultobj;
26156 fail:
26157 return NULL;
26158 }
26159
26160
26161 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26162 PyObject *resultobj;
26163 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26164 int arg2 ;
26165 wxDateSpan *result;
26166 PyObject * obj0 = 0 ;
26167 PyObject * obj1 = 0 ;
26168 char *kwnames[] = {
26169 (char *) "self",(char *) "factor", NULL
26170 };
26171
26172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26174 if (SWIG_arg_fail(1)) SWIG_fail;
26175 {
26176 arg2 = (int)(SWIG_As_int(obj1));
26177 if (SWIG_arg_fail(2)) SWIG_fail;
26178 }
26179 {
26180 PyThreadState* __tstate = wxPyBeginAllowThreads();
26181 {
26182 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26183 result = (wxDateSpan *) &_result_ref;
26184 }
26185
26186 wxPyEndAllowThreads(__tstate);
26187 if (PyErr_Occurred()) SWIG_fail;
26188 }
26189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26190 return resultobj;
26191 fail:
26192 return NULL;
26193 }
26194
26195
26196 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26197 PyObject *resultobj;
26198 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26199 wxDateSpan *arg2 = 0 ;
26200 wxDateSpan result;
26201 PyObject * obj0 = 0 ;
26202 PyObject * obj1 = 0 ;
26203 char *kwnames[] = {
26204 (char *) "self",(char *) "other", NULL
26205 };
26206
26207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26209 if (SWIG_arg_fail(1)) SWIG_fail;
26210 {
26211 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26212 if (SWIG_arg_fail(2)) SWIG_fail;
26213 if (arg2 == NULL) {
26214 SWIG_null_ref("wxDateSpan");
26215 }
26216 if (SWIG_arg_fail(2)) SWIG_fail;
26217 }
26218 {
26219 PyThreadState* __tstate = wxPyBeginAllowThreads();
26220 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26221
26222 wxPyEndAllowThreads(__tstate);
26223 if (PyErr_Occurred()) SWIG_fail;
26224 }
26225 {
26226 wxDateSpan * resultptr;
26227 resultptr = new wxDateSpan((wxDateSpan &)(result));
26228 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26229 }
26230 return resultobj;
26231 fail:
26232 return NULL;
26233 }
26234
26235
26236 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26237 PyObject *resultobj;
26238 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26239 wxDateSpan *arg2 = 0 ;
26240 wxDateSpan result;
26241 PyObject * obj0 = 0 ;
26242 PyObject * obj1 = 0 ;
26243 char *kwnames[] = {
26244 (char *) "self",(char *) "other", NULL
26245 };
26246
26247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26249 if (SWIG_arg_fail(1)) SWIG_fail;
26250 {
26251 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26252 if (SWIG_arg_fail(2)) SWIG_fail;
26253 if (arg2 == NULL) {
26254 SWIG_null_ref("wxDateSpan");
26255 }
26256 if (SWIG_arg_fail(2)) SWIG_fail;
26257 }
26258 {
26259 PyThreadState* __tstate = wxPyBeginAllowThreads();
26260 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26261
26262 wxPyEndAllowThreads(__tstate);
26263 if (PyErr_Occurred()) SWIG_fail;
26264 }
26265 {
26266 wxDateSpan * resultptr;
26267 resultptr = new wxDateSpan((wxDateSpan &)(result));
26268 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26269 }
26270 return resultobj;
26271 fail:
26272 return NULL;
26273 }
26274
26275
26276 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26277 PyObject *resultobj;
26278 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26279 int arg2 ;
26280 wxDateSpan result;
26281 PyObject * obj0 = 0 ;
26282 PyObject * obj1 = 0 ;
26283 char *kwnames[] = {
26284 (char *) "self",(char *) "n", NULL
26285 };
26286
26287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26289 if (SWIG_arg_fail(1)) SWIG_fail;
26290 {
26291 arg2 = (int)(SWIG_As_int(obj1));
26292 if (SWIG_arg_fail(2)) SWIG_fail;
26293 }
26294 {
26295 PyThreadState* __tstate = wxPyBeginAllowThreads();
26296 result = wxDateSpan___mul__(arg1,arg2);
26297
26298 wxPyEndAllowThreads(__tstate);
26299 if (PyErr_Occurred()) SWIG_fail;
26300 }
26301 {
26302 wxDateSpan * resultptr;
26303 resultptr = new wxDateSpan((wxDateSpan &)(result));
26304 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26305 }
26306 return resultobj;
26307 fail:
26308 return NULL;
26309 }
26310
26311
26312 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26313 PyObject *resultobj;
26314 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26315 int arg2 ;
26316 wxDateSpan result;
26317 PyObject * obj0 = 0 ;
26318 PyObject * obj1 = 0 ;
26319 char *kwnames[] = {
26320 (char *) "self",(char *) "n", NULL
26321 };
26322
26323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26325 if (SWIG_arg_fail(1)) SWIG_fail;
26326 {
26327 arg2 = (int)(SWIG_As_int(obj1));
26328 if (SWIG_arg_fail(2)) SWIG_fail;
26329 }
26330 {
26331 PyThreadState* __tstate = wxPyBeginAllowThreads();
26332 result = wxDateSpan___rmul__(arg1,arg2);
26333
26334 wxPyEndAllowThreads(__tstate);
26335 if (PyErr_Occurred()) SWIG_fail;
26336 }
26337 {
26338 wxDateSpan * resultptr;
26339 resultptr = new wxDateSpan((wxDateSpan &)(result));
26340 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26341 }
26342 return resultobj;
26343 fail:
26344 return NULL;
26345 }
26346
26347
26348 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26349 PyObject *resultobj;
26350 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26351 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26352 bool result;
26353 PyObject * obj0 = 0 ;
26354 PyObject * obj1 = 0 ;
26355 char *kwnames[] = {
26356 (char *) "self",(char *) "other", NULL
26357 };
26358
26359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26361 if (SWIG_arg_fail(1)) SWIG_fail;
26362 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26363 if (SWIG_arg_fail(2)) SWIG_fail;
26364 {
26365 PyThreadState* __tstate = wxPyBeginAllowThreads();
26366 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26367
26368 wxPyEndAllowThreads(__tstate);
26369 if (PyErr_Occurred()) SWIG_fail;
26370 }
26371 {
26372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26373 }
26374 return resultobj;
26375 fail:
26376 return NULL;
26377 }
26378
26379
26380 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26381 PyObject *resultobj;
26382 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26383 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26384 bool result;
26385 PyObject * obj0 = 0 ;
26386 PyObject * obj1 = 0 ;
26387 char *kwnames[] = {
26388 (char *) "self",(char *) "other", NULL
26389 };
26390
26391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26393 if (SWIG_arg_fail(1)) SWIG_fail;
26394 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26395 if (SWIG_arg_fail(2)) SWIG_fail;
26396 {
26397 PyThreadState* __tstate = wxPyBeginAllowThreads();
26398 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26399
26400 wxPyEndAllowThreads(__tstate);
26401 if (PyErr_Occurred()) SWIG_fail;
26402 }
26403 {
26404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26405 }
26406 return resultobj;
26407 fail:
26408 return NULL;
26409 }
26410
26411
26412 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26413 PyObject *obj;
26414 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26415 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26416 Py_INCREF(obj);
26417 return Py_BuildValue((char *)"");
26418 }
26419 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26420 PyObject *resultobj;
26421 long result;
26422 char *kwnames[] = {
26423 NULL
26424 };
26425
26426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26427 {
26428 PyThreadState* __tstate = wxPyBeginAllowThreads();
26429 result = (long)wxGetLocalTime();
26430
26431 wxPyEndAllowThreads(__tstate);
26432 if (PyErr_Occurred()) SWIG_fail;
26433 }
26434 {
26435 resultobj = SWIG_From_long((long)(result));
26436 }
26437 return resultobj;
26438 fail:
26439 return NULL;
26440 }
26441
26442
26443 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26444 PyObject *resultobj;
26445 long result;
26446 char *kwnames[] = {
26447 NULL
26448 };
26449
26450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26451 {
26452 PyThreadState* __tstate = wxPyBeginAllowThreads();
26453 result = (long)wxGetUTCTime();
26454
26455 wxPyEndAllowThreads(__tstate);
26456 if (PyErr_Occurred()) SWIG_fail;
26457 }
26458 {
26459 resultobj = SWIG_From_long((long)(result));
26460 }
26461 return resultobj;
26462 fail:
26463 return NULL;
26464 }
26465
26466
26467 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26468 PyObject *resultobj;
26469 long result;
26470 char *kwnames[] = {
26471 NULL
26472 };
26473
26474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26475 {
26476 PyThreadState* __tstate = wxPyBeginAllowThreads();
26477 result = (long)wxGetCurrentTime();
26478
26479 wxPyEndAllowThreads(__tstate);
26480 if (PyErr_Occurred()) SWIG_fail;
26481 }
26482 {
26483 resultobj = SWIG_From_long((long)(result));
26484 }
26485 return resultobj;
26486 fail:
26487 return NULL;
26488 }
26489
26490
26491 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26492 PyObject *resultobj;
26493 wxLongLong result;
26494 char *kwnames[] = {
26495 NULL
26496 };
26497
26498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26499 {
26500 PyThreadState* __tstate = wxPyBeginAllowThreads();
26501 result = wxGetLocalTimeMillis();
26502
26503 wxPyEndAllowThreads(__tstate);
26504 if (PyErr_Occurred()) SWIG_fail;
26505 }
26506 {
26507 PyObject *hi, *lo, *shifter, *shifted;
26508 hi = PyLong_FromLong( (&result)->GetHi() );
26509 lo = PyLong_FromLong( (&result)->GetLo() );
26510 shifter = PyLong_FromLong(32);
26511 shifted = PyNumber_Lshift(hi, shifter);
26512 resultobj = PyNumber_Or(shifted, lo);
26513 Py_DECREF(hi);
26514 Py_DECREF(lo);
26515 Py_DECREF(shifter);
26516 Py_DECREF(shifted);
26517 }
26518 return resultobj;
26519 fail:
26520 return NULL;
26521 }
26522
26523
26524 static int _wrap_DefaultDateTime_set(PyObject *) {
26525 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26526 return 1;
26527 }
26528
26529
26530 static PyObject *_wrap_DefaultDateTime_get(void) {
26531 PyObject *pyobj;
26532
26533 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26534 return pyobj;
26535 }
26536
26537
26538 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26539 PyObject *resultobj;
26540 wxDataFormatId arg1 ;
26541 wxDataFormat *result;
26542 PyObject * obj0 = 0 ;
26543 char *kwnames[] = {
26544 (char *) "type", NULL
26545 };
26546
26547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26548 {
26549 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26550 if (SWIG_arg_fail(1)) SWIG_fail;
26551 }
26552 {
26553 PyThreadState* __tstate = wxPyBeginAllowThreads();
26554 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26555
26556 wxPyEndAllowThreads(__tstate);
26557 if (PyErr_Occurred()) SWIG_fail;
26558 }
26559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26560 return resultobj;
26561 fail:
26562 return NULL;
26563 }
26564
26565
26566 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26567 PyObject *resultobj;
26568 wxString *arg1 = 0 ;
26569 wxDataFormat *result;
26570 bool temp1 = false ;
26571 PyObject * obj0 = 0 ;
26572 char *kwnames[] = {
26573 (char *) "format", NULL
26574 };
26575
26576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26577 {
26578 arg1 = wxString_in_helper(obj0);
26579 if (arg1 == NULL) SWIG_fail;
26580 temp1 = true;
26581 }
26582 {
26583 PyThreadState* __tstate = wxPyBeginAllowThreads();
26584 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26585
26586 wxPyEndAllowThreads(__tstate);
26587 if (PyErr_Occurred()) SWIG_fail;
26588 }
26589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26590 {
26591 if (temp1)
26592 delete arg1;
26593 }
26594 return resultobj;
26595 fail:
26596 {
26597 if (temp1)
26598 delete arg1;
26599 }
26600 return NULL;
26601 }
26602
26603
26604 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26605 PyObject *resultobj;
26606 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26607 PyObject * obj0 = 0 ;
26608 char *kwnames[] = {
26609 (char *) "self", NULL
26610 };
26611
26612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26614 if (SWIG_arg_fail(1)) SWIG_fail;
26615 {
26616 PyThreadState* __tstate = wxPyBeginAllowThreads();
26617 delete arg1;
26618
26619 wxPyEndAllowThreads(__tstate);
26620 if (PyErr_Occurred()) SWIG_fail;
26621 }
26622 Py_INCREF(Py_None); resultobj = Py_None;
26623 return resultobj;
26624 fail:
26625 return NULL;
26626 }
26627
26628
26629 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26630 PyObject *resultobj;
26631 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26632 wxDataFormatId arg2 ;
26633 bool result;
26634 PyObject * obj0 = 0 ;
26635 PyObject * obj1 = 0 ;
26636
26637 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26639 if (SWIG_arg_fail(1)) SWIG_fail;
26640 {
26641 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26642 if (SWIG_arg_fail(2)) SWIG_fail;
26643 }
26644 {
26645 PyThreadState* __tstate = wxPyBeginAllowThreads();
26646 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26647
26648 wxPyEndAllowThreads(__tstate);
26649 if (PyErr_Occurred()) SWIG_fail;
26650 }
26651 {
26652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26653 }
26654 return resultobj;
26655 fail:
26656 return NULL;
26657 }
26658
26659
26660 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26661 PyObject *resultobj;
26662 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26663 wxDataFormatId arg2 ;
26664 bool result;
26665 PyObject * obj0 = 0 ;
26666 PyObject * obj1 = 0 ;
26667
26668 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26670 if (SWIG_arg_fail(1)) SWIG_fail;
26671 {
26672 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26673 if (SWIG_arg_fail(2)) SWIG_fail;
26674 }
26675 {
26676 PyThreadState* __tstate = wxPyBeginAllowThreads();
26677 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26678
26679 wxPyEndAllowThreads(__tstate);
26680 if (PyErr_Occurred()) SWIG_fail;
26681 }
26682 {
26683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26684 }
26685 return resultobj;
26686 fail:
26687 return NULL;
26688 }
26689
26690
26691 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26692 PyObject *resultobj;
26693 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26694 wxDataFormat *arg2 = 0 ;
26695 bool result;
26696 PyObject * obj0 = 0 ;
26697 PyObject * obj1 = 0 ;
26698
26699 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26701 if (SWIG_arg_fail(1)) SWIG_fail;
26702 {
26703 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26704 if (SWIG_arg_fail(2)) SWIG_fail;
26705 if (arg2 == NULL) {
26706 SWIG_null_ref("wxDataFormat");
26707 }
26708 if (SWIG_arg_fail(2)) SWIG_fail;
26709 }
26710 {
26711 PyThreadState* __tstate = wxPyBeginAllowThreads();
26712 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26713
26714 wxPyEndAllowThreads(__tstate);
26715 if (PyErr_Occurred()) SWIG_fail;
26716 }
26717 {
26718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26719 }
26720 return resultobj;
26721 fail:
26722 return NULL;
26723 }
26724
26725
26726 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26727 int argc;
26728 PyObject *argv[3];
26729 int ii;
26730
26731 argc = PyObject_Length(args);
26732 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26733 argv[ii] = PyTuple_GetItem(args,ii);
26734 }
26735 if (argc == 2) {
26736 int _v;
26737 {
26738 void *ptr;
26739 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26740 _v = 0;
26741 PyErr_Clear();
26742 } else {
26743 _v = 1;
26744 }
26745 }
26746 if (_v) {
26747 {
26748 void *ptr = 0;
26749 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26750 _v = 0;
26751 PyErr_Clear();
26752 } else {
26753 _v = (ptr != 0);
26754 }
26755 }
26756 if (_v) {
26757 return _wrap_DataFormat___eq____SWIG_1(self,args);
26758 }
26759 }
26760 }
26761 if (argc == 2) {
26762 int _v;
26763 {
26764 void *ptr;
26765 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26766 _v = 0;
26767 PyErr_Clear();
26768 } else {
26769 _v = 1;
26770 }
26771 }
26772 if (_v) {
26773 _v = SWIG_Check_int(argv[1]);
26774 if (_v) {
26775 return _wrap_DataFormat___eq____SWIG_0(self,args);
26776 }
26777 }
26778 }
26779
26780 Py_INCREF(Py_NotImplemented);
26781 return Py_NotImplemented;
26782 }
26783
26784
26785 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26786 PyObject *resultobj;
26787 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26788 wxDataFormat *arg2 = 0 ;
26789 bool result;
26790 PyObject * obj0 = 0 ;
26791 PyObject * obj1 = 0 ;
26792
26793 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26795 if (SWIG_arg_fail(1)) SWIG_fail;
26796 {
26797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26798 if (SWIG_arg_fail(2)) SWIG_fail;
26799 if (arg2 == NULL) {
26800 SWIG_null_ref("wxDataFormat");
26801 }
26802 if (SWIG_arg_fail(2)) SWIG_fail;
26803 }
26804 {
26805 PyThreadState* __tstate = wxPyBeginAllowThreads();
26806 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26807
26808 wxPyEndAllowThreads(__tstate);
26809 if (PyErr_Occurred()) SWIG_fail;
26810 }
26811 {
26812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26813 }
26814 return resultobj;
26815 fail:
26816 return NULL;
26817 }
26818
26819
26820 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26821 int argc;
26822 PyObject *argv[3];
26823 int ii;
26824
26825 argc = PyObject_Length(args);
26826 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26827 argv[ii] = PyTuple_GetItem(args,ii);
26828 }
26829 if (argc == 2) {
26830 int _v;
26831 {
26832 void *ptr;
26833 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26834 _v = 0;
26835 PyErr_Clear();
26836 } else {
26837 _v = 1;
26838 }
26839 }
26840 if (_v) {
26841 {
26842 void *ptr = 0;
26843 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26844 _v = 0;
26845 PyErr_Clear();
26846 } else {
26847 _v = (ptr != 0);
26848 }
26849 }
26850 if (_v) {
26851 return _wrap_DataFormat___ne____SWIG_1(self,args);
26852 }
26853 }
26854 }
26855 if (argc == 2) {
26856 int _v;
26857 {
26858 void *ptr;
26859 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26860 _v = 0;
26861 PyErr_Clear();
26862 } else {
26863 _v = 1;
26864 }
26865 }
26866 if (_v) {
26867 _v = SWIG_Check_int(argv[1]);
26868 if (_v) {
26869 return _wrap_DataFormat___ne____SWIG_0(self,args);
26870 }
26871 }
26872 }
26873
26874 Py_INCREF(Py_NotImplemented);
26875 return Py_NotImplemented;
26876 }
26877
26878
26879 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26880 PyObject *resultobj;
26881 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26882 wxDataFormatId arg2 ;
26883 PyObject * obj0 = 0 ;
26884 PyObject * obj1 = 0 ;
26885 char *kwnames[] = {
26886 (char *) "self",(char *) "format", NULL
26887 };
26888
26889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26891 if (SWIG_arg_fail(1)) SWIG_fail;
26892 {
26893 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26894 if (SWIG_arg_fail(2)) SWIG_fail;
26895 }
26896 {
26897 PyThreadState* __tstate = wxPyBeginAllowThreads();
26898 (arg1)->SetType((wxDataFormatId )arg2);
26899
26900 wxPyEndAllowThreads(__tstate);
26901 if (PyErr_Occurred()) SWIG_fail;
26902 }
26903 Py_INCREF(Py_None); resultobj = Py_None;
26904 return resultobj;
26905 fail:
26906 return NULL;
26907 }
26908
26909
26910 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26911 PyObject *resultobj;
26912 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26913 wxDataFormatId result;
26914 PyObject * obj0 = 0 ;
26915 char *kwnames[] = {
26916 (char *) "self", NULL
26917 };
26918
26919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26921 if (SWIG_arg_fail(1)) SWIG_fail;
26922 {
26923 PyThreadState* __tstate = wxPyBeginAllowThreads();
26924 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26925
26926 wxPyEndAllowThreads(__tstate);
26927 if (PyErr_Occurred()) SWIG_fail;
26928 }
26929 resultobj = SWIG_From_int((result));
26930 return resultobj;
26931 fail:
26932 return NULL;
26933 }
26934
26935
26936 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26937 PyObject *resultobj;
26938 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26939 wxString result;
26940 PyObject * obj0 = 0 ;
26941 char *kwnames[] = {
26942 (char *) "self", NULL
26943 };
26944
26945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26947 if (SWIG_arg_fail(1)) SWIG_fail;
26948 {
26949 PyThreadState* __tstate = wxPyBeginAllowThreads();
26950 result = ((wxDataFormat const *)arg1)->GetId();
26951
26952 wxPyEndAllowThreads(__tstate);
26953 if (PyErr_Occurred()) SWIG_fail;
26954 }
26955 {
26956 #if wxUSE_UNICODE
26957 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26958 #else
26959 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26960 #endif
26961 }
26962 return resultobj;
26963 fail:
26964 return NULL;
26965 }
26966
26967
26968 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26969 PyObject *resultobj;
26970 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26971 wxString *arg2 = 0 ;
26972 bool temp2 = false ;
26973 PyObject * obj0 = 0 ;
26974 PyObject * obj1 = 0 ;
26975 char *kwnames[] = {
26976 (char *) "self",(char *) "format", NULL
26977 };
26978
26979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26981 if (SWIG_arg_fail(1)) SWIG_fail;
26982 {
26983 arg2 = wxString_in_helper(obj1);
26984 if (arg2 == NULL) SWIG_fail;
26985 temp2 = true;
26986 }
26987 {
26988 PyThreadState* __tstate = wxPyBeginAllowThreads();
26989 (arg1)->SetId((wxString const &)*arg2);
26990
26991 wxPyEndAllowThreads(__tstate);
26992 if (PyErr_Occurred()) SWIG_fail;
26993 }
26994 Py_INCREF(Py_None); resultobj = Py_None;
26995 {
26996 if (temp2)
26997 delete arg2;
26998 }
26999 return resultobj;
27000 fail:
27001 {
27002 if (temp2)
27003 delete arg2;
27004 }
27005 return NULL;
27006 }
27007
27008
27009 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
27010 PyObject *obj;
27011 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27012 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
27013 Py_INCREF(obj);
27014 return Py_BuildValue((char *)"");
27015 }
27016 static int _wrap_FormatInvalid_set(PyObject *) {
27017 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
27018 return 1;
27019 }
27020
27021
27022 static PyObject *_wrap_FormatInvalid_get(void) {
27023 PyObject *pyobj;
27024
27025 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
27026 return pyobj;
27027 }
27028
27029
27030 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27031 PyObject *resultobj;
27032 wxDataObject *arg1 = (wxDataObject *) 0 ;
27033 PyObject * obj0 = 0 ;
27034 char *kwnames[] = {
27035 (char *) "self", NULL
27036 };
27037
27038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27040 if (SWIG_arg_fail(1)) SWIG_fail;
27041 {
27042 PyThreadState* __tstate = wxPyBeginAllowThreads();
27043 delete arg1;
27044
27045 wxPyEndAllowThreads(__tstate);
27046 if (PyErr_Occurred()) SWIG_fail;
27047 }
27048 Py_INCREF(Py_None); resultobj = Py_None;
27049 return resultobj;
27050 fail:
27051 return NULL;
27052 }
27053
27054
27055 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27056 PyObject *resultobj;
27057 wxDataObject *arg1 = (wxDataObject *) 0 ;
27058 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27059 SwigValueWrapper<wxDataFormat > result;
27060 PyObject * obj0 = 0 ;
27061 PyObject * obj1 = 0 ;
27062 char *kwnames[] = {
27063 (char *) "self",(char *) "dir", NULL
27064 };
27065
27066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27068 if (SWIG_arg_fail(1)) SWIG_fail;
27069 if (obj1) {
27070 {
27071 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27072 if (SWIG_arg_fail(2)) SWIG_fail;
27073 }
27074 }
27075 {
27076 PyThreadState* __tstate = wxPyBeginAllowThreads();
27077 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27078
27079 wxPyEndAllowThreads(__tstate);
27080 if (PyErr_Occurred()) SWIG_fail;
27081 }
27082 {
27083 wxDataFormat * resultptr;
27084 resultptr = new wxDataFormat((wxDataFormat &)(result));
27085 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27086 }
27087 return resultobj;
27088 fail:
27089 return NULL;
27090 }
27091
27092
27093 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27094 PyObject *resultobj;
27095 wxDataObject *arg1 = (wxDataObject *) 0 ;
27096 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27097 size_t result;
27098 PyObject * obj0 = 0 ;
27099 PyObject * obj1 = 0 ;
27100 char *kwnames[] = {
27101 (char *) "self",(char *) "dir", NULL
27102 };
27103
27104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27106 if (SWIG_arg_fail(1)) SWIG_fail;
27107 if (obj1) {
27108 {
27109 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27110 if (SWIG_arg_fail(2)) SWIG_fail;
27111 }
27112 }
27113 {
27114 PyThreadState* __tstate = wxPyBeginAllowThreads();
27115 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27116
27117 wxPyEndAllowThreads(__tstate);
27118 if (PyErr_Occurred()) SWIG_fail;
27119 }
27120 {
27121 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27122 }
27123 return resultobj;
27124 fail:
27125 return NULL;
27126 }
27127
27128
27129 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27130 PyObject *resultobj;
27131 wxDataObject *arg1 = (wxDataObject *) 0 ;
27132 wxDataFormat *arg2 = 0 ;
27133 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27134 bool result;
27135 PyObject * obj0 = 0 ;
27136 PyObject * obj1 = 0 ;
27137 PyObject * obj2 = 0 ;
27138 char *kwnames[] = {
27139 (char *) "self",(char *) "format",(char *) "dir", NULL
27140 };
27141
27142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27144 if (SWIG_arg_fail(1)) SWIG_fail;
27145 {
27146 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27147 if (SWIG_arg_fail(2)) SWIG_fail;
27148 if (arg2 == NULL) {
27149 SWIG_null_ref("wxDataFormat");
27150 }
27151 if (SWIG_arg_fail(2)) SWIG_fail;
27152 }
27153 if (obj2) {
27154 {
27155 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27156 if (SWIG_arg_fail(3)) SWIG_fail;
27157 }
27158 }
27159 {
27160 PyThreadState* __tstate = wxPyBeginAllowThreads();
27161 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27162
27163 wxPyEndAllowThreads(__tstate);
27164 if (PyErr_Occurred()) SWIG_fail;
27165 }
27166 {
27167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27168 }
27169 return resultobj;
27170 fail:
27171 return NULL;
27172 }
27173
27174
27175 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27176 PyObject *resultobj;
27177 wxDataObject *arg1 = (wxDataObject *) 0 ;
27178 wxDataFormat *arg2 = 0 ;
27179 size_t result;
27180 PyObject * obj0 = 0 ;
27181 PyObject * obj1 = 0 ;
27182 char *kwnames[] = {
27183 (char *) "self",(char *) "format", NULL
27184 };
27185
27186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27188 if (SWIG_arg_fail(1)) SWIG_fail;
27189 {
27190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27191 if (SWIG_arg_fail(2)) SWIG_fail;
27192 if (arg2 == NULL) {
27193 SWIG_null_ref("wxDataFormat");
27194 }
27195 if (SWIG_arg_fail(2)) SWIG_fail;
27196 }
27197 {
27198 PyThreadState* __tstate = wxPyBeginAllowThreads();
27199 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27200
27201 wxPyEndAllowThreads(__tstate);
27202 if (PyErr_Occurred()) SWIG_fail;
27203 }
27204 {
27205 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27206 }
27207 return resultobj;
27208 fail:
27209 return NULL;
27210 }
27211
27212
27213 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27214 PyObject *resultobj;
27215 wxDataObject *arg1 = (wxDataObject *) 0 ;
27216 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27217 PyObject *result;
27218 PyObject * obj0 = 0 ;
27219 PyObject * obj1 = 0 ;
27220 char *kwnames[] = {
27221 (char *) "self",(char *) "dir", NULL
27222 };
27223
27224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27226 if (SWIG_arg_fail(1)) SWIG_fail;
27227 if (obj1) {
27228 {
27229 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27230 if (SWIG_arg_fail(2)) SWIG_fail;
27231 }
27232 }
27233 {
27234 PyThreadState* __tstate = wxPyBeginAllowThreads();
27235 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27236
27237 wxPyEndAllowThreads(__tstate);
27238 if (PyErr_Occurred()) SWIG_fail;
27239 }
27240 resultobj = result;
27241 return resultobj;
27242 fail:
27243 return NULL;
27244 }
27245
27246
27247 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27248 PyObject *resultobj;
27249 wxDataObject *arg1 = (wxDataObject *) 0 ;
27250 wxDataFormat *arg2 = 0 ;
27251 PyObject *result;
27252 PyObject * obj0 = 0 ;
27253 PyObject * obj1 = 0 ;
27254 char *kwnames[] = {
27255 (char *) "self",(char *) "format", NULL
27256 };
27257
27258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27260 if (SWIG_arg_fail(1)) SWIG_fail;
27261 {
27262 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27263 if (SWIG_arg_fail(2)) SWIG_fail;
27264 if (arg2 == NULL) {
27265 SWIG_null_ref("wxDataFormat");
27266 }
27267 if (SWIG_arg_fail(2)) SWIG_fail;
27268 }
27269 {
27270 PyThreadState* __tstate = wxPyBeginAllowThreads();
27271 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27272
27273 wxPyEndAllowThreads(__tstate);
27274 if (PyErr_Occurred()) SWIG_fail;
27275 }
27276 resultobj = result;
27277 return resultobj;
27278 fail:
27279 return NULL;
27280 }
27281
27282
27283 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27284 PyObject *resultobj;
27285 wxDataObject *arg1 = (wxDataObject *) 0 ;
27286 wxDataFormat *arg2 = 0 ;
27287 PyObject *arg3 = (PyObject *) 0 ;
27288 bool result;
27289 PyObject * obj0 = 0 ;
27290 PyObject * obj1 = 0 ;
27291 PyObject * obj2 = 0 ;
27292 char *kwnames[] = {
27293 (char *) "self",(char *) "format",(char *) "data", NULL
27294 };
27295
27296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27298 if (SWIG_arg_fail(1)) SWIG_fail;
27299 {
27300 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27301 if (SWIG_arg_fail(2)) SWIG_fail;
27302 if (arg2 == NULL) {
27303 SWIG_null_ref("wxDataFormat");
27304 }
27305 if (SWIG_arg_fail(2)) SWIG_fail;
27306 }
27307 arg3 = obj2;
27308 {
27309 PyThreadState* __tstate = wxPyBeginAllowThreads();
27310 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27311
27312 wxPyEndAllowThreads(__tstate);
27313 if (PyErr_Occurred()) SWIG_fail;
27314 }
27315 {
27316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27317 }
27318 return resultobj;
27319 fail:
27320 return NULL;
27321 }
27322
27323
27324 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27325 PyObject *obj;
27326 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27327 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27328 Py_INCREF(obj);
27329 return Py_BuildValue((char *)"");
27330 }
27331 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27332 PyObject *resultobj;
27333 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27334 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27335 wxDataObjectSimple *result;
27336 PyObject * obj0 = 0 ;
27337 char *kwnames[] = {
27338 (char *) "format", NULL
27339 };
27340
27341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27342 if (obj0) {
27343 {
27344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27345 if (SWIG_arg_fail(1)) SWIG_fail;
27346 if (arg1 == NULL) {
27347 SWIG_null_ref("wxDataFormat");
27348 }
27349 if (SWIG_arg_fail(1)) SWIG_fail;
27350 }
27351 }
27352 {
27353 PyThreadState* __tstate = wxPyBeginAllowThreads();
27354 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27355
27356 wxPyEndAllowThreads(__tstate);
27357 if (PyErr_Occurred()) SWIG_fail;
27358 }
27359 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27360 return resultobj;
27361 fail:
27362 return NULL;
27363 }
27364
27365
27366 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27367 PyObject *resultobj;
27368 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27369 wxDataFormat *result;
27370 PyObject * obj0 = 0 ;
27371 char *kwnames[] = {
27372 (char *) "self", NULL
27373 };
27374
27375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27377 if (SWIG_arg_fail(1)) SWIG_fail;
27378 {
27379 PyThreadState* __tstate = wxPyBeginAllowThreads();
27380 {
27381 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27382 result = (wxDataFormat *) &_result_ref;
27383 }
27384
27385 wxPyEndAllowThreads(__tstate);
27386 if (PyErr_Occurred()) SWIG_fail;
27387 }
27388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27389 return resultobj;
27390 fail:
27391 return NULL;
27392 }
27393
27394
27395 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27396 PyObject *resultobj;
27397 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27398 wxDataFormat *arg2 = 0 ;
27399 PyObject * obj0 = 0 ;
27400 PyObject * obj1 = 0 ;
27401 char *kwnames[] = {
27402 (char *) "self",(char *) "format", NULL
27403 };
27404
27405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27407 if (SWIG_arg_fail(1)) SWIG_fail;
27408 {
27409 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27410 if (SWIG_arg_fail(2)) SWIG_fail;
27411 if (arg2 == NULL) {
27412 SWIG_null_ref("wxDataFormat");
27413 }
27414 if (SWIG_arg_fail(2)) SWIG_fail;
27415 }
27416 {
27417 PyThreadState* __tstate = wxPyBeginAllowThreads();
27418 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27419
27420 wxPyEndAllowThreads(__tstate);
27421 if (PyErr_Occurred()) SWIG_fail;
27422 }
27423 Py_INCREF(Py_None); resultobj = Py_None;
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27431 PyObject *resultobj;
27432 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27433 size_t result;
27434 PyObject * obj0 = 0 ;
27435 char *kwnames[] = {
27436 (char *) "self", NULL
27437 };
27438
27439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27441 if (SWIG_arg_fail(1)) SWIG_fail;
27442 {
27443 PyThreadState* __tstate = wxPyBeginAllowThreads();
27444 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27445
27446 wxPyEndAllowThreads(__tstate);
27447 if (PyErr_Occurred()) SWIG_fail;
27448 }
27449 {
27450 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27451 }
27452 return resultobj;
27453 fail:
27454 return NULL;
27455 }
27456
27457
27458 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27459 PyObject *resultobj;
27460 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27461 PyObject *result;
27462 PyObject * obj0 = 0 ;
27463 char *kwnames[] = {
27464 (char *) "self", NULL
27465 };
27466
27467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27469 if (SWIG_arg_fail(1)) SWIG_fail;
27470 {
27471 PyThreadState* __tstate = wxPyBeginAllowThreads();
27472 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27473
27474 wxPyEndAllowThreads(__tstate);
27475 if (PyErr_Occurred()) SWIG_fail;
27476 }
27477 resultobj = result;
27478 return resultobj;
27479 fail:
27480 return NULL;
27481 }
27482
27483
27484 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27485 PyObject *resultobj;
27486 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27487 PyObject *arg2 = (PyObject *) 0 ;
27488 bool result;
27489 PyObject * obj0 = 0 ;
27490 PyObject * obj1 = 0 ;
27491 char *kwnames[] = {
27492 (char *) "self",(char *) "data", NULL
27493 };
27494
27495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27497 if (SWIG_arg_fail(1)) SWIG_fail;
27498 arg2 = obj1;
27499 {
27500 PyThreadState* __tstate = wxPyBeginAllowThreads();
27501 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27502
27503 wxPyEndAllowThreads(__tstate);
27504 if (PyErr_Occurred()) SWIG_fail;
27505 }
27506 {
27507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27508 }
27509 return resultobj;
27510 fail:
27511 return NULL;
27512 }
27513
27514
27515 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27516 PyObject *obj;
27517 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27518 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27519 Py_INCREF(obj);
27520 return Py_BuildValue((char *)"");
27521 }
27522 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27523 PyObject *resultobj;
27524 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27525 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27526 wxPyDataObjectSimple *result;
27527 PyObject * obj0 = 0 ;
27528 char *kwnames[] = {
27529 (char *) "format", NULL
27530 };
27531
27532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27533 if (obj0) {
27534 {
27535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27536 if (SWIG_arg_fail(1)) SWIG_fail;
27537 if (arg1 == NULL) {
27538 SWIG_null_ref("wxDataFormat");
27539 }
27540 if (SWIG_arg_fail(1)) SWIG_fail;
27541 }
27542 }
27543 {
27544 PyThreadState* __tstate = wxPyBeginAllowThreads();
27545 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27546
27547 wxPyEndAllowThreads(__tstate);
27548 if (PyErr_Occurred()) SWIG_fail;
27549 }
27550 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27551 return resultobj;
27552 fail:
27553 return NULL;
27554 }
27555
27556
27557 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27558 PyObject *resultobj;
27559 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27560 PyObject *arg2 = (PyObject *) 0 ;
27561 PyObject *arg3 = (PyObject *) 0 ;
27562 PyObject * obj0 = 0 ;
27563 PyObject * obj1 = 0 ;
27564 PyObject * obj2 = 0 ;
27565 char *kwnames[] = {
27566 (char *) "self",(char *) "self",(char *) "_class", NULL
27567 };
27568
27569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27571 if (SWIG_arg_fail(1)) SWIG_fail;
27572 arg2 = obj1;
27573 arg3 = obj2;
27574 {
27575 PyThreadState* __tstate = wxPyBeginAllowThreads();
27576 (arg1)->_setCallbackInfo(arg2,arg3);
27577
27578 wxPyEndAllowThreads(__tstate);
27579 if (PyErr_Occurred()) SWIG_fail;
27580 }
27581 Py_INCREF(Py_None); resultobj = Py_None;
27582 return resultobj;
27583 fail:
27584 return NULL;
27585 }
27586
27587
27588 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27589 PyObject *obj;
27590 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27591 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27592 Py_INCREF(obj);
27593 return Py_BuildValue((char *)"");
27594 }
27595 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27596 PyObject *resultobj;
27597 wxDataObjectComposite *result;
27598 char *kwnames[] = {
27599 NULL
27600 };
27601
27602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27603 {
27604 PyThreadState* __tstate = wxPyBeginAllowThreads();
27605 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27606
27607 wxPyEndAllowThreads(__tstate);
27608 if (PyErr_Occurred()) SWIG_fail;
27609 }
27610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27611 return resultobj;
27612 fail:
27613 return NULL;
27614 }
27615
27616
27617 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27618 PyObject *resultobj;
27619 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27620 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27621 bool arg3 = (bool) false ;
27622 PyObject * obj0 = 0 ;
27623 PyObject * obj1 = 0 ;
27624 PyObject * obj2 = 0 ;
27625 char *kwnames[] = {
27626 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27627 };
27628
27629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27631 if (SWIG_arg_fail(1)) SWIG_fail;
27632 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27633 if (SWIG_arg_fail(2)) SWIG_fail;
27634 if (obj2) {
27635 {
27636 arg3 = (bool)(SWIG_As_bool(obj2));
27637 if (SWIG_arg_fail(3)) SWIG_fail;
27638 }
27639 }
27640 {
27641 PyThreadState* __tstate = wxPyBeginAllowThreads();
27642 (arg1)->Add(arg2,arg3);
27643
27644 wxPyEndAllowThreads(__tstate);
27645 if (PyErr_Occurred()) SWIG_fail;
27646 }
27647 Py_INCREF(Py_None); resultobj = Py_None;
27648 return resultobj;
27649 fail:
27650 return NULL;
27651 }
27652
27653
27654 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27655 PyObject *obj;
27656 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27657 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27658 Py_INCREF(obj);
27659 return Py_BuildValue((char *)"");
27660 }
27661 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27662 PyObject *resultobj;
27663 wxString const &arg1_defvalue = wxPyEmptyString ;
27664 wxString *arg1 = (wxString *) &arg1_defvalue ;
27665 wxTextDataObject *result;
27666 bool temp1 = false ;
27667 PyObject * obj0 = 0 ;
27668 char *kwnames[] = {
27669 (char *) "text", NULL
27670 };
27671
27672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27673 if (obj0) {
27674 {
27675 arg1 = wxString_in_helper(obj0);
27676 if (arg1 == NULL) SWIG_fail;
27677 temp1 = true;
27678 }
27679 }
27680 {
27681 PyThreadState* __tstate = wxPyBeginAllowThreads();
27682 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27683
27684 wxPyEndAllowThreads(__tstate);
27685 if (PyErr_Occurred()) SWIG_fail;
27686 }
27687 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27688 {
27689 if (temp1)
27690 delete arg1;
27691 }
27692 return resultobj;
27693 fail:
27694 {
27695 if (temp1)
27696 delete arg1;
27697 }
27698 return NULL;
27699 }
27700
27701
27702 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27703 PyObject *resultobj;
27704 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27705 size_t result;
27706 PyObject * obj0 = 0 ;
27707 char *kwnames[] = {
27708 (char *) "self", NULL
27709 };
27710
27711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27713 if (SWIG_arg_fail(1)) SWIG_fail;
27714 {
27715 PyThreadState* __tstate = wxPyBeginAllowThreads();
27716 result = (size_t)(arg1)->GetTextLength();
27717
27718 wxPyEndAllowThreads(__tstate);
27719 if (PyErr_Occurred()) SWIG_fail;
27720 }
27721 {
27722 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27723 }
27724 return resultobj;
27725 fail:
27726 return NULL;
27727 }
27728
27729
27730 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27731 PyObject *resultobj;
27732 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27733 wxString result;
27734 PyObject * obj0 = 0 ;
27735 char *kwnames[] = {
27736 (char *) "self", NULL
27737 };
27738
27739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27741 if (SWIG_arg_fail(1)) SWIG_fail;
27742 {
27743 PyThreadState* __tstate = wxPyBeginAllowThreads();
27744 result = (arg1)->GetText();
27745
27746 wxPyEndAllowThreads(__tstate);
27747 if (PyErr_Occurred()) SWIG_fail;
27748 }
27749 {
27750 #if wxUSE_UNICODE
27751 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27752 #else
27753 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27754 #endif
27755 }
27756 return resultobj;
27757 fail:
27758 return NULL;
27759 }
27760
27761
27762 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27763 PyObject *resultobj;
27764 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27765 wxString *arg2 = 0 ;
27766 bool temp2 = false ;
27767 PyObject * obj0 = 0 ;
27768 PyObject * obj1 = 0 ;
27769 char *kwnames[] = {
27770 (char *) "self",(char *) "text", NULL
27771 };
27772
27773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27775 if (SWIG_arg_fail(1)) SWIG_fail;
27776 {
27777 arg2 = wxString_in_helper(obj1);
27778 if (arg2 == NULL) SWIG_fail;
27779 temp2 = true;
27780 }
27781 {
27782 PyThreadState* __tstate = wxPyBeginAllowThreads();
27783 (arg1)->SetText((wxString const &)*arg2);
27784
27785 wxPyEndAllowThreads(__tstate);
27786 if (PyErr_Occurred()) SWIG_fail;
27787 }
27788 Py_INCREF(Py_None); resultobj = Py_None;
27789 {
27790 if (temp2)
27791 delete arg2;
27792 }
27793 return resultobj;
27794 fail:
27795 {
27796 if (temp2)
27797 delete arg2;
27798 }
27799 return NULL;
27800 }
27801
27802
27803 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27804 PyObject *obj;
27805 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27806 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27807 Py_INCREF(obj);
27808 return Py_BuildValue((char *)"");
27809 }
27810 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27811 PyObject *resultobj;
27812 wxString const &arg1_defvalue = wxPyEmptyString ;
27813 wxString *arg1 = (wxString *) &arg1_defvalue ;
27814 wxPyTextDataObject *result;
27815 bool temp1 = false ;
27816 PyObject * obj0 = 0 ;
27817 char *kwnames[] = {
27818 (char *) "text", NULL
27819 };
27820
27821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27822 if (obj0) {
27823 {
27824 arg1 = wxString_in_helper(obj0);
27825 if (arg1 == NULL) SWIG_fail;
27826 temp1 = true;
27827 }
27828 }
27829 {
27830 PyThreadState* __tstate = wxPyBeginAllowThreads();
27831 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27832
27833 wxPyEndAllowThreads(__tstate);
27834 if (PyErr_Occurred()) SWIG_fail;
27835 }
27836 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27837 {
27838 if (temp1)
27839 delete arg1;
27840 }
27841 return resultobj;
27842 fail:
27843 {
27844 if (temp1)
27845 delete arg1;
27846 }
27847 return NULL;
27848 }
27849
27850
27851 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27852 PyObject *resultobj;
27853 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27854 PyObject *arg2 = (PyObject *) 0 ;
27855 PyObject *arg3 = (PyObject *) 0 ;
27856 PyObject * obj0 = 0 ;
27857 PyObject * obj1 = 0 ;
27858 PyObject * obj2 = 0 ;
27859 char *kwnames[] = {
27860 (char *) "self",(char *) "self",(char *) "_class", NULL
27861 };
27862
27863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27865 if (SWIG_arg_fail(1)) SWIG_fail;
27866 arg2 = obj1;
27867 arg3 = obj2;
27868 {
27869 PyThreadState* __tstate = wxPyBeginAllowThreads();
27870 (arg1)->_setCallbackInfo(arg2,arg3);
27871
27872 wxPyEndAllowThreads(__tstate);
27873 if (PyErr_Occurred()) SWIG_fail;
27874 }
27875 Py_INCREF(Py_None); resultobj = Py_None;
27876 return resultobj;
27877 fail:
27878 return NULL;
27879 }
27880
27881
27882 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27883 PyObject *obj;
27884 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27885 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27886 Py_INCREF(obj);
27887 return Py_BuildValue((char *)"");
27888 }
27889 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27890 PyObject *resultobj;
27891 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27892 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27893 wxBitmapDataObject *result;
27894 PyObject * obj0 = 0 ;
27895 char *kwnames[] = {
27896 (char *) "bitmap", NULL
27897 };
27898
27899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27900 if (obj0) {
27901 {
27902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27903 if (SWIG_arg_fail(1)) SWIG_fail;
27904 if (arg1 == NULL) {
27905 SWIG_null_ref("wxBitmap");
27906 }
27907 if (SWIG_arg_fail(1)) SWIG_fail;
27908 }
27909 }
27910 {
27911 PyThreadState* __tstate = wxPyBeginAllowThreads();
27912 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27913
27914 wxPyEndAllowThreads(__tstate);
27915 if (PyErr_Occurred()) SWIG_fail;
27916 }
27917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27918 return resultobj;
27919 fail:
27920 return NULL;
27921 }
27922
27923
27924 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27925 PyObject *resultobj;
27926 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27927 wxBitmap result;
27928 PyObject * obj0 = 0 ;
27929 char *kwnames[] = {
27930 (char *) "self", NULL
27931 };
27932
27933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27935 if (SWIG_arg_fail(1)) SWIG_fail;
27936 {
27937 PyThreadState* __tstate = wxPyBeginAllowThreads();
27938 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27939
27940 wxPyEndAllowThreads(__tstate);
27941 if (PyErr_Occurred()) SWIG_fail;
27942 }
27943 {
27944 wxBitmap * resultptr;
27945 resultptr = new wxBitmap((wxBitmap &)(result));
27946 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27947 }
27948 return resultobj;
27949 fail:
27950 return NULL;
27951 }
27952
27953
27954 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27955 PyObject *resultobj;
27956 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27957 wxBitmap *arg2 = 0 ;
27958 PyObject * obj0 = 0 ;
27959 PyObject * obj1 = 0 ;
27960 char *kwnames[] = {
27961 (char *) "self",(char *) "bitmap", NULL
27962 };
27963
27964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27966 if (SWIG_arg_fail(1)) SWIG_fail;
27967 {
27968 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27969 if (SWIG_arg_fail(2)) SWIG_fail;
27970 if (arg2 == NULL) {
27971 SWIG_null_ref("wxBitmap");
27972 }
27973 if (SWIG_arg_fail(2)) SWIG_fail;
27974 }
27975 {
27976 PyThreadState* __tstate = wxPyBeginAllowThreads();
27977 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27978
27979 wxPyEndAllowThreads(__tstate);
27980 if (PyErr_Occurred()) SWIG_fail;
27981 }
27982 Py_INCREF(Py_None); resultobj = Py_None;
27983 return resultobj;
27984 fail:
27985 return NULL;
27986 }
27987
27988
27989 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27990 PyObject *obj;
27991 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27992 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27993 Py_INCREF(obj);
27994 return Py_BuildValue((char *)"");
27995 }
27996 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27997 PyObject *resultobj;
27998 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27999 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28000 wxPyBitmapDataObject *result;
28001 PyObject * obj0 = 0 ;
28002 char *kwnames[] = {
28003 (char *) "bitmap", NULL
28004 };
28005
28006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
28007 if (obj0) {
28008 {
28009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28010 if (SWIG_arg_fail(1)) SWIG_fail;
28011 if (arg1 == NULL) {
28012 SWIG_null_ref("wxBitmap");
28013 }
28014 if (SWIG_arg_fail(1)) SWIG_fail;
28015 }
28016 }
28017 {
28018 PyThreadState* __tstate = wxPyBeginAllowThreads();
28019 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
28020
28021 wxPyEndAllowThreads(__tstate);
28022 if (PyErr_Occurred()) SWIG_fail;
28023 }
28024 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
28025 return resultobj;
28026 fail:
28027 return NULL;
28028 }
28029
28030
28031 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28032 PyObject *resultobj;
28033 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28034 PyObject *arg2 = (PyObject *) 0 ;
28035 PyObject *arg3 = (PyObject *) 0 ;
28036 PyObject * obj0 = 0 ;
28037 PyObject * obj1 = 0 ;
28038 PyObject * obj2 = 0 ;
28039 char *kwnames[] = {
28040 (char *) "self",(char *) "self",(char *) "_class", NULL
28041 };
28042
28043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28045 if (SWIG_arg_fail(1)) SWIG_fail;
28046 arg2 = obj1;
28047 arg3 = obj2;
28048 {
28049 PyThreadState* __tstate = wxPyBeginAllowThreads();
28050 (arg1)->_setCallbackInfo(arg2,arg3);
28051
28052 wxPyEndAllowThreads(__tstate);
28053 if (PyErr_Occurred()) SWIG_fail;
28054 }
28055 Py_INCREF(Py_None); resultobj = Py_None;
28056 return resultobj;
28057 fail:
28058 return NULL;
28059 }
28060
28061
28062 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28063 PyObject *obj;
28064 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28065 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28066 Py_INCREF(obj);
28067 return Py_BuildValue((char *)"");
28068 }
28069 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28070 PyObject *resultobj;
28071 wxFileDataObject *result;
28072 char *kwnames[] = {
28073 NULL
28074 };
28075
28076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28077 {
28078 PyThreadState* __tstate = wxPyBeginAllowThreads();
28079 result = (wxFileDataObject *)new wxFileDataObject();
28080
28081 wxPyEndAllowThreads(__tstate);
28082 if (PyErr_Occurred()) SWIG_fail;
28083 }
28084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28085 return resultobj;
28086 fail:
28087 return NULL;
28088 }
28089
28090
28091 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28092 PyObject *resultobj;
28093 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28094 wxArrayString *result;
28095 PyObject * obj0 = 0 ;
28096 char *kwnames[] = {
28097 (char *) "self", NULL
28098 };
28099
28100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28102 if (SWIG_arg_fail(1)) SWIG_fail;
28103 {
28104 PyThreadState* __tstate = wxPyBeginAllowThreads();
28105 {
28106 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28107 result = (wxArrayString *) &_result_ref;
28108 }
28109
28110 wxPyEndAllowThreads(__tstate);
28111 if (PyErr_Occurred()) SWIG_fail;
28112 }
28113 {
28114 resultobj = wxArrayString2PyList_helper(*result);
28115 }
28116 return resultobj;
28117 fail:
28118 return NULL;
28119 }
28120
28121
28122 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28123 PyObject *resultobj;
28124 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28125 wxString *arg2 = 0 ;
28126 bool temp2 = false ;
28127 PyObject * obj0 = 0 ;
28128 PyObject * obj1 = 0 ;
28129 char *kwnames[] = {
28130 (char *) "self",(char *) "filename", NULL
28131 };
28132
28133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28135 if (SWIG_arg_fail(1)) SWIG_fail;
28136 {
28137 arg2 = wxString_in_helper(obj1);
28138 if (arg2 == NULL) SWIG_fail;
28139 temp2 = true;
28140 }
28141 {
28142 PyThreadState* __tstate = wxPyBeginAllowThreads();
28143 (arg1)->AddFile((wxString const &)*arg2);
28144
28145 wxPyEndAllowThreads(__tstate);
28146 if (PyErr_Occurred()) SWIG_fail;
28147 }
28148 Py_INCREF(Py_None); resultobj = Py_None;
28149 {
28150 if (temp2)
28151 delete arg2;
28152 }
28153 return resultobj;
28154 fail:
28155 {
28156 if (temp2)
28157 delete arg2;
28158 }
28159 return NULL;
28160 }
28161
28162
28163 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28164 PyObject *obj;
28165 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28166 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28167 Py_INCREF(obj);
28168 return Py_BuildValue((char *)"");
28169 }
28170 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28171 PyObject *resultobj;
28172 wxDataFormat *arg1 = 0 ;
28173 wxCustomDataObject *result;
28174 PyObject * obj0 = 0 ;
28175
28176 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28177 {
28178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28179 if (SWIG_arg_fail(1)) SWIG_fail;
28180 if (arg1 == NULL) {
28181 SWIG_null_ref("wxDataFormat");
28182 }
28183 if (SWIG_arg_fail(1)) SWIG_fail;
28184 }
28185 {
28186 PyThreadState* __tstate = wxPyBeginAllowThreads();
28187 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28188
28189 wxPyEndAllowThreads(__tstate);
28190 if (PyErr_Occurred()) SWIG_fail;
28191 }
28192 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28193 return resultobj;
28194 fail:
28195 return NULL;
28196 }
28197
28198
28199 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28200 PyObject *resultobj;
28201 wxString *arg1 = 0 ;
28202 wxCustomDataObject *result;
28203 bool temp1 = false ;
28204 PyObject * obj0 = 0 ;
28205
28206 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28207 {
28208 arg1 = wxString_in_helper(obj0);
28209 if (arg1 == NULL) SWIG_fail;
28210 temp1 = true;
28211 }
28212 {
28213 PyThreadState* __tstate = wxPyBeginAllowThreads();
28214 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28215
28216 wxPyEndAllowThreads(__tstate);
28217 if (PyErr_Occurred()) SWIG_fail;
28218 }
28219 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28220 {
28221 if (temp1)
28222 delete arg1;
28223 }
28224 return resultobj;
28225 fail:
28226 {
28227 if (temp1)
28228 delete arg1;
28229 }
28230 return NULL;
28231 }
28232
28233
28234 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28235 PyObject *resultobj;
28236 wxCustomDataObject *result;
28237
28238 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28239 {
28240 PyThreadState* __tstate = wxPyBeginAllowThreads();
28241 result = (wxCustomDataObject *)new wxCustomDataObject();
28242
28243 wxPyEndAllowThreads(__tstate);
28244 if (PyErr_Occurred()) SWIG_fail;
28245 }
28246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28247 return resultobj;
28248 fail:
28249 return NULL;
28250 }
28251
28252
28253 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28254 int argc;
28255 PyObject *argv[2];
28256 int ii;
28257
28258 argc = PyObject_Length(args);
28259 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28260 argv[ii] = PyTuple_GetItem(args,ii);
28261 }
28262 if (argc == 0) {
28263 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28264 }
28265 if (argc == 1) {
28266 int _v;
28267 {
28268 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28269 }
28270 if (_v) {
28271 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28272 }
28273 }
28274 if (argc == 1) {
28275 int _v;
28276 {
28277 void *ptr = 0;
28278 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28279 _v = 0;
28280 PyErr_Clear();
28281 } else {
28282 _v = (ptr != 0);
28283 }
28284 }
28285 if (_v) {
28286 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28287 }
28288 }
28289
28290 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28291 return NULL;
28292 }
28293
28294
28295 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28296 PyObject *resultobj;
28297 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28298 PyObject *arg2 = (PyObject *) 0 ;
28299 bool result;
28300 PyObject * obj0 = 0 ;
28301 PyObject * obj1 = 0 ;
28302 char *kwnames[] = {
28303 (char *) "self",(char *) "data", NULL
28304 };
28305
28306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28308 if (SWIG_arg_fail(1)) SWIG_fail;
28309 arg2 = obj1;
28310 {
28311 PyThreadState* __tstate = wxPyBeginAllowThreads();
28312 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28313
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 {
28318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28319 }
28320 return resultobj;
28321 fail:
28322 return NULL;
28323 }
28324
28325
28326 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28327 PyObject *resultobj;
28328 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28329 size_t result;
28330 PyObject * obj0 = 0 ;
28331 char *kwnames[] = {
28332 (char *) "self", NULL
28333 };
28334
28335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28337 if (SWIG_arg_fail(1)) SWIG_fail;
28338 {
28339 PyThreadState* __tstate = wxPyBeginAllowThreads();
28340 result = (size_t)(arg1)->GetSize();
28341
28342 wxPyEndAllowThreads(__tstate);
28343 if (PyErr_Occurred()) SWIG_fail;
28344 }
28345 {
28346 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28347 }
28348 return resultobj;
28349 fail:
28350 return NULL;
28351 }
28352
28353
28354 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28355 PyObject *resultobj;
28356 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28357 PyObject *result;
28358 PyObject * obj0 = 0 ;
28359 char *kwnames[] = {
28360 (char *) "self", NULL
28361 };
28362
28363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28365 if (SWIG_arg_fail(1)) SWIG_fail;
28366 {
28367 PyThreadState* __tstate = wxPyBeginAllowThreads();
28368 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28369
28370 wxPyEndAllowThreads(__tstate);
28371 if (PyErr_Occurred()) SWIG_fail;
28372 }
28373 resultobj = result;
28374 return resultobj;
28375 fail:
28376 return NULL;
28377 }
28378
28379
28380 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28381 PyObject *obj;
28382 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28383 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28384 Py_INCREF(obj);
28385 return Py_BuildValue((char *)"");
28386 }
28387 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28388 PyObject *resultobj;
28389 wxURLDataObject *result;
28390 char *kwnames[] = {
28391 NULL
28392 };
28393
28394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28395 {
28396 PyThreadState* __tstate = wxPyBeginAllowThreads();
28397 result = (wxURLDataObject *)new wxURLDataObject();
28398
28399 wxPyEndAllowThreads(__tstate);
28400 if (PyErr_Occurred()) SWIG_fail;
28401 }
28402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28403 return resultobj;
28404 fail:
28405 return NULL;
28406 }
28407
28408
28409 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28410 PyObject *resultobj;
28411 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28412 wxString result;
28413 PyObject * obj0 = 0 ;
28414 char *kwnames[] = {
28415 (char *) "self", NULL
28416 };
28417
28418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28420 if (SWIG_arg_fail(1)) SWIG_fail;
28421 {
28422 PyThreadState* __tstate = wxPyBeginAllowThreads();
28423 result = (arg1)->GetURL();
28424
28425 wxPyEndAllowThreads(__tstate);
28426 if (PyErr_Occurred()) SWIG_fail;
28427 }
28428 {
28429 #if wxUSE_UNICODE
28430 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28431 #else
28432 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28433 #endif
28434 }
28435 return resultobj;
28436 fail:
28437 return NULL;
28438 }
28439
28440
28441 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28442 PyObject *resultobj;
28443 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28444 wxString *arg2 = 0 ;
28445 bool temp2 = false ;
28446 PyObject * obj0 = 0 ;
28447 PyObject * obj1 = 0 ;
28448 char *kwnames[] = {
28449 (char *) "self",(char *) "url", NULL
28450 };
28451
28452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28454 if (SWIG_arg_fail(1)) SWIG_fail;
28455 {
28456 arg2 = wxString_in_helper(obj1);
28457 if (arg2 == NULL) SWIG_fail;
28458 temp2 = true;
28459 }
28460 {
28461 PyThreadState* __tstate = wxPyBeginAllowThreads();
28462 (arg1)->SetURL((wxString const &)*arg2);
28463
28464 wxPyEndAllowThreads(__tstate);
28465 if (PyErr_Occurred()) SWIG_fail;
28466 }
28467 Py_INCREF(Py_None); resultobj = Py_None;
28468 {
28469 if (temp2)
28470 delete arg2;
28471 }
28472 return resultobj;
28473 fail:
28474 {
28475 if (temp2)
28476 delete arg2;
28477 }
28478 return NULL;
28479 }
28480
28481
28482 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28483 PyObject *obj;
28484 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28485 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28486 Py_INCREF(obj);
28487 return Py_BuildValue((char *)"");
28488 }
28489 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28490 PyObject *resultobj;
28491 wxMetafileDataObject *result;
28492 char *kwnames[] = {
28493 NULL
28494 };
28495
28496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28497 {
28498 PyThreadState* __tstate = wxPyBeginAllowThreads();
28499 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28500
28501 wxPyEndAllowThreads(__tstate);
28502 if (PyErr_Occurred()) SWIG_fail;
28503 }
28504 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28505 return resultobj;
28506 fail:
28507 return NULL;
28508 }
28509
28510
28511 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28512 PyObject *resultobj;
28513 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28514 wxMetafile *arg2 = 0 ;
28515 PyObject * obj0 = 0 ;
28516 PyObject * obj1 = 0 ;
28517 char *kwnames[] = {
28518 (char *) "self",(char *) "metafile", NULL
28519 };
28520
28521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28523 if (SWIG_arg_fail(1)) SWIG_fail;
28524 {
28525 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28526 if (SWIG_arg_fail(2)) SWIG_fail;
28527 if (arg2 == NULL) {
28528 SWIG_null_ref("wxMetafile");
28529 }
28530 if (SWIG_arg_fail(2)) SWIG_fail;
28531 }
28532 {
28533 PyThreadState* __tstate = wxPyBeginAllowThreads();
28534 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28535
28536 wxPyEndAllowThreads(__tstate);
28537 if (PyErr_Occurred()) SWIG_fail;
28538 }
28539 Py_INCREF(Py_None); resultobj = Py_None;
28540 return resultobj;
28541 fail:
28542 return NULL;
28543 }
28544
28545
28546 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28547 PyObject *resultobj;
28548 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28549 wxMetafile result;
28550 PyObject * obj0 = 0 ;
28551 char *kwnames[] = {
28552 (char *) "self", NULL
28553 };
28554
28555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28557 if (SWIG_arg_fail(1)) SWIG_fail;
28558 {
28559 PyThreadState* __tstate = wxPyBeginAllowThreads();
28560 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28561
28562 wxPyEndAllowThreads(__tstate);
28563 if (PyErr_Occurred()) SWIG_fail;
28564 }
28565 {
28566 wxMetafile * resultptr;
28567 resultptr = new wxMetafile((wxMetafile &)(result));
28568 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28569 }
28570 return resultobj;
28571 fail:
28572 return NULL;
28573 }
28574
28575
28576 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28577 PyObject *obj;
28578 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28579 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28580 Py_INCREF(obj);
28581 return Py_BuildValue((char *)"");
28582 }
28583 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28584 PyObject *resultobj;
28585 wxDragResult arg1 ;
28586 bool result;
28587 PyObject * obj0 = 0 ;
28588 char *kwnames[] = {
28589 (char *) "res", NULL
28590 };
28591
28592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28593 {
28594 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28595 if (SWIG_arg_fail(1)) SWIG_fail;
28596 }
28597 {
28598 PyThreadState* __tstate = wxPyBeginAllowThreads();
28599 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28600
28601 wxPyEndAllowThreads(__tstate);
28602 if (PyErr_Occurred()) SWIG_fail;
28603 }
28604 {
28605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28606 }
28607 return resultobj;
28608 fail:
28609 return NULL;
28610 }
28611
28612
28613 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28614 PyObject *resultobj;
28615 wxWindow *arg1 = (wxWindow *) 0 ;
28616 wxCursor const &arg2_defvalue = wxNullCursor ;
28617 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28618 wxCursor const &arg3_defvalue = wxNullCursor ;
28619 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28620 wxCursor const &arg4_defvalue = wxNullCursor ;
28621 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28622 wxPyDropSource *result;
28623 PyObject * obj0 = 0 ;
28624 PyObject * obj1 = 0 ;
28625 PyObject * obj2 = 0 ;
28626 PyObject * obj3 = 0 ;
28627 char *kwnames[] = {
28628 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28629 };
28630
28631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28633 if (SWIG_arg_fail(1)) SWIG_fail;
28634 if (obj1) {
28635 {
28636 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28637 if (SWIG_arg_fail(2)) SWIG_fail;
28638 if (arg2 == NULL) {
28639 SWIG_null_ref("wxCursor");
28640 }
28641 if (SWIG_arg_fail(2)) SWIG_fail;
28642 }
28643 }
28644 if (obj2) {
28645 {
28646 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28647 if (SWIG_arg_fail(3)) SWIG_fail;
28648 if (arg3 == NULL) {
28649 SWIG_null_ref("wxCursor");
28650 }
28651 if (SWIG_arg_fail(3)) SWIG_fail;
28652 }
28653 }
28654 if (obj3) {
28655 {
28656 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28657 if (SWIG_arg_fail(4)) SWIG_fail;
28658 if (arg4 == NULL) {
28659 SWIG_null_ref("wxCursor");
28660 }
28661 if (SWIG_arg_fail(4)) SWIG_fail;
28662 }
28663 }
28664 {
28665 PyThreadState* __tstate = wxPyBeginAllowThreads();
28666 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28667
28668 wxPyEndAllowThreads(__tstate);
28669 if (PyErr_Occurred()) SWIG_fail;
28670 }
28671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28672 return resultobj;
28673 fail:
28674 return NULL;
28675 }
28676
28677
28678 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28679 PyObject *resultobj;
28680 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28681 PyObject *arg2 = (PyObject *) 0 ;
28682 PyObject *arg3 = (PyObject *) 0 ;
28683 int arg4 ;
28684 PyObject * obj0 = 0 ;
28685 PyObject * obj1 = 0 ;
28686 PyObject * obj2 = 0 ;
28687 PyObject * obj3 = 0 ;
28688 char *kwnames[] = {
28689 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28690 };
28691
28692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28694 if (SWIG_arg_fail(1)) SWIG_fail;
28695 arg2 = obj1;
28696 arg3 = obj2;
28697 {
28698 arg4 = (int)(SWIG_As_int(obj3));
28699 if (SWIG_arg_fail(4)) SWIG_fail;
28700 }
28701 {
28702 PyThreadState* __tstate = wxPyBeginAllowThreads();
28703 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28704
28705 wxPyEndAllowThreads(__tstate);
28706 if (PyErr_Occurred()) SWIG_fail;
28707 }
28708 Py_INCREF(Py_None); resultobj = Py_None;
28709 return resultobj;
28710 fail:
28711 return NULL;
28712 }
28713
28714
28715 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28716 PyObject *resultobj;
28717 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28718 PyObject * obj0 = 0 ;
28719 char *kwnames[] = {
28720 (char *) "self", NULL
28721 };
28722
28723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28725 if (SWIG_arg_fail(1)) SWIG_fail;
28726 {
28727 PyThreadState* __tstate = wxPyBeginAllowThreads();
28728 delete arg1;
28729
28730 wxPyEndAllowThreads(__tstate);
28731 if (PyErr_Occurred()) SWIG_fail;
28732 }
28733 Py_INCREF(Py_None); resultobj = Py_None;
28734 return resultobj;
28735 fail:
28736 return NULL;
28737 }
28738
28739
28740 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28741 PyObject *resultobj;
28742 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28743 wxDataObject *arg2 = 0 ;
28744 PyObject * obj0 = 0 ;
28745 PyObject * obj1 = 0 ;
28746 char *kwnames[] = {
28747 (char *) "self",(char *) "data", NULL
28748 };
28749
28750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28752 if (SWIG_arg_fail(1)) SWIG_fail;
28753 {
28754 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28755 if (SWIG_arg_fail(2)) SWIG_fail;
28756 if (arg2 == NULL) {
28757 SWIG_null_ref("wxDataObject");
28758 }
28759 if (SWIG_arg_fail(2)) SWIG_fail;
28760 }
28761 {
28762 PyThreadState* __tstate = wxPyBeginAllowThreads();
28763 (arg1)->SetData(*arg2);
28764
28765 wxPyEndAllowThreads(__tstate);
28766 if (PyErr_Occurred()) SWIG_fail;
28767 }
28768 Py_INCREF(Py_None); resultobj = Py_None;
28769 return resultobj;
28770 fail:
28771 return NULL;
28772 }
28773
28774
28775 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28776 PyObject *resultobj;
28777 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28778 wxDataObject *result;
28779 PyObject * obj0 = 0 ;
28780 char *kwnames[] = {
28781 (char *) "self", NULL
28782 };
28783
28784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28786 if (SWIG_arg_fail(1)) SWIG_fail;
28787 {
28788 PyThreadState* __tstate = wxPyBeginAllowThreads();
28789 result = (wxDataObject *)(arg1)->GetDataObject();
28790
28791 wxPyEndAllowThreads(__tstate);
28792 if (PyErr_Occurred()) SWIG_fail;
28793 }
28794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28795 return resultobj;
28796 fail:
28797 return NULL;
28798 }
28799
28800
28801 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28802 PyObject *resultobj;
28803 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28804 wxDragResult arg2 ;
28805 wxCursor *arg3 = 0 ;
28806 PyObject * obj0 = 0 ;
28807 PyObject * obj1 = 0 ;
28808 PyObject * obj2 = 0 ;
28809 char *kwnames[] = {
28810 (char *) "self",(char *) "res",(char *) "cursor", NULL
28811 };
28812
28813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28815 if (SWIG_arg_fail(1)) SWIG_fail;
28816 {
28817 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28818 if (SWIG_arg_fail(2)) SWIG_fail;
28819 }
28820 {
28821 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28822 if (SWIG_arg_fail(3)) SWIG_fail;
28823 if (arg3 == NULL) {
28824 SWIG_null_ref("wxCursor");
28825 }
28826 if (SWIG_arg_fail(3)) SWIG_fail;
28827 }
28828 {
28829 PyThreadState* __tstate = wxPyBeginAllowThreads();
28830 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28831
28832 wxPyEndAllowThreads(__tstate);
28833 if (PyErr_Occurred()) SWIG_fail;
28834 }
28835 Py_INCREF(Py_None); resultobj = Py_None;
28836 return resultobj;
28837 fail:
28838 return NULL;
28839 }
28840
28841
28842 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28843 PyObject *resultobj;
28844 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28845 int arg2 = (int) wxDrag_CopyOnly ;
28846 wxDragResult result;
28847 PyObject * obj0 = 0 ;
28848 PyObject * obj1 = 0 ;
28849 char *kwnames[] = {
28850 (char *) "self",(char *) "flags", NULL
28851 };
28852
28853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28855 if (SWIG_arg_fail(1)) SWIG_fail;
28856 if (obj1) {
28857 {
28858 arg2 = (int)(SWIG_As_int(obj1));
28859 if (SWIG_arg_fail(2)) SWIG_fail;
28860 }
28861 }
28862 {
28863 PyThreadState* __tstate = wxPyBeginAllowThreads();
28864 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28865
28866 wxPyEndAllowThreads(__tstate);
28867 if (PyErr_Occurred()) SWIG_fail;
28868 }
28869 resultobj = SWIG_From_int((result));
28870 return resultobj;
28871 fail:
28872 return NULL;
28873 }
28874
28875
28876 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28877 PyObject *resultobj;
28878 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28879 wxDragResult arg2 ;
28880 bool result;
28881 PyObject * obj0 = 0 ;
28882 PyObject * obj1 = 0 ;
28883 char *kwnames[] = {
28884 (char *) "self",(char *) "effect", NULL
28885 };
28886
28887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28889 if (SWIG_arg_fail(1)) SWIG_fail;
28890 {
28891 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28892 if (SWIG_arg_fail(2)) SWIG_fail;
28893 }
28894 {
28895 PyThreadState* __tstate = wxPyBeginAllowThreads();
28896 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28897
28898 wxPyEndAllowThreads(__tstate);
28899 if (PyErr_Occurred()) SWIG_fail;
28900 }
28901 {
28902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28903 }
28904 return resultobj;
28905 fail:
28906 return NULL;
28907 }
28908
28909
28910 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28911 PyObject *obj;
28912 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28913 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28914 Py_INCREF(obj);
28915 return Py_BuildValue((char *)"");
28916 }
28917 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28918 PyObject *resultobj;
28919 wxDataObject *arg1 = (wxDataObject *) NULL ;
28920 wxPyDropTarget *result;
28921 PyObject * obj0 = 0 ;
28922 char *kwnames[] = {
28923 (char *) "dataObject", NULL
28924 };
28925
28926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28927 if (obj0) {
28928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28929 if (SWIG_arg_fail(1)) SWIG_fail;
28930 }
28931 {
28932 PyThreadState* __tstate = wxPyBeginAllowThreads();
28933 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28934
28935 wxPyEndAllowThreads(__tstate);
28936 if (PyErr_Occurred()) SWIG_fail;
28937 }
28938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28939 return resultobj;
28940 fail:
28941 return NULL;
28942 }
28943
28944
28945 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28946 PyObject *resultobj;
28947 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28948 PyObject *arg2 = (PyObject *) 0 ;
28949 PyObject *arg3 = (PyObject *) 0 ;
28950 PyObject * obj0 = 0 ;
28951 PyObject * obj1 = 0 ;
28952 PyObject * obj2 = 0 ;
28953 char *kwnames[] = {
28954 (char *) "self",(char *) "self",(char *) "_class", NULL
28955 };
28956
28957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28959 if (SWIG_arg_fail(1)) SWIG_fail;
28960 arg2 = obj1;
28961 arg3 = obj2;
28962 {
28963 PyThreadState* __tstate = wxPyBeginAllowThreads();
28964 (arg1)->_setCallbackInfo(arg2,arg3);
28965
28966 wxPyEndAllowThreads(__tstate);
28967 if (PyErr_Occurred()) SWIG_fail;
28968 }
28969 Py_INCREF(Py_None); resultobj = Py_None;
28970 return resultobj;
28971 fail:
28972 return NULL;
28973 }
28974
28975
28976 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28977 PyObject *resultobj;
28978 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28979 PyObject * obj0 = 0 ;
28980 char *kwnames[] = {
28981 (char *) "self", NULL
28982 };
28983
28984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28986 if (SWIG_arg_fail(1)) SWIG_fail;
28987 {
28988 PyThreadState* __tstate = wxPyBeginAllowThreads();
28989 delete arg1;
28990
28991 wxPyEndAllowThreads(__tstate);
28992 if (PyErr_Occurred()) SWIG_fail;
28993 }
28994 Py_INCREF(Py_None); resultobj = Py_None;
28995 return resultobj;
28996 fail:
28997 return NULL;
28998 }
28999
29000
29001 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29002 PyObject *resultobj;
29003 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29004 wxDataObject *result;
29005 PyObject * obj0 = 0 ;
29006 char *kwnames[] = {
29007 (char *) "self", NULL
29008 };
29009
29010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
29011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29012 if (SWIG_arg_fail(1)) SWIG_fail;
29013 {
29014 PyThreadState* __tstate = wxPyBeginAllowThreads();
29015 result = (wxDataObject *)(arg1)->GetDataObject();
29016
29017 wxPyEndAllowThreads(__tstate);
29018 if (PyErr_Occurred()) SWIG_fail;
29019 }
29020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
29021 return resultobj;
29022 fail:
29023 return NULL;
29024 }
29025
29026
29027 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29028 PyObject *resultobj;
29029 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29030 wxDataObject *arg2 = (wxDataObject *) 0 ;
29031 PyObject * obj0 = 0 ;
29032 PyObject * obj1 = 0 ;
29033 char *kwnames[] = {
29034 (char *) "self",(char *) "dataObject", NULL
29035 };
29036
29037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
29038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29039 if (SWIG_arg_fail(1)) SWIG_fail;
29040 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29041 if (SWIG_arg_fail(2)) SWIG_fail;
29042 {
29043 PyThreadState* __tstate = wxPyBeginAllowThreads();
29044 (arg1)->SetDataObject(arg2);
29045
29046 wxPyEndAllowThreads(__tstate);
29047 if (PyErr_Occurred()) SWIG_fail;
29048 }
29049 Py_INCREF(Py_None); resultobj = Py_None;
29050 return resultobj;
29051 fail:
29052 return NULL;
29053 }
29054
29055
29056 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29057 PyObject *resultobj;
29058 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29059 int arg2 ;
29060 int arg3 ;
29061 wxDragResult arg4 ;
29062 wxDragResult result;
29063 PyObject * obj0 = 0 ;
29064 PyObject * obj1 = 0 ;
29065 PyObject * obj2 = 0 ;
29066 PyObject * obj3 = 0 ;
29067 char *kwnames[] = {
29068 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29069 };
29070
29071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29073 if (SWIG_arg_fail(1)) SWIG_fail;
29074 {
29075 arg2 = (int)(SWIG_As_int(obj1));
29076 if (SWIG_arg_fail(2)) SWIG_fail;
29077 }
29078 {
29079 arg3 = (int)(SWIG_As_int(obj2));
29080 if (SWIG_arg_fail(3)) SWIG_fail;
29081 }
29082 {
29083 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29084 if (SWIG_arg_fail(4)) SWIG_fail;
29085 }
29086 {
29087 PyThreadState* __tstate = wxPyBeginAllowThreads();
29088 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29089
29090 wxPyEndAllowThreads(__tstate);
29091 if (PyErr_Occurred()) SWIG_fail;
29092 }
29093 resultobj = SWIG_From_int((result));
29094 return resultobj;
29095 fail:
29096 return NULL;
29097 }
29098
29099
29100 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29101 PyObject *resultobj;
29102 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29103 int arg2 ;
29104 int arg3 ;
29105 wxDragResult arg4 ;
29106 wxDragResult result;
29107 PyObject * obj0 = 0 ;
29108 PyObject * obj1 = 0 ;
29109 PyObject * obj2 = 0 ;
29110 PyObject * obj3 = 0 ;
29111 char *kwnames[] = {
29112 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29113 };
29114
29115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29117 if (SWIG_arg_fail(1)) SWIG_fail;
29118 {
29119 arg2 = (int)(SWIG_As_int(obj1));
29120 if (SWIG_arg_fail(2)) SWIG_fail;
29121 }
29122 {
29123 arg3 = (int)(SWIG_As_int(obj2));
29124 if (SWIG_arg_fail(3)) SWIG_fail;
29125 }
29126 {
29127 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29128 if (SWIG_arg_fail(4)) SWIG_fail;
29129 }
29130 {
29131 PyThreadState* __tstate = wxPyBeginAllowThreads();
29132 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29133
29134 wxPyEndAllowThreads(__tstate);
29135 if (PyErr_Occurred()) SWIG_fail;
29136 }
29137 resultobj = SWIG_From_int((result));
29138 return resultobj;
29139 fail:
29140 return NULL;
29141 }
29142
29143
29144 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29145 PyObject *resultobj;
29146 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29147 PyObject * obj0 = 0 ;
29148 char *kwnames[] = {
29149 (char *) "self", NULL
29150 };
29151
29152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29154 if (SWIG_arg_fail(1)) SWIG_fail;
29155 {
29156 PyThreadState* __tstate = wxPyBeginAllowThreads();
29157 (arg1)->base_OnLeave();
29158
29159 wxPyEndAllowThreads(__tstate);
29160 if (PyErr_Occurred()) SWIG_fail;
29161 }
29162 Py_INCREF(Py_None); resultobj = Py_None;
29163 return resultobj;
29164 fail:
29165 return NULL;
29166 }
29167
29168
29169 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29170 PyObject *resultobj;
29171 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29172 int arg2 ;
29173 int arg3 ;
29174 bool result;
29175 PyObject * obj0 = 0 ;
29176 PyObject * obj1 = 0 ;
29177 PyObject * obj2 = 0 ;
29178 char *kwnames[] = {
29179 (char *) "self",(char *) "x",(char *) "y", NULL
29180 };
29181
29182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29184 if (SWIG_arg_fail(1)) SWIG_fail;
29185 {
29186 arg2 = (int)(SWIG_As_int(obj1));
29187 if (SWIG_arg_fail(2)) SWIG_fail;
29188 }
29189 {
29190 arg3 = (int)(SWIG_As_int(obj2));
29191 if (SWIG_arg_fail(3)) SWIG_fail;
29192 }
29193 {
29194 PyThreadState* __tstate = wxPyBeginAllowThreads();
29195 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29196
29197 wxPyEndAllowThreads(__tstate);
29198 if (PyErr_Occurred()) SWIG_fail;
29199 }
29200 {
29201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29202 }
29203 return resultobj;
29204 fail:
29205 return NULL;
29206 }
29207
29208
29209 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29210 PyObject *resultobj;
29211 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29212 bool result;
29213 PyObject * obj0 = 0 ;
29214 char *kwnames[] = {
29215 (char *) "self", NULL
29216 };
29217
29218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29220 if (SWIG_arg_fail(1)) SWIG_fail;
29221 {
29222 PyThreadState* __tstate = wxPyBeginAllowThreads();
29223 result = (bool)(arg1)->GetData();
29224
29225 wxPyEndAllowThreads(__tstate);
29226 if (PyErr_Occurred()) SWIG_fail;
29227 }
29228 {
29229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29230 }
29231 return resultobj;
29232 fail:
29233 return NULL;
29234 }
29235
29236
29237 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29238 PyObject *resultobj;
29239 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29240 wxDragResult arg2 ;
29241 PyObject * obj0 = 0 ;
29242 PyObject * obj1 = 0 ;
29243 char *kwnames[] = {
29244 (char *) "self",(char *) "action", NULL
29245 };
29246
29247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29249 if (SWIG_arg_fail(1)) SWIG_fail;
29250 {
29251 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29252 if (SWIG_arg_fail(2)) SWIG_fail;
29253 }
29254 {
29255 PyThreadState* __tstate = wxPyBeginAllowThreads();
29256 (arg1)->SetDefaultAction((wxDragResult )arg2);
29257
29258 wxPyEndAllowThreads(__tstate);
29259 if (PyErr_Occurred()) SWIG_fail;
29260 }
29261 Py_INCREF(Py_None); resultobj = Py_None;
29262 return resultobj;
29263 fail:
29264 return NULL;
29265 }
29266
29267
29268 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29269 PyObject *resultobj;
29270 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29271 wxDragResult result;
29272 PyObject * obj0 = 0 ;
29273 char *kwnames[] = {
29274 (char *) "self", NULL
29275 };
29276
29277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29279 if (SWIG_arg_fail(1)) SWIG_fail;
29280 {
29281 PyThreadState* __tstate = wxPyBeginAllowThreads();
29282 result = (wxDragResult)(arg1)->GetDefaultAction();
29283
29284 wxPyEndAllowThreads(__tstate);
29285 if (PyErr_Occurred()) SWIG_fail;
29286 }
29287 resultobj = SWIG_From_int((result));
29288 return resultobj;
29289 fail:
29290 return NULL;
29291 }
29292
29293
29294 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29295 PyObject *obj;
29296 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29297 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29298 Py_INCREF(obj);
29299 return Py_BuildValue((char *)"");
29300 }
29301 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29302 PyObject *resultobj;
29303 wxPyTextDropTarget *result;
29304 char *kwnames[] = {
29305 NULL
29306 };
29307
29308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29309 {
29310 PyThreadState* __tstate = wxPyBeginAllowThreads();
29311 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29312
29313 wxPyEndAllowThreads(__tstate);
29314 if (PyErr_Occurred()) SWIG_fail;
29315 }
29316 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29317 return resultobj;
29318 fail:
29319 return NULL;
29320 }
29321
29322
29323 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29324 PyObject *resultobj;
29325 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29326 PyObject *arg2 = (PyObject *) 0 ;
29327 PyObject *arg3 = (PyObject *) 0 ;
29328 PyObject * obj0 = 0 ;
29329 PyObject * obj1 = 0 ;
29330 PyObject * obj2 = 0 ;
29331 char *kwnames[] = {
29332 (char *) "self",(char *) "self",(char *) "_class", NULL
29333 };
29334
29335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29337 if (SWIG_arg_fail(1)) SWIG_fail;
29338 arg2 = obj1;
29339 arg3 = obj2;
29340 {
29341 PyThreadState* __tstate = wxPyBeginAllowThreads();
29342 (arg1)->_setCallbackInfo(arg2,arg3);
29343
29344 wxPyEndAllowThreads(__tstate);
29345 if (PyErr_Occurred()) SWIG_fail;
29346 }
29347 Py_INCREF(Py_None); resultobj = Py_None;
29348 return resultobj;
29349 fail:
29350 return NULL;
29351 }
29352
29353
29354 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29355 PyObject *resultobj;
29356 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29357 int arg2 ;
29358 int arg3 ;
29359 wxDragResult arg4 ;
29360 wxDragResult result;
29361 PyObject * obj0 = 0 ;
29362 PyObject * obj1 = 0 ;
29363 PyObject * obj2 = 0 ;
29364 PyObject * obj3 = 0 ;
29365 char *kwnames[] = {
29366 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29367 };
29368
29369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29371 if (SWIG_arg_fail(1)) SWIG_fail;
29372 {
29373 arg2 = (int)(SWIG_As_int(obj1));
29374 if (SWIG_arg_fail(2)) SWIG_fail;
29375 }
29376 {
29377 arg3 = (int)(SWIG_As_int(obj2));
29378 if (SWIG_arg_fail(3)) SWIG_fail;
29379 }
29380 {
29381 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29382 if (SWIG_arg_fail(4)) SWIG_fail;
29383 }
29384 {
29385 PyThreadState* __tstate = wxPyBeginAllowThreads();
29386 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29387
29388 wxPyEndAllowThreads(__tstate);
29389 if (PyErr_Occurred()) SWIG_fail;
29390 }
29391 resultobj = SWIG_From_int((result));
29392 return resultobj;
29393 fail:
29394 return NULL;
29395 }
29396
29397
29398 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29399 PyObject *resultobj;
29400 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29401 int arg2 ;
29402 int arg3 ;
29403 wxDragResult arg4 ;
29404 wxDragResult result;
29405 PyObject * obj0 = 0 ;
29406 PyObject * obj1 = 0 ;
29407 PyObject * obj2 = 0 ;
29408 PyObject * obj3 = 0 ;
29409 char *kwnames[] = {
29410 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29411 };
29412
29413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29415 if (SWIG_arg_fail(1)) SWIG_fail;
29416 {
29417 arg2 = (int)(SWIG_As_int(obj1));
29418 if (SWIG_arg_fail(2)) SWIG_fail;
29419 }
29420 {
29421 arg3 = (int)(SWIG_As_int(obj2));
29422 if (SWIG_arg_fail(3)) SWIG_fail;
29423 }
29424 {
29425 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29426 if (SWIG_arg_fail(4)) SWIG_fail;
29427 }
29428 {
29429 PyThreadState* __tstate = wxPyBeginAllowThreads();
29430 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29431
29432 wxPyEndAllowThreads(__tstate);
29433 if (PyErr_Occurred()) SWIG_fail;
29434 }
29435 resultobj = SWIG_From_int((result));
29436 return resultobj;
29437 fail:
29438 return NULL;
29439 }
29440
29441
29442 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29443 PyObject *resultobj;
29444 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29445 PyObject * obj0 = 0 ;
29446 char *kwnames[] = {
29447 (char *) "self", NULL
29448 };
29449
29450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29452 if (SWIG_arg_fail(1)) SWIG_fail;
29453 {
29454 PyThreadState* __tstate = wxPyBeginAllowThreads();
29455 (arg1)->base_OnLeave();
29456
29457 wxPyEndAllowThreads(__tstate);
29458 if (PyErr_Occurred()) SWIG_fail;
29459 }
29460 Py_INCREF(Py_None); resultobj = Py_None;
29461 return resultobj;
29462 fail:
29463 return NULL;
29464 }
29465
29466
29467 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29468 PyObject *resultobj;
29469 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29470 int arg2 ;
29471 int arg3 ;
29472 bool result;
29473 PyObject * obj0 = 0 ;
29474 PyObject * obj1 = 0 ;
29475 PyObject * obj2 = 0 ;
29476 char *kwnames[] = {
29477 (char *) "self",(char *) "x",(char *) "y", NULL
29478 };
29479
29480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29482 if (SWIG_arg_fail(1)) SWIG_fail;
29483 {
29484 arg2 = (int)(SWIG_As_int(obj1));
29485 if (SWIG_arg_fail(2)) SWIG_fail;
29486 }
29487 {
29488 arg3 = (int)(SWIG_As_int(obj2));
29489 if (SWIG_arg_fail(3)) SWIG_fail;
29490 }
29491 {
29492 PyThreadState* __tstate = wxPyBeginAllowThreads();
29493 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29494
29495 wxPyEndAllowThreads(__tstate);
29496 if (PyErr_Occurred()) SWIG_fail;
29497 }
29498 {
29499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29500 }
29501 return resultobj;
29502 fail:
29503 return NULL;
29504 }
29505
29506
29507 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29508 PyObject *resultobj;
29509 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29510 int arg2 ;
29511 int arg3 ;
29512 wxDragResult arg4 ;
29513 wxDragResult result;
29514 PyObject * obj0 = 0 ;
29515 PyObject * obj1 = 0 ;
29516 PyObject * obj2 = 0 ;
29517 PyObject * obj3 = 0 ;
29518 char *kwnames[] = {
29519 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29520 };
29521
29522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29524 if (SWIG_arg_fail(1)) SWIG_fail;
29525 {
29526 arg2 = (int)(SWIG_As_int(obj1));
29527 if (SWIG_arg_fail(2)) SWIG_fail;
29528 }
29529 {
29530 arg3 = (int)(SWIG_As_int(obj2));
29531 if (SWIG_arg_fail(3)) SWIG_fail;
29532 }
29533 {
29534 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29535 if (SWIG_arg_fail(4)) SWIG_fail;
29536 }
29537 {
29538 PyThreadState* __tstate = wxPyBeginAllowThreads();
29539 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29540
29541 wxPyEndAllowThreads(__tstate);
29542 if (PyErr_Occurred()) SWIG_fail;
29543 }
29544 resultobj = SWIG_From_int((result));
29545 return resultobj;
29546 fail:
29547 return NULL;
29548 }
29549
29550
29551 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29552 PyObject *obj;
29553 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29554 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29555 Py_INCREF(obj);
29556 return Py_BuildValue((char *)"");
29557 }
29558 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29559 PyObject *resultobj;
29560 wxPyFileDropTarget *result;
29561 char *kwnames[] = {
29562 NULL
29563 };
29564
29565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29566 {
29567 PyThreadState* __tstate = wxPyBeginAllowThreads();
29568 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29569
29570 wxPyEndAllowThreads(__tstate);
29571 if (PyErr_Occurred()) SWIG_fail;
29572 }
29573 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29574 return resultobj;
29575 fail:
29576 return NULL;
29577 }
29578
29579
29580 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29581 PyObject *resultobj;
29582 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29583 PyObject *arg2 = (PyObject *) 0 ;
29584 PyObject *arg3 = (PyObject *) 0 ;
29585 PyObject * obj0 = 0 ;
29586 PyObject * obj1 = 0 ;
29587 PyObject * obj2 = 0 ;
29588 char *kwnames[] = {
29589 (char *) "self",(char *) "self",(char *) "_class", NULL
29590 };
29591
29592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29594 if (SWIG_arg_fail(1)) SWIG_fail;
29595 arg2 = obj1;
29596 arg3 = obj2;
29597 {
29598 PyThreadState* __tstate = wxPyBeginAllowThreads();
29599 (arg1)->_setCallbackInfo(arg2,arg3);
29600
29601 wxPyEndAllowThreads(__tstate);
29602 if (PyErr_Occurred()) SWIG_fail;
29603 }
29604 Py_INCREF(Py_None); resultobj = Py_None;
29605 return resultobj;
29606 fail:
29607 return NULL;
29608 }
29609
29610
29611 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29612 PyObject *resultobj;
29613 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29614 int arg2 ;
29615 int arg3 ;
29616 wxDragResult arg4 ;
29617 wxDragResult result;
29618 PyObject * obj0 = 0 ;
29619 PyObject * obj1 = 0 ;
29620 PyObject * obj2 = 0 ;
29621 PyObject * obj3 = 0 ;
29622 char *kwnames[] = {
29623 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29624 };
29625
29626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29628 if (SWIG_arg_fail(1)) SWIG_fail;
29629 {
29630 arg2 = (int)(SWIG_As_int(obj1));
29631 if (SWIG_arg_fail(2)) SWIG_fail;
29632 }
29633 {
29634 arg3 = (int)(SWIG_As_int(obj2));
29635 if (SWIG_arg_fail(3)) SWIG_fail;
29636 }
29637 {
29638 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29639 if (SWIG_arg_fail(4)) SWIG_fail;
29640 }
29641 {
29642 PyThreadState* __tstate = wxPyBeginAllowThreads();
29643 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29644
29645 wxPyEndAllowThreads(__tstate);
29646 if (PyErr_Occurred()) SWIG_fail;
29647 }
29648 resultobj = SWIG_From_int((result));
29649 return resultobj;
29650 fail:
29651 return NULL;
29652 }
29653
29654
29655 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29656 PyObject *resultobj;
29657 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29658 int arg2 ;
29659 int arg3 ;
29660 wxDragResult arg4 ;
29661 wxDragResult result;
29662 PyObject * obj0 = 0 ;
29663 PyObject * obj1 = 0 ;
29664 PyObject * obj2 = 0 ;
29665 PyObject * obj3 = 0 ;
29666 char *kwnames[] = {
29667 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29668 };
29669
29670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29672 if (SWIG_arg_fail(1)) SWIG_fail;
29673 {
29674 arg2 = (int)(SWIG_As_int(obj1));
29675 if (SWIG_arg_fail(2)) SWIG_fail;
29676 }
29677 {
29678 arg3 = (int)(SWIG_As_int(obj2));
29679 if (SWIG_arg_fail(3)) SWIG_fail;
29680 }
29681 {
29682 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29683 if (SWIG_arg_fail(4)) SWIG_fail;
29684 }
29685 {
29686 PyThreadState* __tstate = wxPyBeginAllowThreads();
29687 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29688
29689 wxPyEndAllowThreads(__tstate);
29690 if (PyErr_Occurred()) SWIG_fail;
29691 }
29692 resultobj = SWIG_From_int((result));
29693 return resultobj;
29694 fail:
29695 return NULL;
29696 }
29697
29698
29699 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29700 PyObject *resultobj;
29701 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29702 PyObject * obj0 = 0 ;
29703 char *kwnames[] = {
29704 (char *) "self", NULL
29705 };
29706
29707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29709 if (SWIG_arg_fail(1)) SWIG_fail;
29710 {
29711 PyThreadState* __tstate = wxPyBeginAllowThreads();
29712 (arg1)->base_OnLeave();
29713
29714 wxPyEndAllowThreads(__tstate);
29715 if (PyErr_Occurred()) SWIG_fail;
29716 }
29717 Py_INCREF(Py_None); resultobj = Py_None;
29718 return resultobj;
29719 fail:
29720 return NULL;
29721 }
29722
29723
29724 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29725 PyObject *resultobj;
29726 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29727 int arg2 ;
29728 int arg3 ;
29729 bool result;
29730 PyObject * obj0 = 0 ;
29731 PyObject * obj1 = 0 ;
29732 PyObject * obj2 = 0 ;
29733 char *kwnames[] = {
29734 (char *) "self",(char *) "x",(char *) "y", NULL
29735 };
29736
29737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29739 if (SWIG_arg_fail(1)) SWIG_fail;
29740 {
29741 arg2 = (int)(SWIG_As_int(obj1));
29742 if (SWIG_arg_fail(2)) SWIG_fail;
29743 }
29744 {
29745 arg3 = (int)(SWIG_As_int(obj2));
29746 if (SWIG_arg_fail(3)) SWIG_fail;
29747 }
29748 {
29749 PyThreadState* __tstate = wxPyBeginAllowThreads();
29750 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29751
29752 wxPyEndAllowThreads(__tstate);
29753 if (PyErr_Occurred()) SWIG_fail;
29754 }
29755 {
29756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29757 }
29758 return resultobj;
29759 fail:
29760 return NULL;
29761 }
29762
29763
29764 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29765 PyObject *resultobj;
29766 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29767 int arg2 ;
29768 int arg3 ;
29769 wxDragResult arg4 ;
29770 wxDragResult result;
29771 PyObject * obj0 = 0 ;
29772 PyObject * obj1 = 0 ;
29773 PyObject * obj2 = 0 ;
29774 PyObject * obj3 = 0 ;
29775 char *kwnames[] = {
29776 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29777 };
29778
29779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29781 if (SWIG_arg_fail(1)) SWIG_fail;
29782 {
29783 arg2 = (int)(SWIG_As_int(obj1));
29784 if (SWIG_arg_fail(2)) SWIG_fail;
29785 }
29786 {
29787 arg3 = (int)(SWIG_As_int(obj2));
29788 if (SWIG_arg_fail(3)) SWIG_fail;
29789 }
29790 {
29791 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29792 if (SWIG_arg_fail(4)) SWIG_fail;
29793 }
29794 {
29795 PyThreadState* __tstate = wxPyBeginAllowThreads();
29796 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29797
29798 wxPyEndAllowThreads(__tstate);
29799 if (PyErr_Occurred()) SWIG_fail;
29800 }
29801 resultobj = SWIG_From_int((result));
29802 return resultobj;
29803 fail:
29804 return NULL;
29805 }
29806
29807
29808 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29809 PyObject *obj;
29810 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29811 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29812 Py_INCREF(obj);
29813 return Py_BuildValue((char *)"");
29814 }
29815 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29816 PyObject *resultobj;
29817 wxClipboard *result;
29818 char *kwnames[] = {
29819 NULL
29820 };
29821
29822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29823 {
29824 PyThreadState* __tstate = wxPyBeginAllowThreads();
29825 result = (wxClipboard *)new wxClipboard();
29826
29827 wxPyEndAllowThreads(__tstate);
29828 if (PyErr_Occurred()) SWIG_fail;
29829 }
29830 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29831 return resultobj;
29832 fail:
29833 return NULL;
29834 }
29835
29836
29837 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29838 PyObject *resultobj;
29839 wxClipboard *arg1 = (wxClipboard *) 0 ;
29840 PyObject * obj0 = 0 ;
29841 char *kwnames[] = {
29842 (char *) "self", NULL
29843 };
29844
29845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29847 if (SWIG_arg_fail(1)) SWIG_fail;
29848 {
29849 PyThreadState* __tstate = wxPyBeginAllowThreads();
29850 delete arg1;
29851
29852 wxPyEndAllowThreads(__tstate);
29853 if (PyErr_Occurred()) SWIG_fail;
29854 }
29855 Py_INCREF(Py_None); resultobj = Py_None;
29856 return resultobj;
29857 fail:
29858 return NULL;
29859 }
29860
29861
29862 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29863 PyObject *resultobj;
29864 wxClipboard *arg1 = (wxClipboard *) 0 ;
29865 bool result;
29866 PyObject * obj0 = 0 ;
29867 char *kwnames[] = {
29868 (char *) "self", NULL
29869 };
29870
29871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29873 if (SWIG_arg_fail(1)) SWIG_fail;
29874 {
29875 PyThreadState* __tstate = wxPyBeginAllowThreads();
29876 result = (bool)(arg1)->Open();
29877
29878 wxPyEndAllowThreads(__tstate);
29879 if (PyErr_Occurred()) SWIG_fail;
29880 }
29881 {
29882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29883 }
29884 return resultobj;
29885 fail:
29886 return NULL;
29887 }
29888
29889
29890 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29891 PyObject *resultobj;
29892 wxClipboard *arg1 = (wxClipboard *) 0 ;
29893 PyObject * obj0 = 0 ;
29894 char *kwnames[] = {
29895 (char *) "self", NULL
29896 };
29897
29898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29900 if (SWIG_arg_fail(1)) SWIG_fail;
29901 {
29902 PyThreadState* __tstate = wxPyBeginAllowThreads();
29903 (arg1)->Close();
29904
29905 wxPyEndAllowThreads(__tstate);
29906 if (PyErr_Occurred()) SWIG_fail;
29907 }
29908 Py_INCREF(Py_None); resultobj = Py_None;
29909 return resultobj;
29910 fail:
29911 return NULL;
29912 }
29913
29914
29915 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29916 PyObject *resultobj;
29917 wxClipboard *arg1 = (wxClipboard *) 0 ;
29918 bool result;
29919 PyObject * obj0 = 0 ;
29920 char *kwnames[] = {
29921 (char *) "self", NULL
29922 };
29923
29924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29926 if (SWIG_arg_fail(1)) SWIG_fail;
29927 {
29928 PyThreadState* __tstate = wxPyBeginAllowThreads();
29929 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29930
29931 wxPyEndAllowThreads(__tstate);
29932 if (PyErr_Occurred()) SWIG_fail;
29933 }
29934 {
29935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29936 }
29937 return resultobj;
29938 fail:
29939 return NULL;
29940 }
29941
29942
29943 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29944 PyObject *resultobj;
29945 wxClipboard *arg1 = (wxClipboard *) 0 ;
29946 wxDataObject *arg2 = (wxDataObject *) 0 ;
29947 bool result;
29948 PyObject * obj0 = 0 ;
29949 PyObject * obj1 = 0 ;
29950 char *kwnames[] = {
29951 (char *) "self",(char *) "data", NULL
29952 };
29953
29954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29956 if (SWIG_arg_fail(1)) SWIG_fail;
29957 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29958 if (SWIG_arg_fail(2)) SWIG_fail;
29959 {
29960 PyThreadState* __tstate = wxPyBeginAllowThreads();
29961 result = (bool)(arg1)->AddData(arg2);
29962
29963 wxPyEndAllowThreads(__tstate);
29964 if (PyErr_Occurred()) SWIG_fail;
29965 }
29966 {
29967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29968 }
29969 return resultobj;
29970 fail:
29971 return NULL;
29972 }
29973
29974
29975 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29976 PyObject *resultobj;
29977 wxClipboard *arg1 = (wxClipboard *) 0 ;
29978 wxDataObject *arg2 = (wxDataObject *) 0 ;
29979 bool result;
29980 PyObject * obj0 = 0 ;
29981 PyObject * obj1 = 0 ;
29982 char *kwnames[] = {
29983 (char *) "self",(char *) "data", NULL
29984 };
29985
29986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29988 if (SWIG_arg_fail(1)) SWIG_fail;
29989 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29990 if (SWIG_arg_fail(2)) SWIG_fail;
29991 {
29992 PyThreadState* __tstate = wxPyBeginAllowThreads();
29993 result = (bool)(arg1)->SetData(arg2);
29994
29995 wxPyEndAllowThreads(__tstate);
29996 if (PyErr_Occurred()) SWIG_fail;
29997 }
29998 {
29999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30000 }
30001 return resultobj;
30002 fail:
30003 return NULL;
30004 }
30005
30006
30007 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
30008 PyObject *resultobj;
30009 wxClipboard *arg1 = (wxClipboard *) 0 ;
30010 wxDataFormat *arg2 = 0 ;
30011 bool result;
30012 PyObject * obj0 = 0 ;
30013 PyObject * obj1 = 0 ;
30014 char *kwnames[] = {
30015 (char *) "self",(char *) "format", NULL
30016 };
30017
30018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
30019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30020 if (SWIG_arg_fail(1)) SWIG_fail;
30021 {
30022 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
30023 if (SWIG_arg_fail(2)) SWIG_fail;
30024 if (arg2 == NULL) {
30025 SWIG_null_ref("wxDataFormat");
30026 }
30027 if (SWIG_arg_fail(2)) SWIG_fail;
30028 }
30029 {
30030 PyThreadState* __tstate = wxPyBeginAllowThreads();
30031 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
30032
30033 wxPyEndAllowThreads(__tstate);
30034 if (PyErr_Occurred()) SWIG_fail;
30035 }
30036 {
30037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30038 }
30039 return resultobj;
30040 fail:
30041 return NULL;
30042 }
30043
30044
30045 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30046 PyObject *resultobj;
30047 wxClipboard *arg1 = (wxClipboard *) 0 ;
30048 wxDataObject *arg2 = 0 ;
30049 bool result;
30050 PyObject * obj0 = 0 ;
30051 PyObject * obj1 = 0 ;
30052 char *kwnames[] = {
30053 (char *) "self",(char *) "data", NULL
30054 };
30055
30056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30058 if (SWIG_arg_fail(1)) SWIG_fail;
30059 {
30060 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30061 if (SWIG_arg_fail(2)) SWIG_fail;
30062 if (arg2 == NULL) {
30063 SWIG_null_ref("wxDataObject");
30064 }
30065 if (SWIG_arg_fail(2)) SWIG_fail;
30066 }
30067 {
30068 PyThreadState* __tstate = wxPyBeginAllowThreads();
30069 result = (bool)(arg1)->GetData(*arg2);
30070
30071 wxPyEndAllowThreads(__tstate);
30072 if (PyErr_Occurred()) SWIG_fail;
30073 }
30074 {
30075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30076 }
30077 return resultobj;
30078 fail:
30079 return NULL;
30080 }
30081
30082
30083 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30084 PyObject *resultobj;
30085 wxClipboard *arg1 = (wxClipboard *) 0 ;
30086 PyObject * obj0 = 0 ;
30087 char *kwnames[] = {
30088 (char *) "self", NULL
30089 };
30090
30091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30093 if (SWIG_arg_fail(1)) SWIG_fail;
30094 {
30095 PyThreadState* __tstate = wxPyBeginAllowThreads();
30096 (arg1)->Clear();
30097
30098 wxPyEndAllowThreads(__tstate);
30099 if (PyErr_Occurred()) SWIG_fail;
30100 }
30101 Py_INCREF(Py_None); resultobj = Py_None;
30102 return resultobj;
30103 fail:
30104 return NULL;
30105 }
30106
30107
30108 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30109 PyObject *resultobj;
30110 wxClipboard *arg1 = (wxClipboard *) 0 ;
30111 bool result;
30112 PyObject * obj0 = 0 ;
30113 char *kwnames[] = {
30114 (char *) "self", NULL
30115 };
30116
30117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30119 if (SWIG_arg_fail(1)) SWIG_fail;
30120 {
30121 PyThreadState* __tstate = wxPyBeginAllowThreads();
30122 result = (bool)(arg1)->Flush();
30123
30124 wxPyEndAllowThreads(__tstate);
30125 if (PyErr_Occurred()) SWIG_fail;
30126 }
30127 {
30128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30129 }
30130 return resultobj;
30131 fail:
30132 return NULL;
30133 }
30134
30135
30136 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30137 PyObject *resultobj;
30138 wxClipboard *arg1 = (wxClipboard *) 0 ;
30139 bool arg2 = (bool) true ;
30140 PyObject * obj0 = 0 ;
30141 PyObject * obj1 = 0 ;
30142 char *kwnames[] = {
30143 (char *) "self",(char *) "primary", NULL
30144 };
30145
30146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30148 if (SWIG_arg_fail(1)) SWIG_fail;
30149 if (obj1) {
30150 {
30151 arg2 = (bool)(SWIG_As_bool(obj1));
30152 if (SWIG_arg_fail(2)) SWIG_fail;
30153 }
30154 }
30155 {
30156 PyThreadState* __tstate = wxPyBeginAllowThreads();
30157 (arg1)->UsePrimarySelection(arg2);
30158
30159 wxPyEndAllowThreads(__tstate);
30160 if (PyErr_Occurred()) SWIG_fail;
30161 }
30162 Py_INCREF(Py_None); resultobj = Py_None;
30163 return resultobj;
30164 fail:
30165 return NULL;
30166 }
30167
30168
30169 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30170 PyObject *resultobj;
30171 wxClipboard *result;
30172 char *kwnames[] = {
30173 NULL
30174 };
30175
30176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30177 {
30178 PyThreadState* __tstate = wxPyBeginAllowThreads();
30179 result = (wxClipboard *)wxClipboard::Get();
30180
30181 wxPyEndAllowThreads(__tstate);
30182 if (PyErr_Occurred()) SWIG_fail;
30183 }
30184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30185 return resultobj;
30186 fail:
30187 return NULL;
30188 }
30189
30190
30191 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30192 PyObject *obj;
30193 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30194 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30195 Py_INCREF(obj);
30196 return Py_BuildValue((char *)"");
30197 }
30198 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30199 PyObject *resultobj;
30200 wxClipboard *arg1 = (wxClipboard *) NULL ;
30201 wxClipboardLocker *result;
30202 PyObject * obj0 = 0 ;
30203 char *kwnames[] = {
30204 (char *) "clipboard", NULL
30205 };
30206
30207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30208 if (obj0) {
30209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30210 if (SWIG_arg_fail(1)) SWIG_fail;
30211 }
30212 {
30213 PyThreadState* __tstate = wxPyBeginAllowThreads();
30214 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30215
30216 wxPyEndAllowThreads(__tstate);
30217 if (PyErr_Occurred()) SWIG_fail;
30218 }
30219 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30220 return resultobj;
30221 fail:
30222 return NULL;
30223 }
30224
30225
30226 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30227 PyObject *resultobj;
30228 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30229 PyObject * obj0 = 0 ;
30230 char *kwnames[] = {
30231 (char *) "self", NULL
30232 };
30233
30234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30236 if (SWIG_arg_fail(1)) SWIG_fail;
30237 {
30238 PyThreadState* __tstate = wxPyBeginAllowThreads();
30239 delete arg1;
30240
30241 wxPyEndAllowThreads(__tstate);
30242 if (PyErr_Occurred()) SWIG_fail;
30243 }
30244 Py_INCREF(Py_None); resultobj = Py_None;
30245 return resultobj;
30246 fail:
30247 return NULL;
30248 }
30249
30250
30251 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30252 PyObject *resultobj;
30253 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30254 bool result;
30255 PyObject * obj0 = 0 ;
30256 char *kwnames[] = {
30257 (char *) "self", NULL
30258 };
30259
30260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30262 if (SWIG_arg_fail(1)) SWIG_fail;
30263 {
30264 PyThreadState* __tstate = wxPyBeginAllowThreads();
30265 result = (bool)wxClipboardLocker___nonzero__(arg1);
30266
30267 wxPyEndAllowThreads(__tstate);
30268 if (PyErr_Occurred()) SWIG_fail;
30269 }
30270 {
30271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30272 }
30273 return resultobj;
30274 fail:
30275 return NULL;
30276 }
30277
30278
30279 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30280 PyObject *obj;
30281 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30282 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30283 Py_INCREF(obj);
30284 return Py_BuildValue((char *)"");
30285 }
30286 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30287 PyObject *resultobj;
30288 int arg1 = (int) 0 ;
30289 int arg2 = (int) 0 ;
30290 int arg3 = (int) 0 ;
30291 int arg4 = (int) 0 ;
30292 wxVideoMode *result;
30293 PyObject * obj0 = 0 ;
30294 PyObject * obj1 = 0 ;
30295 PyObject * obj2 = 0 ;
30296 PyObject * obj3 = 0 ;
30297 char *kwnames[] = {
30298 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30299 };
30300
30301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30302 if (obj0) {
30303 {
30304 arg1 = (int)(SWIG_As_int(obj0));
30305 if (SWIG_arg_fail(1)) SWIG_fail;
30306 }
30307 }
30308 if (obj1) {
30309 {
30310 arg2 = (int)(SWIG_As_int(obj1));
30311 if (SWIG_arg_fail(2)) SWIG_fail;
30312 }
30313 }
30314 if (obj2) {
30315 {
30316 arg3 = (int)(SWIG_As_int(obj2));
30317 if (SWIG_arg_fail(3)) SWIG_fail;
30318 }
30319 }
30320 if (obj3) {
30321 {
30322 arg4 = (int)(SWIG_As_int(obj3));
30323 if (SWIG_arg_fail(4)) SWIG_fail;
30324 }
30325 }
30326 {
30327 PyThreadState* __tstate = wxPyBeginAllowThreads();
30328 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30329
30330 wxPyEndAllowThreads(__tstate);
30331 if (PyErr_Occurred()) SWIG_fail;
30332 }
30333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30334 return resultobj;
30335 fail:
30336 return NULL;
30337 }
30338
30339
30340 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30341 PyObject *resultobj;
30342 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30343 PyObject * obj0 = 0 ;
30344 char *kwnames[] = {
30345 (char *) "self", NULL
30346 };
30347
30348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30350 if (SWIG_arg_fail(1)) SWIG_fail;
30351 {
30352 PyThreadState* __tstate = wxPyBeginAllowThreads();
30353 delete arg1;
30354
30355 wxPyEndAllowThreads(__tstate);
30356 if (PyErr_Occurred()) SWIG_fail;
30357 }
30358 Py_INCREF(Py_None); resultobj = Py_None;
30359 return resultobj;
30360 fail:
30361 return NULL;
30362 }
30363
30364
30365 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30366 PyObject *resultobj;
30367 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30368 wxVideoMode *arg2 = 0 ;
30369 bool result;
30370 PyObject * obj0 = 0 ;
30371 PyObject * obj1 = 0 ;
30372 char *kwnames[] = {
30373 (char *) "self",(char *) "other", NULL
30374 };
30375
30376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30378 if (SWIG_arg_fail(1)) SWIG_fail;
30379 {
30380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30381 if (SWIG_arg_fail(2)) SWIG_fail;
30382 if (arg2 == NULL) {
30383 SWIG_null_ref("wxVideoMode");
30384 }
30385 if (SWIG_arg_fail(2)) SWIG_fail;
30386 }
30387 {
30388 PyThreadState* __tstate = wxPyBeginAllowThreads();
30389 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30390
30391 wxPyEndAllowThreads(__tstate);
30392 if (PyErr_Occurred()) SWIG_fail;
30393 }
30394 {
30395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30396 }
30397 return resultobj;
30398 fail:
30399 return NULL;
30400 }
30401
30402
30403 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30404 PyObject *resultobj;
30405 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30406 int result;
30407 PyObject * obj0 = 0 ;
30408 char *kwnames[] = {
30409 (char *) "self", NULL
30410 };
30411
30412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30414 if (SWIG_arg_fail(1)) SWIG_fail;
30415 {
30416 PyThreadState* __tstate = wxPyBeginAllowThreads();
30417 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30418
30419 wxPyEndAllowThreads(__tstate);
30420 if (PyErr_Occurred()) SWIG_fail;
30421 }
30422 {
30423 resultobj = SWIG_From_int((int)(result));
30424 }
30425 return resultobj;
30426 fail:
30427 return NULL;
30428 }
30429
30430
30431 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30432 PyObject *resultobj;
30433 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30434 int result;
30435 PyObject * obj0 = 0 ;
30436 char *kwnames[] = {
30437 (char *) "self", NULL
30438 };
30439
30440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30442 if (SWIG_arg_fail(1)) SWIG_fail;
30443 {
30444 PyThreadState* __tstate = wxPyBeginAllowThreads();
30445 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30446
30447 wxPyEndAllowThreads(__tstate);
30448 if (PyErr_Occurred()) SWIG_fail;
30449 }
30450 {
30451 resultobj = SWIG_From_int((int)(result));
30452 }
30453 return resultobj;
30454 fail:
30455 return NULL;
30456 }
30457
30458
30459 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30460 PyObject *resultobj;
30461 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30462 int result;
30463 PyObject * obj0 = 0 ;
30464 char *kwnames[] = {
30465 (char *) "self", NULL
30466 };
30467
30468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30470 if (SWIG_arg_fail(1)) SWIG_fail;
30471 {
30472 PyThreadState* __tstate = wxPyBeginAllowThreads();
30473 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30474
30475 wxPyEndAllowThreads(__tstate);
30476 if (PyErr_Occurred()) SWIG_fail;
30477 }
30478 {
30479 resultobj = SWIG_From_int((int)(result));
30480 }
30481 return resultobj;
30482 fail:
30483 return NULL;
30484 }
30485
30486
30487 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30488 PyObject *resultobj;
30489 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30490 bool result;
30491 PyObject * obj0 = 0 ;
30492 char *kwnames[] = {
30493 (char *) "self", NULL
30494 };
30495
30496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30498 if (SWIG_arg_fail(1)) SWIG_fail;
30499 {
30500 PyThreadState* __tstate = wxPyBeginAllowThreads();
30501 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30502
30503 wxPyEndAllowThreads(__tstate);
30504 if (PyErr_Occurred()) SWIG_fail;
30505 }
30506 {
30507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30508 }
30509 return resultobj;
30510 fail:
30511 return NULL;
30512 }
30513
30514
30515 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30516 PyObject *resultobj;
30517 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30518 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30519 bool result;
30520 PyObject * obj0 = 0 ;
30521 PyObject * obj1 = 0 ;
30522 char *kwnames[] = {
30523 (char *) "self",(char *) "other", NULL
30524 };
30525
30526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30528 if (SWIG_arg_fail(1)) SWIG_fail;
30529 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30530 if (SWIG_arg_fail(2)) SWIG_fail;
30531 {
30532 PyThreadState* __tstate = wxPyBeginAllowThreads();
30533 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30534
30535 wxPyEndAllowThreads(__tstate);
30536 if (PyErr_Occurred()) SWIG_fail;
30537 }
30538 {
30539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30540 }
30541 return resultobj;
30542 fail:
30543 return NULL;
30544 }
30545
30546
30547 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30548 PyObject *resultobj;
30549 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30550 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30551 bool result;
30552 PyObject * obj0 = 0 ;
30553 PyObject * obj1 = 0 ;
30554 char *kwnames[] = {
30555 (char *) "self",(char *) "other", NULL
30556 };
30557
30558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30560 if (SWIG_arg_fail(1)) SWIG_fail;
30561 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30562 if (SWIG_arg_fail(2)) SWIG_fail;
30563 {
30564 PyThreadState* __tstate = wxPyBeginAllowThreads();
30565 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30566
30567 wxPyEndAllowThreads(__tstate);
30568 if (PyErr_Occurred()) SWIG_fail;
30569 }
30570 {
30571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30572 }
30573 return resultobj;
30574 fail:
30575 return NULL;
30576 }
30577
30578
30579 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30580 PyObject *resultobj;
30581 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30582 int arg2 ;
30583 PyObject * obj0 = 0 ;
30584 PyObject * obj1 = 0 ;
30585 char *kwnames[] = {
30586 (char *) "self",(char *) "w", NULL
30587 };
30588
30589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30591 if (SWIG_arg_fail(1)) SWIG_fail;
30592 {
30593 arg2 = (int)(SWIG_As_int(obj1));
30594 if (SWIG_arg_fail(2)) SWIG_fail;
30595 }
30596 if (arg1) (arg1)->w = arg2;
30597
30598 Py_INCREF(Py_None); resultobj = Py_None;
30599 return resultobj;
30600 fail:
30601 return NULL;
30602 }
30603
30604
30605 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30606 PyObject *resultobj;
30607 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30608 int result;
30609 PyObject * obj0 = 0 ;
30610 char *kwnames[] = {
30611 (char *) "self", NULL
30612 };
30613
30614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30616 if (SWIG_arg_fail(1)) SWIG_fail;
30617 result = (int) ((arg1)->w);
30618
30619 {
30620 resultobj = SWIG_From_int((int)(result));
30621 }
30622 return resultobj;
30623 fail:
30624 return NULL;
30625 }
30626
30627
30628 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30629 PyObject *resultobj;
30630 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30631 int arg2 ;
30632 PyObject * obj0 = 0 ;
30633 PyObject * obj1 = 0 ;
30634 char *kwnames[] = {
30635 (char *) "self",(char *) "h", NULL
30636 };
30637
30638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30640 if (SWIG_arg_fail(1)) SWIG_fail;
30641 {
30642 arg2 = (int)(SWIG_As_int(obj1));
30643 if (SWIG_arg_fail(2)) SWIG_fail;
30644 }
30645 if (arg1) (arg1)->h = arg2;
30646
30647 Py_INCREF(Py_None); resultobj = Py_None;
30648 return resultobj;
30649 fail:
30650 return NULL;
30651 }
30652
30653
30654 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30655 PyObject *resultobj;
30656 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30657 int result;
30658 PyObject * obj0 = 0 ;
30659 char *kwnames[] = {
30660 (char *) "self", NULL
30661 };
30662
30663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30665 if (SWIG_arg_fail(1)) SWIG_fail;
30666 result = (int) ((arg1)->h);
30667
30668 {
30669 resultobj = SWIG_From_int((int)(result));
30670 }
30671 return resultobj;
30672 fail:
30673 return NULL;
30674 }
30675
30676
30677 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30678 PyObject *resultobj;
30679 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30680 int arg2 ;
30681 PyObject * obj0 = 0 ;
30682 PyObject * obj1 = 0 ;
30683 char *kwnames[] = {
30684 (char *) "self",(char *) "bpp", NULL
30685 };
30686
30687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30689 if (SWIG_arg_fail(1)) SWIG_fail;
30690 {
30691 arg2 = (int)(SWIG_As_int(obj1));
30692 if (SWIG_arg_fail(2)) SWIG_fail;
30693 }
30694 if (arg1) (arg1)->bpp = arg2;
30695
30696 Py_INCREF(Py_None); resultobj = Py_None;
30697 return resultobj;
30698 fail:
30699 return NULL;
30700 }
30701
30702
30703 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30704 PyObject *resultobj;
30705 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30706 int result;
30707 PyObject * obj0 = 0 ;
30708 char *kwnames[] = {
30709 (char *) "self", NULL
30710 };
30711
30712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30714 if (SWIG_arg_fail(1)) SWIG_fail;
30715 result = (int) ((arg1)->bpp);
30716
30717 {
30718 resultobj = SWIG_From_int((int)(result));
30719 }
30720 return resultobj;
30721 fail:
30722 return NULL;
30723 }
30724
30725
30726 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30727 PyObject *resultobj;
30728 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30729 int arg2 ;
30730 PyObject * obj0 = 0 ;
30731 PyObject * obj1 = 0 ;
30732 char *kwnames[] = {
30733 (char *) "self",(char *) "refresh", NULL
30734 };
30735
30736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30738 if (SWIG_arg_fail(1)) SWIG_fail;
30739 {
30740 arg2 = (int)(SWIG_As_int(obj1));
30741 if (SWIG_arg_fail(2)) SWIG_fail;
30742 }
30743 if (arg1) (arg1)->refresh = arg2;
30744
30745 Py_INCREF(Py_None); resultobj = Py_None;
30746 return resultobj;
30747 fail:
30748 return NULL;
30749 }
30750
30751
30752 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30753 PyObject *resultobj;
30754 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30755 int result;
30756 PyObject * obj0 = 0 ;
30757 char *kwnames[] = {
30758 (char *) "self", NULL
30759 };
30760
30761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30763 if (SWIG_arg_fail(1)) SWIG_fail;
30764 result = (int) ((arg1)->refresh);
30765
30766 {
30767 resultobj = SWIG_From_int((int)(result));
30768 }
30769 return resultobj;
30770 fail:
30771 return NULL;
30772 }
30773
30774
30775 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30776 PyObject *obj;
30777 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30778 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30779 Py_INCREF(obj);
30780 return Py_BuildValue((char *)"");
30781 }
30782 static int _wrap_DefaultVideoMode_set(PyObject *) {
30783 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30784 return 1;
30785 }
30786
30787
30788 static PyObject *_wrap_DefaultVideoMode_get(void) {
30789 PyObject *pyobj;
30790
30791 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30792 return pyobj;
30793 }
30794
30795
30796 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30797 PyObject *resultobj;
30798 size_t arg1 = (size_t) 0 ;
30799 wxDisplay *result;
30800 PyObject * obj0 = 0 ;
30801 char *kwnames[] = {
30802 (char *) "index", NULL
30803 };
30804
30805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30806 if (obj0) {
30807 {
30808 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30809 if (SWIG_arg_fail(1)) SWIG_fail;
30810 }
30811 }
30812 {
30813 PyThreadState* __tstate = wxPyBeginAllowThreads();
30814 result = (wxDisplay *)new wxDisplay(arg1);
30815
30816 wxPyEndAllowThreads(__tstate);
30817 if (PyErr_Occurred()) SWIG_fail;
30818 }
30819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30820 return resultobj;
30821 fail:
30822 return NULL;
30823 }
30824
30825
30826 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30827 PyObject *resultobj;
30828 wxDisplay *arg1 = (wxDisplay *) 0 ;
30829 PyObject * obj0 = 0 ;
30830 char *kwnames[] = {
30831 (char *) "self", NULL
30832 };
30833
30834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30836 if (SWIG_arg_fail(1)) SWIG_fail;
30837 {
30838 PyThreadState* __tstate = wxPyBeginAllowThreads();
30839 delete arg1;
30840
30841 wxPyEndAllowThreads(__tstate);
30842 if (PyErr_Occurred()) SWIG_fail;
30843 }
30844 Py_INCREF(Py_None); resultobj = Py_None;
30845 return resultobj;
30846 fail:
30847 return NULL;
30848 }
30849
30850
30851 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30852 PyObject *resultobj;
30853 size_t result;
30854 char *kwnames[] = {
30855 NULL
30856 };
30857
30858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30859 {
30860 PyThreadState* __tstate = wxPyBeginAllowThreads();
30861 result = (size_t)wxDisplay::GetCount();
30862
30863 wxPyEndAllowThreads(__tstate);
30864 if (PyErr_Occurred()) SWIG_fail;
30865 }
30866 {
30867 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30868 }
30869 return resultobj;
30870 fail:
30871 return NULL;
30872 }
30873
30874
30875 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30876 PyObject *resultobj;
30877 wxPoint *arg1 = 0 ;
30878 int result;
30879 wxPoint temp1 ;
30880 PyObject * obj0 = 0 ;
30881 char *kwnames[] = {
30882 (char *) "pt", NULL
30883 };
30884
30885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30886 {
30887 arg1 = &temp1;
30888 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30889 }
30890 {
30891 PyThreadState* __tstate = wxPyBeginAllowThreads();
30892 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30893
30894 wxPyEndAllowThreads(__tstate);
30895 if (PyErr_Occurred()) SWIG_fail;
30896 }
30897 {
30898 resultobj = SWIG_From_int((int)(result));
30899 }
30900 return resultobj;
30901 fail:
30902 return NULL;
30903 }
30904
30905
30906 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30907 PyObject *resultobj;
30908 wxWindow *arg1 = (wxWindow *) 0 ;
30909 int result;
30910 PyObject * obj0 = 0 ;
30911 char *kwnames[] = {
30912 (char *) "window", NULL
30913 };
30914
30915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30917 if (SWIG_arg_fail(1)) SWIG_fail;
30918 {
30919 PyThreadState* __tstate = wxPyBeginAllowThreads();
30920 result = (int)wxDisplay::GetFromWindow(arg1);
30921
30922 wxPyEndAllowThreads(__tstate);
30923 if (PyErr_Occurred()) SWIG_fail;
30924 }
30925 {
30926 resultobj = SWIG_From_int((int)(result));
30927 }
30928 return resultobj;
30929 fail:
30930 return NULL;
30931 }
30932
30933
30934 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30935 PyObject *resultobj;
30936 wxDisplay *arg1 = (wxDisplay *) 0 ;
30937 bool result;
30938 PyObject * obj0 = 0 ;
30939 char *kwnames[] = {
30940 (char *) "self", NULL
30941 };
30942
30943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30945 if (SWIG_arg_fail(1)) SWIG_fail;
30946 {
30947 PyThreadState* __tstate = wxPyBeginAllowThreads();
30948 result = (bool)((wxDisplay const *)arg1)->IsOk();
30949
30950 wxPyEndAllowThreads(__tstate);
30951 if (PyErr_Occurred()) SWIG_fail;
30952 }
30953 {
30954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30955 }
30956 return resultobj;
30957 fail:
30958 return NULL;
30959 }
30960
30961
30962 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30963 PyObject *resultobj;
30964 wxDisplay *arg1 = (wxDisplay *) 0 ;
30965 wxRect result;
30966 PyObject * obj0 = 0 ;
30967 char *kwnames[] = {
30968 (char *) "self", NULL
30969 };
30970
30971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30973 if (SWIG_arg_fail(1)) SWIG_fail;
30974 {
30975 PyThreadState* __tstate = wxPyBeginAllowThreads();
30976 result = ((wxDisplay const *)arg1)->GetGeometry();
30977
30978 wxPyEndAllowThreads(__tstate);
30979 if (PyErr_Occurred()) SWIG_fail;
30980 }
30981 {
30982 wxRect * resultptr;
30983 resultptr = new wxRect((wxRect &)(result));
30984 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30985 }
30986 return resultobj;
30987 fail:
30988 return NULL;
30989 }
30990
30991
30992 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30993 PyObject *resultobj;
30994 wxDisplay *arg1 = (wxDisplay *) 0 ;
30995 wxString result;
30996 PyObject * obj0 = 0 ;
30997 char *kwnames[] = {
30998 (char *) "self", NULL
30999 };
31000
31001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
31002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31003 if (SWIG_arg_fail(1)) SWIG_fail;
31004 {
31005 PyThreadState* __tstate = wxPyBeginAllowThreads();
31006 result = ((wxDisplay const *)arg1)->GetName();
31007
31008 wxPyEndAllowThreads(__tstate);
31009 if (PyErr_Occurred()) SWIG_fail;
31010 }
31011 {
31012 #if wxUSE_UNICODE
31013 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31014 #else
31015 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31016 #endif
31017 }
31018 return resultobj;
31019 fail:
31020 return NULL;
31021 }
31022
31023
31024 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
31025 PyObject *resultobj;
31026 wxDisplay *arg1 = (wxDisplay *) 0 ;
31027 bool result;
31028 PyObject * obj0 = 0 ;
31029 char *kwnames[] = {
31030 (char *) "self", NULL
31031 };
31032
31033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
31034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31035 if (SWIG_arg_fail(1)) SWIG_fail;
31036 {
31037 PyThreadState* __tstate = wxPyBeginAllowThreads();
31038 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
31039
31040 wxPyEndAllowThreads(__tstate);
31041 if (PyErr_Occurred()) SWIG_fail;
31042 }
31043 {
31044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31045 }
31046 return resultobj;
31047 fail:
31048 return NULL;
31049 }
31050
31051
31052 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31053 PyObject *resultobj;
31054 wxDisplay *arg1 = (wxDisplay *) 0 ;
31055 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31056 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31057 PyObject *result;
31058 PyObject * obj0 = 0 ;
31059 PyObject * obj1 = 0 ;
31060 char *kwnames[] = {
31061 (char *) "self",(char *) "mode", NULL
31062 };
31063
31064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31066 if (SWIG_arg_fail(1)) SWIG_fail;
31067 if (obj1) {
31068 {
31069 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31070 if (SWIG_arg_fail(2)) SWIG_fail;
31071 if (arg2 == NULL) {
31072 SWIG_null_ref("wxVideoMode");
31073 }
31074 if (SWIG_arg_fail(2)) SWIG_fail;
31075 }
31076 }
31077 {
31078 PyThreadState* __tstate = wxPyBeginAllowThreads();
31079 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31080
31081 wxPyEndAllowThreads(__tstate);
31082 if (PyErr_Occurred()) SWIG_fail;
31083 }
31084 resultobj = result;
31085 return resultobj;
31086 fail:
31087 return NULL;
31088 }
31089
31090
31091 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31092 PyObject *resultobj;
31093 wxDisplay *arg1 = (wxDisplay *) 0 ;
31094 wxVideoMode result;
31095 PyObject * obj0 = 0 ;
31096 char *kwnames[] = {
31097 (char *) "self", NULL
31098 };
31099
31100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31102 if (SWIG_arg_fail(1)) SWIG_fail;
31103 {
31104 PyThreadState* __tstate = wxPyBeginAllowThreads();
31105 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31106
31107 wxPyEndAllowThreads(__tstate);
31108 if (PyErr_Occurred()) SWIG_fail;
31109 }
31110 {
31111 wxVideoMode * resultptr;
31112 resultptr = new wxVideoMode((wxVideoMode &)(result));
31113 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31114 }
31115 return resultobj;
31116 fail:
31117 return NULL;
31118 }
31119
31120
31121 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31122 PyObject *resultobj;
31123 wxDisplay *arg1 = (wxDisplay *) 0 ;
31124 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31125 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31126 bool result;
31127 PyObject * obj0 = 0 ;
31128 PyObject * obj1 = 0 ;
31129 char *kwnames[] = {
31130 (char *) "self",(char *) "mode", NULL
31131 };
31132
31133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31135 if (SWIG_arg_fail(1)) SWIG_fail;
31136 if (obj1) {
31137 {
31138 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31139 if (SWIG_arg_fail(2)) SWIG_fail;
31140 if (arg2 == NULL) {
31141 SWIG_null_ref("wxVideoMode");
31142 }
31143 if (SWIG_arg_fail(2)) SWIG_fail;
31144 }
31145 }
31146 {
31147 PyThreadState* __tstate = wxPyBeginAllowThreads();
31148 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31149
31150 wxPyEndAllowThreads(__tstate);
31151 if (PyErr_Occurred()) SWIG_fail;
31152 }
31153 {
31154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31155 }
31156 return resultobj;
31157 fail:
31158 return NULL;
31159 }
31160
31161
31162 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31163 PyObject *resultobj;
31164 wxDisplay *arg1 = (wxDisplay *) 0 ;
31165 PyObject * obj0 = 0 ;
31166 char *kwnames[] = {
31167 (char *) "self", NULL
31168 };
31169
31170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31172 if (SWIG_arg_fail(1)) SWIG_fail;
31173 {
31174 PyThreadState* __tstate = wxPyBeginAllowThreads();
31175 (arg1)->ResetMode();
31176
31177 wxPyEndAllowThreads(__tstate);
31178 if (PyErr_Occurred()) SWIG_fail;
31179 }
31180 Py_INCREF(Py_None); resultobj = Py_None;
31181 return resultobj;
31182 fail:
31183 return NULL;
31184 }
31185
31186
31187 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31188 PyObject *obj;
31189 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31190 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31191 Py_INCREF(obj);
31192 return Py_BuildValue((char *)"");
31193 }
31194 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31195 PyObject *resultobj;
31196 wxStandardPaths *result;
31197 char *kwnames[] = {
31198 NULL
31199 };
31200
31201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31202 {
31203 PyThreadState* __tstate = wxPyBeginAllowThreads();
31204 result = (wxStandardPaths *)StandardPaths_Get();
31205
31206 wxPyEndAllowThreads(__tstate);
31207 if (PyErr_Occurred()) SWIG_fail;
31208 }
31209 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31210 return resultobj;
31211 fail:
31212 return NULL;
31213 }
31214
31215
31216 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31217 PyObject *resultobj;
31218 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31219 wxString result;
31220 PyObject * obj0 = 0 ;
31221 char *kwnames[] = {
31222 (char *) "self", NULL
31223 };
31224
31225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31227 if (SWIG_arg_fail(1)) SWIG_fail;
31228 {
31229 PyThreadState* __tstate = wxPyBeginAllowThreads();
31230 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31231
31232 wxPyEndAllowThreads(__tstate);
31233 if (PyErr_Occurred()) SWIG_fail;
31234 }
31235 {
31236 #if wxUSE_UNICODE
31237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31238 #else
31239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31240 #endif
31241 }
31242 return resultobj;
31243 fail:
31244 return NULL;
31245 }
31246
31247
31248 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31249 PyObject *resultobj;
31250 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31251 wxString result;
31252 PyObject * obj0 = 0 ;
31253 char *kwnames[] = {
31254 (char *) "self", NULL
31255 };
31256
31257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31259 if (SWIG_arg_fail(1)) SWIG_fail;
31260 {
31261 PyThreadState* __tstate = wxPyBeginAllowThreads();
31262 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31263
31264 wxPyEndAllowThreads(__tstate);
31265 if (PyErr_Occurred()) SWIG_fail;
31266 }
31267 {
31268 #if wxUSE_UNICODE
31269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31270 #else
31271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31272 #endif
31273 }
31274 return resultobj;
31275 fail:
31276 return NULL;
31277 }
31278
31279
31280 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31281 PyObject *resultobj;
31282 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31283 wxString result;
31284 PyObject * obj0 = 0 ;
31285 char *kwnames[] = {
31286 (char *) "self", NULL
31287 };
31288
31289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31291 if (SWIG_arg_fail(1)) SWIG_fail;
31292 {
31293 PyThreadState* __tstate = wxPyBeginAllowThreads();
31294 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31295
31296 wxPyEndAllowThreads(__tstate);
31297 if (PyErr_Occurred()) SWIG_fail;
31298 }
31299 {
31300 #if wxUSE_UNICODE
31301 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31302 #else
31303 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31304 #endif
31305 }
31306 return resultobj;
31307 fail:
31308 return NULL;
31309 }
31310
31311
31312 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31313 PyObject *resultobj;
31314 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31315 wxString result;
31316 PyObject * obj0 = 0 ;
31317 char *kwnames[] = {
31318 (char *) "self", NULL
31319 };
31320
31321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31323 if (SWIG_arg_fail(1)) SWIG_fail;
31324 {
31325 PyThreadState* __tstate = wxPyBeginAllowThreads();
31326 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31327
31328 wxPyEndAllowThreads(__tstate);
31329 if (PyErr_Occurred()) SWIG_fail;
31330 }
31331 {
31332 #if wxUSE_UNICODE
31333 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31334 #else
31335 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31336 #endif
31337 }
31338 return resultobj;
31339 fail:
31340 return NULL;
31341 }
31342
31343
31344 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31345 PyObject *resultobj;
31346 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31347 wxString result;
31348 PyObject * obj0 = 0 ;
31349 char *kwnames[] = {
31350 (char *) "self", NULL
31351 };
31352
31353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31355 if (SWIG_arg_fail(1)) SWIG_fail;
31356 {
31357 PyThreadState* __tstate = wxPyBeginAllowThreads();
31358 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31359
31360 wxPyEndAllowThreads(__tstate);
31361 if (PyErr_Occurred()) SWIG_fail;
31362 }
31363 {
31364 #if wxUSE_UNICODE
31365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31366 #else
31367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31368 #endif
31369 }
31370 return resultobj;
31371 fail:
31372 return NULL;
31373 }
31374
31375
31376 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31377 PyObject *resultobj;
31378 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31379 wxString result;
31380 PyObject * obj0 = 0 ;
31381 char *kwnames[] = {
31382 (char *) "self", NULL
31383 };
31384
31385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31387 if (SWIG_arg_fail(1)) SWIG_fail;
31388 {
31389 PyThreadState* __tstate = wxPyBeginAllowThreads();
31390 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31391
31392 wxPyEndAllowThreads(__tstate);
31393 if (PyErr_Occurred()) SWIG_fail;
31394 }
31395 {
31396 #if wxUSE_UNICODE
31397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31398 #else
31399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31400 #endif
31401 }
31402 return resultobj;
31403 fail:
31404 return NULL;
31405 }
31406
31407
31408 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31409 PyObject *resultobj;
31410 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31411 wxString result;
31412 PyObject * obj0 = 0 ;
31413 char *kwnames[] = {
31414 (char *) "self", NULL
31415 };
31416
31417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31419 if (SWIG_arg_fail(1)) SWIG_fail;
31420 {
31421 PyThreadState* __tstate = wxPyBeginAllowThreads();
31422 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31423
31424 wxPyEndAllowThreads(__tstate);
31425 if (PyErr_Occurred()) SWIG_fail;
31426 }
31427 {
31428 #if wxUSE_UNICODE
31429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31430 #else
31431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31432 #endif
31433 }
31434 return resultobj;
31435 fail:
31436 return NULL;
31437 }
31438
31439
31440 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31441 PyObject *resultobj;
31442 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31443 wxString *arg2 = 0 ;
31444 bool temp2 = false ;
31445 PyObject * obj0 = 0 ;
31446 PyObject * obj1 = 0 ;
31447 char *kwnames[] = {
31448 (char *) "self",(char *) "prefix", NULL
31449 };
31450
31451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31453 if (SWIG_arg_fail(1)) SWIG_fail;
31454 {
31455 arg2 = wxString_in_helper(obj1);
31456 if (arg2 == NULL) SWIG_fail;
31457 temp2 = true;
31458 }
31459 {
31460 PyThreadState* __tstate = wxPyBeginAllowThreads();
31461 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31462
31463 wxPyEndAllowThreads(__tstate);
31464 if (PyErr_Occurred()) SWIG_fail;
31465 }
31466 Py_INCREF(Py_None); resultobj = Py_None;
31467 {
31468 if (temp2)
31469 delete arg2;
31470 }
31471 return resultobj;
31472 fail:
31473 {
31474 if (temp2)
31475 delete arg2;
31476 }
31477 return NULL;
31478 }
31479
31480
31481 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31482 PyObject *resultobj;
31483 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31484 wxString result;
31485 PyObject * obj0 = 0 ;
31486 char *kwnames[] = {
31487 (char *) "self", NULL
31488 };
31489
31490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31492 if (SWIG_arg_fail(1)) SWIG_fail;
31493 {
31494 PyThreadState* __tstate = wxPyBeginAllowThreads();
31495 result = wxStandardPaths_GetInstallPrefix(arg1);
31496
31497 wxPyEndAllowThreads(__tstate);
31498 if (PyErr_Occurred()) SWIG_fail;
31499 }
31500 {
31501 #if wxUSE_UNICODE
31502 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31503 #else
31504 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31505 #endif
31506 }
31507 return resultobj;
31508 fail:
31509 return NULL;
31510 }
31511
31512
31513 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31514 PyObject *obj;
31515 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31516 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31517 Py_INCREF(obj);
31518 return Py_BuildValue((char *)"");
31519 }
31520 static PyMethodDef SwigMethods[] = {
31521 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31528 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31536 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31601 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31609 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31627 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31630 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31633 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31636 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31642 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31656 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31662 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31668 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31671 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31685 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31688 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31689 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31692 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31719 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31721 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31723 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31725 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31732 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31738 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31752 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31756 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31759 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31776 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31784 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31831 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31849 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31859 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31875 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31891 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31905 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31915 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31958 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31961 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31964 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31968 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32061 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32062 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32063 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32064 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32081 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32126 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32160 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32168 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32169 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32174 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32183 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32190 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32193 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32196 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32201 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32204 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32208 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32211 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32215 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32216 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32220 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32224 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32225 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32228 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32231 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32236 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32238 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32239 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32243 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32244 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32245 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32247 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32249 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32250 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32251 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32252 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32253 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32256 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32257 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32258 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32259 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32260 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32261 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32262 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32263 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32264 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32265 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32267 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32268 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32271 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32272 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32273 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32274 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32275 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32276 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32277 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32278 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32279 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32280 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32281 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32282 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32283 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32284 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32285 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32286 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32287 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32288 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32289 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32290 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32291 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32292 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32293 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32294 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32295 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32296 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32297 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32298 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32299 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32300 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32301 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32302 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32303 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32304 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32305 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32306 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32307 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32308 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32309 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32310 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32311 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32312 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32313 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32314 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32315 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32316 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32317 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32318 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32319 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32320 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32321 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32322 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32323 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32324 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32325 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32326 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32327 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32328 { NULL, NULL, 0, NULL }
32329 };
32330
32331
32332 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32333
32334 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32335 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32336 }
32337 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32338 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32339 }
32340 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32341 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32342 }
32343 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32344 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32345 }
32346 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32347 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32348 }
32349 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32350 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32351 }
32352 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32353 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32354 }
32355 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32356 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32357 }
32358 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32359 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32360 }
32361 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32362 return (void *)((wxEvent *) ((wxPyEvent *) x));
32363 }
32364 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32365 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32366 }
32367 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32368 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32369 }
32370 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32371 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32372 }
32373 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32374 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32375 }
32376 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32377 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32378 }
32379 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32380 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32381 }
32382 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32383 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32384 }
32385 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32386 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32387 }
32388 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32389 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32390 }
32391 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32392 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32393 }
32394 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32395 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32396 }
32397 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32398 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32399 }
32400 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32401 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32402 }
32403 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32404 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32405 }
32406 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32407 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32408 }
32409 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32410 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32411 }
32412 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32413 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32414 }
32415 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32416 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32417 }
32418 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32419 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32420 }
32421 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32422 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32423 }
32424 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32425 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32426 }
32427 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32428 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32429 }
32430 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32431 return (void *)((wxEvent *) ((wxShowEvent *) x));
32432 }
32433 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32434 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32435 }
32436 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32437 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32438 }
32439 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32440 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32441 }
32442 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32443 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32444 }
32445 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32446 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32447 }
32448 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32449 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32450 }
32451 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32452 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32453 }
32454 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32455 return (void *)((wxConfigBase *) ((wxConfig *) x));
32456 }
32457 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32458 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32459 }
32460 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32461 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32462 }
32463 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32464 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32465 }
32466 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32467 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32468 }
32469 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32470 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32471 }
32472 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32473 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32474 }
32475 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32476 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32477 }
32478 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32479 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32480 }
32481 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32482 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32483 }
32484 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32485 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32486 }
32487 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32488 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32489 }
32490 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32491 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32492 }
32493 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32494 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32495 }
32496 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32497 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32498 }
32499 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32500 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32501 }
32502 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32503 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32504 }
32505 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32506 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32507 }
32508 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32509 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32510 }
32511 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32512 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32513 }
32514 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32515 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32516 }
32517 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32518 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32519 }
32520 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32521 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32522 }
32523 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32524 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32525 }
32526 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32527 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32528 }
32529 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32530 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32531 }
32532 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32533 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32534 }
32535 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32536 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32537 }
32538 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32539 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32540 }
32541 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32542 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32543 }
32544 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32545 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32546 }
32547 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32548 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32549 }
32550 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32551 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32552 }
32553 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32554 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32555 }
32556 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32557 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32558 }
32559 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32560 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32561 }
32562 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32563 return (void *)((wxObject *) ((wxSizerItem *) x));
32564 }
32565 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32566 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32567 }
32568 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32569 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32570 }
32571 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32572 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32573 }
32574 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32575 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32576 }
32577 static void *_p_wxSizerTo_p_wxObject(void *x) {
32578 return (void *)((wxObject *) ((wxSizer *) x));
32579 }
32580 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32581 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32582 }
32583 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32584 return (void *)((wxObject *) ((wxFileHistory *) x));
32585 }
32586 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32587 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32588 }
32589 static void *_p_wxEventTo_p_wxObject(void *x) {
32590 return (void *)((wxObject *) ((wxEvent *) x));
32591 }
32592 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32593 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32594 }
32595 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32596 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32597 }
32598 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32599 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32600 }
32601 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32602 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32603 }
32604 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32605 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32606 }
32607 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32608 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32609 }
32610 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32611 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32612 }
32613 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32614 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32615 }
32616 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32617 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32618 }
32619 static void *_p_wxControlTo_p_wxObject(void *x) {
32620 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32621 }
32622 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32623 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32624 }
32625 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32626 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32627 }
32628 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32629 return (void *)((wxObject *) ((wxFSFile *) x));
32630 }
32631 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32632 return (void *)((wxObject *) ((wxClipboard *) x));
32633 }
32634 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32635 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32636 }
32637 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32638 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32639 }
32640 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32641 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32642 }
32643 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32644 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32645 }
32646 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32647 return (void *)((wxObject *) ((wxToolTip *) x));
32648 }
32649 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32650 return (void *)((wxObject *) ((wxMenuItem *) x));
32651 }
32652 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32653 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32654 }
32655 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32656 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32657 }
32658 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32659 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32660 }
32661 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32662 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32663 }
32664 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32665 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32666 }
32667 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32668 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32669 }
32670 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32671 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32672 }
32673 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32674 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32675 }
32676 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32677 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32678 }
32679 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32680 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32681 }
32682 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32683 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32684 }
32685 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32686 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32687 }
32688 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32689 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32690 }
32691 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32692 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32693 }
32694 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32695 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32696 }
32697 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32698 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32699 }
32700 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32701 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32702 }
32703 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32704 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32705 }
32706 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32707 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32708 }
32709 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32710 return (void *)((wxObject *) ((wxImageHandler *) x));
32711 }
32712 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32713 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32714 }
32715 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32716 return (void *)((wxObject *) ((wxEvtHandler *) x));
32717 }
32718 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32719 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32720 }
32721 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32722 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32723 }
32724 static void *_p_wxImageTo_p_wxObject(void *x) {
32725 return (void *)((wxObject *) ((wxImage *) x));
32726 }
32727 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32728 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32729 }
32730 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32731 return (void *)((wxObject *) ((wxSystemOptions *) x));
32732 }
32733 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32734 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32735 }
32736 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32737 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32738 }
32739 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32740 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32741 }
32742 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32743 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32744 }
32745 static void *_p_wxWindowTo_p_wxObject(void *x) {
32746 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32747 }
32748 static void *_p_wxMenuTo_p_wxObject(void *x) {
32749 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32750 }
32751 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32752 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32753 }
32754 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32755 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32756 }
32757 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32758 return (void *)((wxObject *) ((wxFileSystem *) x));
32759 }
32760 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32761 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32762 }
32763 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32764 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32765 }
32766 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32767 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32768 }
32769 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32770 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32771 }
32772 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32773 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32774 }
32775 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32776 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32777 }
32778 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32779 return (void *)((wxObject *) ((wxBusyInfo *) x));
32780 }
32781 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32782 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32783 }
32784 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32785 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32786 }
32787 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32788 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32789 }
32790 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32791 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32792 }
32793 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32794 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32795 }
32796 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32797 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32798 }
32799 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32800 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32801 }
32802 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32803 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32804 }
32805 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32806 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32807 }
32808 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32809 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32810 }
32811 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32812 return (void *)((wxLog *) ((wxLogStderr *) x));
32813 }
32814 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32815 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32816 }
32817 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32818 return (void *)((wxLog *) ((wxLogWindow *) x));
32819 }
32820 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32821 return (void *)((wxLog *) ((wxLogChain *) x));
32822 }
32823 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32824 return (void *)((wxLog *) ((wxLogGui *) x));
32825 }
32826 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32827 return (void *)((wxLog *) ((wxPyLog *) x));
32828 }
32829 static void *_p_wxControlTo_p_wxWindow(void *x) {
32830 return (void *)((wxWindow *) ((wxControl *) x));
32831 }
32832 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32833 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32834 }
32835 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32836 return (void *)((wxWindow *) ((wxMenuBar *) x));
32837 }
32838 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32839 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32840 }
32841 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32842 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32843 }
32844 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}};
32845 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}};
32846 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}};
32847 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}};
32848 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}};
32849 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}};
32850 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}};
32851 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}};
32852 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}};
32853 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}};
32854 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}};
32855 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}};
32856 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}};
32857 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}};
32858 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}};
32859 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}};
32860 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}};
32861 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}};
32862 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}};
32863 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}};
32864 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}};
32865 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}};
32866 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}};
32867 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}};
32868 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}};
32869 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}};
32870 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}};
32871 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}};
32872 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}};
32873 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}};
32874 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}};
32875 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}};
32876 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}};
32877 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}};
32878 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}};
32879 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}};
32880 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}};
32881 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}};
32882 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}};
32883 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}};
32884 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}};
32885 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}};
32886 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}};
32887 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}};
32888 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}};
32889 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}};
32890 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}};
32891 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}};
32892 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}};
32893 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}};
32894 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}};
32895 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}};
32896 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}};
32897 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}};
32898 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}};
32899 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}};
32900 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}};
32901 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}};
32902 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}};
32903 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}};
32904 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}};
32905 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}};
32906 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}};
32907 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}};
32908 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}};
32909 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}};
32910 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}};
32911 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}};
32912 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}};
32913 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}};
32914 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}};
32915 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}};
32916 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}};
32917 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}};
32918 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}};
32919 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}};
32920 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}};
32921 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}};
32922 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}};
32923 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}};
32924 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}};
32925 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}};
32926 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}};
32927 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}};
32928 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}};
32929 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}};
32930 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}};
32931 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}};
32932 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}};
32933 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}};
32934 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}};
32935 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}};
32936 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}};
32937 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}};
32938 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}};
32939 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}};
32940 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}};
32941
32942 static swig_type_info *swig_types_initial[] = {
32943 _swigt__p_wxLogChain,
32944 _swigt__p_wxMutexGuiLocker,
32945 _swigt__p_wxMetafile,
32946 _swigt__p_wxFileHistory,
32947 _swigt__p_wxLog,
32948 _swigt__p_wxMenu,
32949 _swigt__p_wxEvent,
32950 _swigt__p_wxDateTime__TimeZone,
32951 _swigt__p_wxConfigBase,
32952 _swigt__p_wxDisplay,
32953 _swigt__p_wxFileType,
32954 _swigt__p_wxLogGui,
32955 _swigt__p_wxFont,
32956 _swigt__p_wxDataFormat,
32957 _swigt__p_wxTimerEvent,
32958 _swigt__p_wxCaret,
32959 _swigt__ptrdiff_t,
32960 _swigt__std__ptrdiff_t,
32961 _swigt__p_int,
32962 _swigt__p_wxSize,
32963 _swigt__p_wxClipboard,
32964 _swigt__p_wxStopWatch,
32965 _swigt__p_wxDC,
32966 _swigt__p_wxClipboardLocker,
32967 _swigt__p_wxIcon,
32968 _swigt__p_wxLogStderr,
32969 _swigt__p_wxLogTextCtrl,
32970 _swigt__p_wxTextCtrl,
32971 _swigt__p_wxBusyCursor,
32972 _swigt__p_wxBitmapDataObject,
32973 _swigt__p_wxTextDataObject,
32974 _swigt__p_wxDataObject,
32975 _swigt__p_wxPyTextDataObject,
32976 _swigt__p_wxPyBitmapDataObject,
32977 _swigt__p_wxFileDataObject,
32978 _swigt__p_wxCustomDataObject,
32979 _swigt__p_wxURLDataObject,
32980 _swigt__p_wxMetafileDataObject,
32981 _swigt__p_wxSound,
32982 _swigt__p_wxTimerRunner,
32983 _swigt__p_wxLogWindow,
32984 _swigt__p_wxTimeSpan,
32985 _swigt__p_wxArrayString,
32986 _swigt__p_wxWindowDisabler,
32987 _swigt__p_form_ops_t,
32988 _swigt__p_wxToolTip,
32989 _swigt__p_wxDataObjectComposite,
32990 _swigt__p_wxSystemSettings,
32991 _swigt__p_wxFileConfig,
32992 _swigt__p_wxVideoMode,
32993 _swigt__p_wxDataObjectSimple,
32994 _swigt__p_wxPyDataObjectSimple,
32995 _swigt__p_wxDuplexMode,
32996 _swigt__p_wxEvtHandler,
32997 _swigt__p_wxRect,
32998 _swigt__p_char,
32999 _swigt__p_wxSingleInstanceChecker,
33000 _swigt__p_wxStandardPaths,
33001 _swigt__p_wxFileTypeInfo,
33002 _swigt__p_wxFrame,
33003 _swigt__p_wxTimer,
33004 _swigt__p_wxPaperSize,
33005 _swigt__p_wxMimeTypesManager,
33006 _swigt__p_wxPyArtProvider,
33007 _swigt__p_wxPyTipProvider,
33008 _swigt__p_wxTipProvider,
33009 _swigt__p_wxJoystick,
33010 _swigt__p_wxSystemOptions,
33011 _swigt__p_wxPoint,
33012 _swigt__p_wxJoystickEvent,
33013 _swigt__p_wxCursor,
33014 _swigt__p_wxObject,
33015 _swigt__p_wxOutputStream,
33016 _swigt__p_wxDateTime,
33017 _swigt__p_wxPyDropSource,
33018 _swigt__p_unsigned_long,
33019 _swigt__p_wxKillError,
33020 _swigt__p_wxWindow,
33021 _swigt__p_wxString,
33022 _swigt__p_wxPyProcess,
33023 _swigt__p_wxBitmap,
33024 _swigt__p_wxConfig,
33025 _swigt__unsigned_int,
33026 _swigt__p_unsigned_int,
33027 _swigt__p_unsigned_char,
33028 _swigt__p_wxChar,
33029 _swigt__p_wxBusyInfo,
33030 _swigt__p_wxPyDropTarget,
33031 _swigt__p_wxPyTextDropTarget,
33032 _swigt__p_wxPyFileDropTarget,
33033 _swigt__p_wxProcessEvent,
33034 _swigt__p_wxPyLog,
33035 _swigt__p_wxLogNull,
33036 _swigt__p_wxColour,
33037 _swigt__p_wxPyTimer,
33038 _swigt__p_wxConfigPathChanger,
33039 _swigt__p_wxDateSpan,
33040 0
33041 };
33042
33043
33044 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33045
33046 static swig_const_info swig_const_table[] = {
33047 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
33048 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
33049 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
33050 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
33051 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
33052 {0, 0, 0, 0.0, 0, 0}};
33053
33054 #ifdef __cplusplus
33055 }
33056 #endif
33057
33058
33059 #ifdef __cplusplus
33060 extern "C" {
33061 #endif
33062
33063 /* Python-specific SWIG API */
33064 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33065 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33066 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33067
33068 /* -----------------------------------------------------------------------------
33069 * global variable support code.
33070 * ----------------------------------------------------------------------------- */
33071
33072 typedef struct swig_globalvar {
33073 char *name; /* Name of global variable */
33074 PyObject *(*get_attr)(); /* Return the current value */
33075 int (*set_attr)(PyObject *); /* Set the value */
33076 struct swig_globalvar *next;
33077 } swig_globalvar;
33078
33079 typedef struct swig_varlinkobject {
33080 PyObject_HEAD
33081 swig_globalvar *vars;
33082 } swig_varlinkobject;
33083
33084 static PyObject *
33085 swig_varlink_repr(swig_varlinkobject *v) {
33086 v = v;
33087 return PyString_FromString("<Swig global variables>");
33088 }
33089
33090 static int
33091 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33092 swig_globalvar *var;
33093 flags = flags;
33094 fprintf(fp,"Swig global variables { ");
33095 for (var = v->vars; var; var=var->next) {
33096 fprintf(fp,"%s", var->name);
33097 if (var->next) fprintf(fp,", ");
33098 }
33099 fprintf(fp," }\n");
33100 return 0;
33101 }
33102
33103 static PyObject *
33104 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33105 swig_globalvar *var = v->vars;
33106 while (var) {
33107 if (strcmp(var->name,n) == 0) {
33108 return (*var->get_attr)();
33109 }
33110 var = var->next;
33111 }
33112 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33113 return NULL;
33114 }
33115
33116 static int
33117 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33118 swig_globalvar *var = v->vars;
33119 while (var) {
33120 if (strcmp(var->name,n) == 0) {
33121 return (*var->set_attr)(p);
33122 }
33123 var = var->next;
33124 }
33125 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33126 return 1;
33127 }
33128
33129 static PyTypeObject varlinktype = {
33130 PyObject_HEAD_INIT(0)
33131 0, /* Number of items in variable part (ob_size) */
33132 (char *)"swigvarlink", /* Type name (tp_name) */
33133 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33134 0, /* Itemsize (tp_itemsize) */
33135 0, /* Deallocator (tp_dealloc) */
33136 (printfunc) swig_varlink_print, /* Print (tp_print) */
33137 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33138 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33139 0, /* tp_compare */
33140 (reprfunc) swig_varlink_repr, /* tp_repr */
33141 0, /* tp_as_number */
33142 0, /* tp_as_sequence */
33143 0, /* tp_as_mapping */
33144 0, /* tp_hash */
33145 0, /* tp_call */
33146 0, /* tp_str */
33147 0, /* tp_getattro */
33148 0, /* tp_setattro */
33149 0, /* tp_as_buffer */
33150 0, /* tp_flags */
33151 0, /* tp_doc */
33152 #if PY_VERSION_HEX >= 0x02000000
33153 0, /* tp_traverse */
33154 0, /* tp_clear */
33155 #endif
33156 #if PY_VERSION_HEX >= 0x02010000
33157 0, /* tp_richcompare */
33158 0, /* tp_weaklistoffset */
33159 #endif
33160 #if PY_VERSION_HEX >= 0x02020000
33161 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33162 #endif
33163 #if PY_VERSION_HEX >= 0x02030000
33164 0, /* tp_del */
33165 #endif
33166 #ifdef COUNT_ALLOCS
33167 0,0,0,0 /* tp_alloc -> tp_next */
33168 #endif
33169 };
33170
33171 /* Create a variable linking object for use later */
33172 static PyObject *
33173 SWIG_Python_newvarlink(void) {
33174 swig_varlinkobject *result = 0;
33175 result = PyMem_NEW(swig_varlinkobject,1);
33176 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33177 result->ob_type = &varlinktype;
33178 result->vars = 0;
33179 result->ob_refcnt = 0;
33180 Py_XINCREF((PyObject *) result);
33181 return ((PyObject*) result);
33182 }
33183
33184 static void
33185 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33186 swig_varlinkobject *v;
33187 swig_globalvar *gv;
33188 v= (swig_varlinkobject *) p;
33189 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33190 gv->name = (char *) malloc(strlen(name)+1);
33191 strcpy(gv->name,name);
33192 gv->get_attr = get_attr;
33193 gv->set_attr = set_attr;
33194 gv->next = v->vars;
33195 v->vars = gv;
33196 }
33197
33198 /* -----------------------------------------------------------------------------
33199 * constants/methods manipulation
33200 * ----------------------------------------------------------------------------- */
33201
33202 /* Install Constants */
33203 static void
33204 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33205 PyObject *obj = 0;
33206 size_t i;
33207 for (i = 0; constants[i].type; i++) {
33208 switch(constants[i].type) {
33209 case SWIG_PY_INT:
33210 obj = PyInt_FromLong(constants[i].lvalue);
33211 break;
33212 case SWIG_PY_FLOAT:
33213 obj = PyFloat_FromDouble(constants[i].dvalue);
33214 break;
33215 case SWIG_PY_STRING:
33216 if (constants[i].pvalue) {
33217 obj = PyString_FromString((char *) constants[i].pvalue);
33218 } else {
33219 Py_INCREF(Py_None);
33220 obj = Py_None;
33221 }
33222 break;
33223 case SWIG_PY_POINTER:
33224 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33225 break;
33226 case SWIG_PY_BINARY:
33227 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33228 break;
33229 default:
33230 obj = 0;
33231 break;
33232 }
33233 if (obj) {
33234 PyDict_SetItemString(d,constants[i].name,obj);
33235 Py_DECREF(obj);
33236 }
33237 }
33238 }
33239
33240 /* -----------------------------------------------------------------------------*/
33241 /* Fix SwigMethods to carry the callback ptrs when needed */
33242 /* -----------------------------------------------------------------------------*/
33243
33244 static void
33245 SWIG_Python_FixMethods(PyMethodDef *methods,
33246 swig_const_info *const_table,
33247 swig_type_info **types,
33248 swig_type_info **types_initial) {
33249 size_t i;
33250 for (i = 0; methods[i].ml_name; ++i) {
33251 char *c = methods[i].ml_doc;
33252 if (c && (c = strstr(c, "swig_ptr: "))) {
33253 int j;
33254 swig_const_info *ci = 0;
33255 char *name = c + 10;
33256 for (j = 0; const_table[j].type; j++) {
33257 if (strncmp(const_table[j].name, name,
33258 strlen(const_table[j].name)) == 0) {
33259 ci = &(const_table[j]);
33260 break;
33261 }
33262 }
33263 if (ci) {
33264 size_t shift = (ci->ptype) - types;
33265 swig_type_info *ty = types_initial[shift];
33266 size_t ldoc = (c - methods[i].ml_doc);
33267 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33268 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33269 char *buff = ndoc;
33270 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33271 strncpy(buff, methods[i].ml_doc, ldoc);
33272 buff += ldoc;
33273 strncpy(buff, "swig_ptr: ", 10);
33274 buff += 10;
33275 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33276 methods[i].ml_doc = ndoc;
33277 }
33278 }
33279 }
33280 }
33281
33282 /* -----------------------------------------------------------------------------*
33283 * Initialize type list
33284 * -----------------------------------------------------------------------------*/
33285
33286 #if PY_MAJOR_VERSION < 2
33287 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33288 is copied out of Python/modsupport.c in python version 2.3.4 */
33289 static int
33290 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33291 {
33292 PyObject *dict;
33293 if (!PyModule_Check(m)) {
33294 PyErr_SetString(PyExc_TypeError,
33295 "PyModule_AddObject() needs module as first arg");
33296 return -1;
33297 }
33298 if (!o) {
33299 PyErr_SetString(PyExc_TypeError,
33300 "PyModule_AddObject() needs non-NULL value");
33301 return -1;
33302 }
33303
33304 dict = PyModule_GetDict(m);
33305 if (dict == NULL) {
33306 /* Internal error -- modules must have a dict! */
33307 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33308 PyModule_GetName(m));
33309 return -1;
33310 }
33311 if (PyDict_SetItemString(dict, name, o))
33312 return -1;
33313 Py_DECREF(o);
33314 return 0;
33315 }
33316 #endif
33317
33318 static swig_type_info **
33319 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33320 static PyMethodDef swig_empty_runtime_method_table[] = {
33321 {
33322 NULL, NULL, 0, NULL
33323 }
33324 };/* Sentinel */
33325
33326 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33327 swig_empty_runtime_method_table);
33328 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33329 if (pointer && module) {
33330 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33331 }
33332 return type_list_handle;
33333 }
33334
33335 static swig_type_info **
33336 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33337 swig_type_info **type_pointer;
33338
33339 /* first check if module already created */
33340 type_pointer = SWIG_Python_GetTypeListHandle();
33341 if (type_pointer) {
33342 return type_pointer;
33343 } else {
33344 /* create a new module and variable */
33345 return SWIG_Python_SetTypeListHandle(type_list_handle);
33346 }
33347 }
33348
33349 #ifdef __cplusplus
33350 }
33351 #endif
33352
33353 /* -----------------------------------------------------------------------------*
33354 * Partial Init method
33355 * -----------------------------------------------------------------------------*/
33356
33357 #ifdef SWIG_LINK_RUNTIME
33358 #ifdef __cplusplus
33359 extern "C"
33360 #endif
33361 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33362 #endif
33363
33364 #ifdef __cplusplus
33365 extern "C"
33366 #endif
33367 SWIGEXPORT(void) SWIG_init(void) {
33368 static PyObject *SWIG_globals = 0;
33369 static int typeinit = 0;
33370 PyObject *m, *d;
33371 int i;
33372 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33373
33374 /* Fix SwigMethods to carry the callback ptrs when needed */
33375 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33376
33377 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33378 d = PyModule_GetDict(m);
33379
33380 if (!typeinit) {
33381 #ifdef SWIG_LINK_RUNTIME
33382 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33383 #else
33384 # ifndef SWIG_STATIC_RUNTIME
33385 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33386 # endif
33387 #endif
33388 for (i = 0; swig_types_initial[i]; i++) {
33389 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33390 }
33391 typeinit = 1;
33392 }
33393 SWIG_InstallConstants(d,swig_const_table);
33394
33395 {
33396 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33397 }
33398 {
33399 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33400 }
33401 {
33402 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33403 }
33404 {
33405 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33406 }
33407 {
33408 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33409 }
33410 {
33411 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33412 }
33413 {
33414 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33415 }
33416 {
33417 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33418 }
33419 {
33420 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33421 }
33422 {
33423 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33424 }
33425 {
33426 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33427 }
33428 {
33429 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33430 }
33431 {
33432 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33433 }
33434 {
33435 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33436 }
33437 {
33438 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33439 }
33440 {
33441 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33442 }
33443 {
33444 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33445 }
33446 {
33447 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33448 }
33449 {
33450 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33463 }
33464 {
33465 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33466 }
33467 {
33468 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33469 }
33470 {
33471 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33472 }
33473 {
33474 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33475 }
33476 {
33477 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33478 }
33479 {
33480 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33481 }
33482 {
33483 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33484 }
33485 {
33486 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33487 }
33488 {
33489 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33490 }
33491 {
33492 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33493 }
33494 {
33495 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33496 }
33497 {
33498 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33499 }
33500 {
33501 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33502 }
33503 {
33504 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33505 }
33506 {
33507 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33508 }
33509 {
33510 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33511 }
33512 {
33513 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33514 }
33515 {
33516 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33517 }
33518 {
33519 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33520 }
33521 {
33522 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33523 }
33524 {
33525 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33526 }
33527 {
33528 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33529 }
33530 {
33531 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33532 }
33533 {
33534 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33535 }
33536 {
33537 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33538 }
33539 {
33540 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33541 }
33542 {
33543 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33544 }
33545 {
33546 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33547 }
33548 {
33549 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33550 }
33551 {
33552 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33553 }
33554 {
33555 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33556 }
33557 {
33558 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33559 }
33560 {
33561 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33562 }
33563 {
33564 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33565 }
33566 {
33567 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33568 }
33569 {
33570 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33571 }
33572 {
33573 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33574 }
33575 {
33576 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33577 }
33578 {
33579 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33580 }
33581 {
33582 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33583 }
33584 {
33585 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33586 }
33587 {
33588 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33589 }
33590 {
33591 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33592 }
33593 {
33594 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33595 }
33596 {
33597 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33598 }
33599 {
33600 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33601 }
33602 {
33603 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33604 }
33605 {
33606 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33607 }
33608 {
33609 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33610 }
33611 {
33612 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33613 }
33614 {
33615 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33616 }
33617 {
33618 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33619 }
33620 {
33621 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33622 }
33623 {
33624 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33625 }
33626 {
33627 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33628 }
33629 {
33630 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33631 }
33632 {
33633 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33634 }
33635 {
33636 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33637 }
33638 {
33639 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33640 }
33641 {
33642 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33643 }
33644 {
33645 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33646 }
33647 {
33648 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33649 }
33650 {
33651 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33652 }
33653 {
33654 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33655 }
33656 {
33657 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33658 }
33659 {
33660 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33661 }
33662 {
33663 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33664 }
33665 {
33666 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33667 }
33668 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33669 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33670 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33671 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33672 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33673 {
33674 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33675 }
33676 {
33677 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33678 }
33679 {
33680 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33681 }
33682 {
33683 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33684 }
33685 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33686
33687 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33688
33689 {
33690 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33691 }
33692 {
33693 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33694 }
33695 {
33696 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33697 }
33698 {
33699 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33700 }
33701 {
33702 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33703 }
33704 {
33705 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33706 }
33707 {
33708 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33709 }
33710 {
33711 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33712 }
33713 {
33714 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33715 }
33716 {
33717 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33718 }
33719 {
33720 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33721 }
33722 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33723 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33724 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33725 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33726 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33727 {
33728 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33729 }
33730 {
33731 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33732 }
33733 {
33734 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33735 }
33736 {
33737 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33738 }
33739 {
33740 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33741 }
33742 {
33743 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33744 }
33745 {
33746 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33747 }
33748 {
33749 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33750 }
33751 {
33752 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33753 }
33754 {
33755 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33756 }
33757 {
33758 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33759 }
33760 {
33761 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33762 }
33763 {
33764 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33765 }
33766 {
33767 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33768 }
33769 {
33770 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33771 }
33772 {
33773 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33774 }
33775 {
33776 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33777 }
33778 {
33779 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33780 }
33781 {
33782 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33783 }
33784 {
33785 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33786 }
33787 {
33788 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33789 }
33790 {
33791 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33792 }
33793 {
33794 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33795 }
33796 {
33797 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33798 }
33799 {
33800 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33801 }
33802 {
33803 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33804 }
33805 {
33806 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33807 }
33808 {
33809 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33810 }
33811 {
33812 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33813 }
33814 {
33815 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33816 }
33817 {
33818 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33819 }
33820 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33821 {
33822 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33823 }
33824 {
33825 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33826 }
33827 {
33828 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33829 }
33830 {
33831 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33832 }
33833 {
33834 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33835 }
33836
33837 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33838
33839 {
33840 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33841 }
33842 {
33843 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33844 }
33845 {
33846 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33847 }
33848 {
33849 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33850 }
33851 {
33852 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33853 }
33854 {
33855 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33856 }
33857 {
33858 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33859 }
33860 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33861 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33862 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33863 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33864 {
33865 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33866 }
33867 {
33868 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33869 }
33870 {
33871 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33872 }
33873 {
33874 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33875 }
33876 {
33877 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33878 }
33879 {
33880 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33881 }
33882 {
33883 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33884 }
33885 {
33886 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33887 }
33888 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33889 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33890 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33891 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33892 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33893 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33894 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33895 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33896 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33897 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33898 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33899 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33900 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33901 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33902 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33903 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33904 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33905 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33906 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33907 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33908 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33909 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33910 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33911 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33912 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33913 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33914 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33915 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33916 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33917 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33918 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33919 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33920 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33921 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33922 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33923 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33924 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33925 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33926 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33927 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33928 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33929 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33930 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33931 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33932 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33933 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33934 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33935 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33936 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33937 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33938 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33939 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33940 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33941 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33942 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33943 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33944
33945 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33946
33947 {
33948 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33949 }
33950 {
33951 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33952 }
33953 {
33954 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33955 }
33956 {
33957 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33958 }
33959 {
33960 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33961 }
33962 {
33963 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33964 }
33965 {
33966 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33967 }
33968 {
33969 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33970 }
33971 {
33972 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33973 }
33974 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33975 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33976 {
33977 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33978 }
33979 {
33980 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33981 }
33982 {
33983 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33984 }
33985 {
33986 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33987 }
33988 {
33989 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33990 }
33991 {
33992 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33993 }
33994 {
33995 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33996 }
33997 {
33998 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33999 }
34000 {
34001 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
34002 }
34003 {
34004 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
34005 }
34006 {
34007 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
34008 }
34009 {
34010 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
34011 }
34012 {
34013 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
34014 }
34015 {
34016 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
34017 }
34018 {
34019 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
34020 }
34021 {
34022 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
34023 }
34024 {
34025 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
34026 }
34027 {
34028 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
34029 }
34030 {
34031 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
34032 }
34033 {
34034 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
34035 }
34036 {
34037 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
34038 }
34039 {
34040 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
34041 }
34042 {
34043 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
34044 }
34045 {
34046 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
34047 }
34048 {
34049 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
34050 }
34051 {
34052 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
34053 }
34054 {
34055 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34056 }
34057 {
34058 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34059 }
34060 {
34061 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34062 }
34063 {
34064 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34065 }
34066 {
34067 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34068 }
34069 {
34070 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34071 }
34072 {
34073 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34074 }
34075 {
34076 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34077 }
34078 {
34079 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34080 }
34081 {
34082 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34083 }
34084 {
34085 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34086 }
34087 {
34088 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34089 }
34090 {
34091 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34092 }
34093 {
34094 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34095 }
34096 {
34097 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34098 }
34099 {
34100 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34101 }
34102 {
34103 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34104 }
34105 {
34106 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34107 }
34108 {
34109 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34110 }
34111 {
34112 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34113 }
34114 {
34115 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34116 }
34117 {
34118 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34119 }
34120 {
34121 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34122 }
34123 {
34124 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34125 }
34126 {
34127 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34128 }
34129 {
34130 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34131 }
34132 {
34133 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34134 }
34135 {
34136 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34137 }
34138 {
34139 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34140 }
34141 {
34142 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34143 }
34144 {
34145 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34146 }
34147 {
34148 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34149 }
34150 {
34151 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34152 }
34153 {
34154 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34155 }
34156 {
34157 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34158 }
34159 {
34160 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34161 }
34162 {
34163 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34164 }
34165 {
34166 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34167 }
34168 {
34169 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34170 }
34171 {
34172 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34173 }
34174 {
34175 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34176 }
34177 {
34178 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34179 }
34180 {
34181 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34182 }
34183 {
34184 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34185 }
34186 {
34187 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34188 }
34189 {
34190 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34191 }
34192 {
34193 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34194 }
34195 {
34196 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34197 }
34198 {
34199 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34200 }
34201 {
34202 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34203 }
34204 {
34205 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34206 }
34207 {
34208 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34209 }
34210 {
34211 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34212 }
34213 {
34214 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34215 }
34216 {
34217 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34218 }
34219 {
34220 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34221 }
34222 {
34223 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34224 }
34225 {
34226 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34227 }
34228 {
34229 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34230 }
34231 {
34232 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34233 }
34234 {
34235 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34236 }
34237 {
34238 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34239 }
34240 {
34241 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34242 }
34243 {
34244 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34245 }
34246 {
34247 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34248 }
34249 {
34250 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34251 }
34252 {
34253 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34254 }
34255 {
34256 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34257 }
34258 {
34259 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34260 }
34261 {
34262 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34263 }
34264 {
34265 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34266 }
34267 {
34268 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34269 }
34270 {
34271 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34272 }
34273 {
34274 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34275 }
34276 {
34277 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34278 }
34279 {
34280 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34281 }
34282 {
34283 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34284 }
34285 {
34286 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34287 }
34288 {
34289 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34290 }
34291 {
34292 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34293 }
34294 {
34295 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34296 }
34297 {
34298 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34299 }
34300 {
34301 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34302 }
34303 {
34304 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34305 }
34306 {
34307 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34308 }
34309 {
34310 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34311 }
34312 {
34313 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34314 }
34315 {
34316 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34317 }
34318 {
34319 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34320 }
34321 {
34322 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34323 }
34324 {
34325 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34326 }
34327 {
34328 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34329 }
34330 {
34331 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34332 }
34333 {
34334 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34335 }
34336 {
34337 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34338 }
34339 {
34340 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34341 }
34342 {
34343 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34344 }
34345 {
34346 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34347 }
34348 {
34349 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34350 }
34351 {
34352 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34353 }
34354 {
34355 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34356 }
34357 {
34358 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34359 }
34360 {
34361 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34362 }
34363 {
34364 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34365 }
34366 {
34367 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34368 }
34369 {
34370 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34371 }
34372 {
34373 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34374 }
34375 {
34376 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34377 }
34378 {
34379 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34380 }
34381 {
34382 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34383 }
34384 {
34385 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34386 }
34387 {
34388 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34389 }
34390 {
34391 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34392 }
34393 {
34394 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34395 }
34396 {
34397 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34398 }
34399 {
34400 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34401 }
34402 {
34403 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34404 }
34405 {
34406 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34407 }
34408 {
34409 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34410 }
34411 {
34412 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34413 }
34414 {
34415 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34416 }
34417 {
34418 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34419 }
34420 {
34421 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34422 }
34423 {
34424 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34425 }
34426 {
34427 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34428 }
34429 {
34430 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34431 }
34432 {
34433 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34434 }
34435 {
34436 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34437 }
34438 {
34439 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34440 }
34441 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34442 {
34443 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34444 }
34445 {
34446 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34447 }
34448 {
34449 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34450 }
34451 {
34452 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34453 }
34454 {
34455 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34456 }
34457 {
34458 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34459 }
34460 {
34461 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34462 }
34463 {
34464 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34465 }
34466 {
34467 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34468 }
34469 {
34470 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34471 }
34472 {
34473 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34474 }
34475 {
34476 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34477 }
34478 {
34479 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34480 }
34481 {
34482 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34483 }
34484 {
34485 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34486 }
34487 {
34488 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34489 }
34490 {
34491 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34492 }
34493 {
34494 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34495 }
34496 {
34497 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34498 }
34499 {
34500 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34501 }
34502 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34503 {
34504 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34505 }
34506 {
34507 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34508 }
34509 {
34510 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34511 }
34512 {
34513 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34514 }
34515 {
34516 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34517 }
34518 {
34519 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34520 }
34521 {
34522 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34523 }
34524 {
34525 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34526 }
34527 {
34528 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34529 }
34530 {
34531 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34532 }
34533 {
34534 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34535 }
34536 {
34537 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34538 }
34539
34540 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34541 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34542 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34543 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34544
34545 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34546 }
34547
wxWidgets (Impactor)