]> 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
MultiByteToWideChar(CP_UTF7, MB_ERR_INVALID_CHARS, ...) fails, so don't use MB_ERR_IN...
[wxWidgets.git] / wxPython / src / msw / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxMetafile swig_types[2]
1344 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1345 #define SWIGTYPE_p_wxLog swig_types[4]
1346 #define SWIGTYPE_p_wxMenu swig_types[5]
1347 #define SWIGTYPE_p_wxEvent swig_types[6]
1348 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1349 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1350 #define SWIGTYPE_p_wxDisplay swig_types[9]
1351 #define SWIGTYPE_p_wxFileType swig_types[10]
1352 #define SWIGTYPE_p_wxLogGui swig_types[11]
1353 #define SWIGTYPE_p_wxFont swig_types[12]
1354 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1355 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1356 #define SWIGTYPE_p_wxCaret swig_types[15]
1357 #define SWIGTYPE_ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_std__ptrdiff_t swig_types[17]
1359 #define SWIGTYPE_p_int swig_types[18]
1360 #define SWIGTYPE_p_wxSize swig_types[19]
1361 #define SWIGTYPE_p_wxClipboard swig_types[20]
1362 #define SWIGTYPE_p_wxStopWatch swig_types[21]
1363 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
1364 #define SWIGTYPE_p_wxIcon swig_types[23]
1365 #define SWIGTYPE_p_wxLogStderr swig_types[24]
1366 #define SWIGTYPE_p_wxLogTextCtrl swig_types[25]
1367 #define SWIGTYPE_p_wxTextCtrl swig_types[26]
1368 #define SWIGTYPE_p_wxBusyCursor swig_types[27]
1369 #define SWIGTYPE_p_wxBitmapDataObject swig_types[28]
1370 #define SWIGTYPE_p_wxTextDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxPyTextDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxFileDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxURLDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxMetafileDataObject swig_types[36]
1378 #define SWIGTYPE_p_wxSound swig_types[37]
1379 #define SWIGTYPE_p_wxTimerRunner swig_types[38]
1380 #define SWIGTYPE_p_wxLogWindow swig_types[39]
1381 #define SWIGTYPE_p_wxTimeSpan swig_types[40]
1382 #define SWIGTYPE_p_wxArrayString swig_types[41]
1383 #define SWIGTYPE_p_wxWindowDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxToolTip swig_types[44]
1386 #define SWIGTYPE_p_wxDataObjectComposite swig_types[45]
1387 #define SWIGTYPE_p_wxFileConfig swig_types[46]
1388 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1389 #define SWIGTYPE_p_wxVideoMode swig_types[48]
1390 #define SWIGTYPE_p_wxDataObjectSimple swig_types[49]
1391 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[50]
1392 #define SWIGTYPE_p_wxDuplexMode swig_types[51]
1393 #define SWIGTYPE_p_wxEvtHandler swig_types[52]
1394 #define SWIGTYPE_p_wxRect swig_types[53]
1395 #define SWIGTYPE_p_char swig_types[54]
1396 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[55]
1397 #define SWIGTYPE_p_wxStandardPaths swig_types[56]
1398 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
1399 #define SWIGTYPE_p_wxFrame swig_types[58]
1400 #define SWIGTYPE_p_wxTimer swig_types[59]
1401 #define SWIGTYPE_p_wxPaperSize swig_types[60]
1402 #define SWIGTYPE_p_wxMimeTypesManager swig_types[61]
1403 #define SWIGTYPE_p_wxPyArtProvider swig_types[62]
1404 #define SWIGTYPE_p_wxPyTipProvider swig_types[63]
1405 #define SWIGTYPE_p_wxTipProvider swig_types[64]
1406 #define SWIGTYPE_p_wxJoystick swig_types[65]
1407 #define SWIGTYPE_p_wxSystemOptions swig_types[66]
1408 #define SWIGTYPE_p_wxPoint swig_types[67]
1409 #define SWIGTYPE_p_wxJoystickEvent swig_types[68]
1410 #define SWIGTYPE_p_wxCursor swig_types[69]
1411 #define SWIGTYPE_p_wxObject swig_types[70]
1412 #define SWIGTYPE_p_wxOutputStream swig_types[71]
1413 #define SWIGTYPE_p_wxDateTime swig_types[72]
1414 #define SWIGTYPE_p_wxPyDropSource swig_types[73]
1415 #define SWIGTYPE_p_unsigned_long swig_types[74]
1416 #define SWIGTYPE_p_wxKillError swig_types[75]
1417 #define SWIGTYPE_p_wxWindow swig_types[76]
1418 #define SWIGTYPE_p_wxString swig_types[77]
1419 #define SWIGTYPE_p_wxPyProcess swig_types[78]
1420 #define SWIGTYPE_p_wxBitmap swig_types[79]
1421 #define SWIGTYPE_p_wxConfig swig_types[80]
1422 #define SWIGTYPE_unsigned_int swig_types[81]
1423 #define SWIGTYPE_p_unsigned_int swig_types[82]
1424 #define SWIGTYPE_p_unsigned_char swig_types[83]
1425 #define SWIGTYPE_p_wxChar swig_types[84]
1426 #define SWIGTYPE_p_wxBusyInfo swig_types[85]
1427 #define SWIGTYPE_p_wxPyDropTarget swig_types[86]
1428 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[88]
1430 #define SWIGTYPE_p_wxProcessEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPyLog swig_types[90]
1432 #define SWIGTYPE_p_wxLogNull swig_types[91]
1433 #define SWIGTYPE_p_wxColour swig_types[92]
1434 #define SWIGTYPE_p_wxPyTimer swig_types[93]
1435 #define SWIGTYPE_p_wxConfigPathChanger swig_types[94]
1436 #define SWIGTYPE_p_wxDateSpan swig_types[95]
1437 static swig_type_info *swig_types[97];
1438
1439 /* -------- TYPES TABLE (END) -------- */
1440
1441
1442 /*-----------------------------------------------
1443 @(target):= _misc_.so
1444 ------------------------------------------------*/
1445 #define SWIG_init init_misc_
1446
1447 #define SWIG_name "_misc_"
1448
1449 #include "wx/wxPython/wxPython.h"
1450 #include "wx/wxPython/pyclasses.h"
1451 #include "wx/wxPython/pyistream.h"
1452
1453 static const wxString wxPyEmptyString(wxEmptyString);
1454
1455
1456
1457 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1458 #define SWIG_From_int PyInt_FromLong
1459 /*@@*/
1460
1461
1462 #include <limits.h>
1463
1464
1465 SWIGINTERN int
1466 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1467 const char *errmsg)
1468 {
1469 if (value < min_value) {
1470 if (errmsg) {
1471 PyErr_Format(PyExc_OverflowError,
1472 "value %ld is less than '%s' minimum %ld",
1473 value, errmsg, min_value);
1474 }
1475 return 0;
1476 } else if (value > max_value) {
1477 if (errmsg) {
1478 PyErr_Format(PyExc_OverflowError,
1479 "value %ld is greater than '%s' maximum %ld",
1480 value, errmsg, max_value);
1481 }
1482 return 0;
1483 }
1484 return 1;
1485 }
1486
1487
1488 SWIGINTERN int
1489 SWIG_AsVal_long(PyObject* obj, long* val)
1490 {
1491 if (PyNumber_Check(obj)) {
1492 if (val) *val = PyInt_AsLong(obj);
1493 return 1;
1494 }
1495 else {
1496 SWIG_type_error("number", obj);
1497 }
1498 return 0;
1499 }
1500
1501
1502 #if INT_MAX != LONG_MAX
1503 SWIGINTERN int
1504 SWIG_AsVal_int(PyObject *obj, int *val)
1505 {
1506 const char* errmsg = val ? "int" : (char*)0;
1507 long v;
1508 if (SWIG_AsVal_long(obj, &v)) {
1509 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1510 if (val) *val = (int)(v);
1511 return 1;
1512 } else {
1513 return 0;
1514 }
1515 } else {
1516 PyErr_Clear();
1517 }
1518 if (val) {
1519 SWIG_type_error(errmsg, obj);
1520 }
1521 return 0;
1522 }
1523 #else
1524 SWIGINTERNSHORT int
1525 SWIG_AsVal_int(PyObject *obj, int *val)
1526 {
1527 return SWIG_AsVal_long(obj,(long*)val);
1528 }
1529 #endif
1530
1531
1532 SWIGINTERNSHORT int
1533 SWIG_As_int(PyObject* obj)
1534 {
1535 int v;
1536 if (!SWIG_AsVal_int(obj, &v)) {
1537 /*
1538 this is needed to make valgrind/purify happier.
1539 */
1540 memset((void*)&v, 0, sizeof(int));
1541 }
1542 return v;
1543 }
1544
1545
1546 SWIGINTERNSHORT int
1547 SWIG_Check_int(PyObject* obj)
1548 {
1549 return SWIG_AsVal_int(obj, (int*)0);
1550 }
1551
1552 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1553
1554 #include <wx/stockitem.h>
1555
1556 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1557 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1558 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1559
1560 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1561 #define SWIG_From_long PyInt_FromLong
1562 /*@@*/
1563
1564
1565 SWIGINTERNSHORT long
1566 SWIG_As_long(PyObject* obj)
1567 {
1568 long v;
1569 if (!SWIG_AsVal_long(obj, &v)) {
1570 /*
1571 this is needed to make valgrind/purify happier.
1572 */
1573 memset((void*)&v, 0, sizeof(long));
1574 }
1575 return v;
1576 }
1577
1578
1579 SWIGINTERNSHORT int
1580 SWIG_Check_long(PyObject* obj)
1581 {
1582 return SWIG_AsVal_long(obj, (long*)0);
1583 }
1584
1585
1586 SWIGINTERN int
1587 SWIG_AsVal_bool(PyObject *obj, bool *val)
1588 {
1589 if (obj == Py_True) {
1590 if (val) *val = true;
1591 return 1;
1592 }
1593 if (obj == Py_False) {
1594 if (val) *val = false;
1595 return 1;
1596 }
1597 int res = 0;
1598 if (SWIG_AsVal_int(obj, &res)) {
1599 if (val) *val = res ? true : false;
1600 return 1;
1601 } else {
1602 PyErr_Clear();
1603 }
1604 if (val) {
1605 SWIG_type_error("bool", obj);
1606 }
1607 return 0;
1608 }
1609
1610
1611 SWIGINTERNSHORT bool
1612 SWIG_As_bool(PyObject* obj)
1613 {
1614 bool v;
1615 if (!SWIG_AsVal_bool(obj, &v)) {
1616 /*
1617 this is needed to make valgrind/purify happier.
1618 */
1619 memset((void*)&v, 0, sizeof(bool));
1620 }
1621 return v;
1622 }
1623
1624
1625 SWIGINTERNSHORT int
1626 SWIG_Check_bool(PyObject* obj)
1627 {
1628 return SWIG_AsVal_bool(obj, (bool*)0);
1629 }
1630
1631
1632 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1633 PyObject* o2;
1634 PyObject* o3;
1635
1636 if (!target) {
1637 target = o;
1638 } else if (target == Py_None) {
1639 Py_DECREF(Py_None);
1640 target = o;
1641 } else {
1642 if (!PyTuple_Check(target)) {
1643 o2 = target;
1644 target = PyTuple_New(1);
1645 PyTuple_SetItem(target, 0, o2);
1646 }
1647 o3 = PyTuple_New(1);
1648 PyTuple_SetItem(o3, 0, o);
1649
1650 o2 = target;
1651 target = PySequence_Concat(o2, o3);
1652 Py_DECREF(o2);
1653 Py_DECREF(o3);
1654 }
1655 return target;
1656 }
1657
1658
1659
1660 SWIGINTERN int
1661 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1662 {
1663 long v = 0;
1664 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1665 SWIG_type_error("unsigned number", obj);
1666 }
1667 else if (val)
1668 *val = (unsigned long)v;
1669 return 1;
1670 }
1671
1672
1673 SWIGINTERNSHORT unsigned long
1674 SWIG_As_unsigned_SS_long(PyObject* obj)
1675 {
1676 unsigned long v;
1677 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1678 /*
1679 this is needed to make valgrind/purify happier.
1680 */
1681 memset((void*)&v, 0, sizeof(unsigned long));
1682 }
1683 return v;
1684 }
1685
1686
1687 SWIGINTERNSHORT int
1688 SWIG_Check_unsigned_SS_long(PyObject* obj)
1689 {
1690 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1691 }
1692
1693
1694 SWIGINTERNSHORT PyObject*
1695 SWIG_From_unsigned_SS_long(unsigned long value)
1696 {
1697 return (value > LONG_MAX) ?
1698 PyLong_FromUnsignedLong(value)
1699 : PyInt_FromLong((long)(value));
1700 }
1701
1702
1703 bool wxThread_IsMain() {
1704 #ifdef WXP_WITH_THREAD
1705 return wxThread::IsMain();
1706 #else
1707 return true;
1708 #endif
1709 }
1710
1711
1712 int wxCaret_GetBlinkTime() {
1713 return wxCaret::GetBlinkTime();
1714 }
1715
1716 void wxCaret_SetBlinkTime(int milliseconds) {
1717 wxCaret::SetBlinkTime(milliseconds);
1718 }
1719
1720
1721 #include <wx/snglinst.h>
1722
1723
1724 #include <wx/tipdlg.h>
1725
1726
1727 class wxPyTipProvider : public wxTipProvider {
1728 public:
1729 wxPyTipProvider(size_t currentTip)
1730 : wxTipProvider(currentTip) {}
1731
1732 DEC_PYCALLBACK_STRING__pure(GetTip);
1733 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1734 PYPRIVATE;
1735 };
1736
1737 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1738 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1739
1740
1741 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1742
1743 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1744
1745 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1746 : wxTimer(owner, id)
1747 {
1748 if (owner == NULL) SetOwner(this);
1749 }
1750
1751
1752 void wxPyTimer::Notify() {
1753 bool found;
1754 bool blocked = wxPyBeginBlockThreads();
1755 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1756 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1757 wxPyEndBlockThreads(blocked);
1758 if (! found)
1759 wxTimer::Notify();
1760 }
1761 void wxPyTimer::base_Notify() {
1762 wxTimer::Notify();
1763 }
1764
1765
1766
1767 SWIGINTERN PyObject *
1768 SWIG_FromCharPtr(const char* cptr)
1769 {
1770 if (cptr) {
1771 size_t size = strlen(cptr);
1772 if (size > INT_MAX) {
1773 return SWIG_NewPointerObj((char*)(cptr),
1774 SWIG_TypeQuery("char *"), 0);
1775 } else {
1776 if (size != 0) {
1777 return PyString_FromStringAndSize(cptr, size);
1778 } else {
1779 return PyString_FromString(cptr);
1780 }
1781 }
1782 }
1783 Py_INCREF(Py_None);
1784 return Py_None;
1785 }
1786
1787
1788 SWIGINTERNSHORT int
1789 SWIG_CheckUnsignedLongInRange(unsigned long value,
1790 unsigned long max_value,
1791 const char *errmsg)
1792 {
1793 if (value > max_value) {
1794 if (errmsg) {
1795 PyErr_Format(PyExc_OverflowError,
1796 "value %lu is greater than '%s' minimum %lu",
1797 value, errmsg, max_value);
1798 }
1799 return 0;
1800 }
1801 return 1;
1802 }
1803
1804
1805 #if UINT_MAX != ULONG_MAX
1806 SWIGINTERN int
1807 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1808 {
1809 const char* errmsg = val ? "unsigned int" : (char*)0;
1810 unsigned long v;
1811 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1812 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1813 if (val) *val = (unsigned int)(v);
1814 return 1;
1815 }
1816 } else {
1817 PyErr_Clear();
1818 }
1819 if (val) {
1820 SWIG_type_error(errmsg, obj);
1821 }
1822 return 0;
1823 }
1824 #else
1825 SWIGINTERNSHORT unsigned int
1826 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1827 {
1828 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1829 }
1830 #endif
1831
1832
1833 SWIGINTERNSHORT unsigned int
1834 SWIG_As_unsigned_SS_int(PyObject* obj)
1835 {
1836 unsigned int v;
1837 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1838 /*
1839 this is needed to make valgrind/purify happier.
1840 */
1841 memset((void*)&v, 0, sizeof(unsigned int));
1842 }
1843 return v;
1844 }
1845
1846
1847 SWIGINTERNSHORT int
1848 SWIG_Check_unsigned_SS_int(PyObject* obj)
1849 {
1850 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1851 }
1852
1853 static wxString Log_TimeStamp(){
1854 wxString msg;
1855 wxLog::TimeStamp(&msg);
1856 return msg;
1857 }
1858 static void wxLog_Destroy(wxLog *self){ delete self; }
1859 // Make somce wrappers that double any % signs so they are 'escaped'
1860 void wxPyLogFatalError(const wxString& msg)
1861 {
1862 wxString m(msg);
1863 m.Replace(wxT("%"), wxT("%%"));
1864 wxLogFatalError(m);
1865 }
1866
1867 void wxPyLogError(const wxString& msg)
1868 {
1869 wxString m(msg);
1870 m.Replace(wxT("%"), wxT("%%"));
1871 wxLogError(m);
1872 }
1873
1874 void wxPyLogWarning(const wxString& msg)
1875 {
1876 wxString m(msg);
1877 m.Replace(wxT("%"), wxT("%%"));
1878 wxLogWarning(m);
1879 }
1880
1881 void wxPyLogMessage(const wxString& msg)
1882 {
1883 wxString m(msg);
1884 m.Replace(wxT("%"), wxT("%%"));
1885 wxLogMessage(m);
1886 }
1887
1888 void wxPyLogInfo(const wxString& msg)
1889 {
1890 wxString m(msg);
1891 m.Replace(wxT("%"), wxT("%%"));
1892 wxLogInfo(m);
1893 }
1894
1895 void wxPyLogDebug(const wxString& msg)
1896 {
1897 wxString m(msg);
1898 m.Replace(wxT("%"), wxT("%%"));
1899 wxLogDebug(m);
1900 }
1901
1902 void wxPyLogVerbose(const wxString& msg)
1903 {
1904 wxString m(msg);
1905 m.Replace(wxT("%"), wxT("%%"));
1906 wxLogVerbose(m);
1907 }
1908
1909 void wxPyLogStatus(const wxString& msg)
1910 {
1911 wxString m(msg);
1912 m.Replace(wxT("%"), wxT("%%"));
1913 wxLogStatus(m);
1914 }
1915
1916 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
1917 {
1918 wxString m(msg);
1919 m.Replace(wxT("%"), wxT("%%"));
1920 wxLogStatus(pFrame, m);
1921 }
1922
1923 void wxPyLogSysError(const wxString& msg)
1924 {
1925 wxString m(msg);
1926 m.Replace(wxT("%"), wxT("%%"));
1927 wxLogSysError(m);
1928 }
1929
1930 void wxPyLogGeneric(unsigned long level, const wxString& msg)
1931 {
1932 wxString m(msg);
1933 m.Replace(wxT("%"), wxT("%%"));
1934 wxLogGeneric(level, m);
1935 }
1936
1937 void wxPyLogTrace(unsigned long mask, const wxString& msg)
1938 {
1939 wxString m(msg);
1940 m.Replace(wxT("%"), wxT("%%"));
1941 wxLogTrace(mask, m);
1942 }
1943
1944 void wxPyLogTrace(const wxString& mask, const wxString& msg)
1945 {
1946 wxString m(msg);
1947 m.Replace(wxT("%"), wxT("%%"));
1948 wxLogTrace(mask, m);
1949 }
1950
1951
1952
1953 // A wxLog class that can be derived from in wxPython
1954 class wxPyLog : public wxLog {
1955 public:
1956 wxPyLog() : wxLog() {}
1957
1958 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
1959 bool found;
1960 bool blocked = wxPyBeginBlockThreads();
1961 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
1962 PyObject* s = wx2PyString(szString);
1963 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
1964 Py_DECREF(s);
1965 }
1966 wxPyEndBlockThreads(blocked);
1967 if (! found)
1968 wxLog::DoLog(level, szString, t);
1969 }
1970
1971 virtual void DoLogString(const wxChar *szString, time_t t) {
1972 bool found;
1973 bool blocked = wxPyBeginBlockThreads();
1974 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
1975 PyObject* s = wx2PyString(szString);
1976 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
1977 Py_DECREF(s);
1978 }
1979 wxPyEndBlockThreads(blocked);
1980 if (! found)
1981 wxLog::DoLogString(szString, t);
1982 }
1983
1984 PYPRIVATE;
1985 };
1986
1987
1988
1989
1990 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
1991
1992
1993 #include <wx/joystick.h>
1994
1995
1996 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
1997 // A C++ stub class for wxJoystick for platforms that don't have it.
1998 class wxJoystick : public wxObject {
1999 public:
2000 wxJoystick(int joystick = wxJOYSTICK1) {
2001 bool blocked = wxPyBeginBlockThreads();
2002 PyErr_SetString(PyExc_NotImplementedError,
2003 "wxJoystick is not available on this platform.");
2004 wxPyEndBlockThreads(blocked);
2005 }
2006 wxPoint GetPosition() { return wxPoint(-1,-1); }
2007 int GetZPosition() { return -1; }
2008 int GetButtonState() { return -1; }
2009 int GetPOVPosition() { return -1; }
2010 int GetPOVCTSPosition() { return -1; }
2011 int GetRudderPosition() { return -1; }
2012 int GetUPosition() { return -1; }
2013 int GetVPosition() { return -1; }
2014 int GetMovementThreshold() { return -1; }
2015 void SetMovementThreshold(int threshold) {}
2016
2017 bool IsOk(void) { return false; }
2018 int GetNumberJoysticks() { return -1; }
2019 int GetManufacturerId() { return -1; }
2020 int GetProductId() { return -1; }
2021 wxString GetProductName() { return wxEmptyString; }
2022 int GetXMin() { return -1; }
2023 int GetYMin() { return -1; }
2024 int GetZMin() { return -1; }
2025 int GetXMax() { return -1; }
2026 int GetYMax() { return -1; }
2027 int GetZMax() { return -1; }
2028 int GetNumberButtons() { return -1; }
2029 int GetNumberAxes() { return -1; }
2030 int GetMaxButtons() { return -1; }
2031 int GetMaxAxes() { return -1; }
2032 int GetPollingMin() { return -1; }
2033 int GetPollingMax() { return -1; }
2034 int GetRudderMin() { return -1; }
2035 int GetRudderMax() { return -1; }
2036 int GetUMin() { return -1; }
2037 int GetUMax() { return -1; }
2038 int GetVMin() { return -1; }
2039 int GetVMax() { return -1; }
2040
2041 bool HasRudder() { return false; }
2042 bool HasZ() { return false; }
2043 bool HasU() { return false; }
2044 bool HasV() { return false; }
2045 bool HasPOV() { return false; }
2046 bool HasPOV4Dir() { return false; }
2047 bool HasPOVCTS() { return false; }
2048
2049 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2050 bool ReleaseCapture() { return false; }
2051 };
2052 #endif
2053
2054
2055 #include <wx/sound.h>
2056
2057
2058 #if !wxUSE_SOUND
2059 // A C++ stub class for wxWave for platforms that don't have it.
2060 class wxSound : public wxObject
2061 {
2062 public:
2063 wxSound() {
2064 bool blocked = wxPyBeginBlockThreads();
2065 PyErr_SetString(PyExc_NotImplementedError,
2066 "wxSound is not available on this platform.");
2067 wxPyEndBlockThreads(blocked);
2068 }
2069 wxSound(const wxString&/*, bool*/) {
2070 bool blocked = wxPyBeginBlockThreads();
2071 PyErr_SetString(PyExc_NotImplementedError,
2072 "wxSound is not available on this platform.");
2073 wxPyEndBlockThreads(blocked);
2074 }
2075 wxSound(int, const wxByte*) {
2076 bool blocked = wxPyBeginBlockThreads();
2077 PyErr_SetString(PyExc_NotImplementedError,
2078 "wxSound is not available on this platform.");
2079 wxPyEndBlockThreads(blocked);
2080 }
2081
2082 ~wxSound() {};
2083
2084 bool Create(const wxString&/*, bool*/) { return false; }
2085 bool Create(int, const wxByte*) { return false; };
2086 bool IsOk() { return false; };
2087 bool Play(unsigned) const { return false; }
2088 static bool Play(const wxString&, unsigned) { return false; }
2089 static void Stop() {}
2090 };
2091
2092 #endif
2093
2094 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2095 if (fileName.Length() == 0)
2096 return new wxSound;
2097 else
2098 return new wxSound(fileName);
2099 }
2100 static wxSound *new_wxSound(PyObject *data){
2101 unsigned char* buffer; int size;
2102 wxSound *sound = NULL;
2103
2104 bool blocked = wxPyBeginBlockThreads();
2105 if (!PyArg_Parse(data, "t#", &buffer, &size))
2106 goto done;
2107 sound = new wxSound(size, buffer);
2108 done:
2109 wxPyEndBlockThreads(blocked);
2110 return sound;
2111 }
2112 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2113 #ifndef __WXMAC__
2114 unsigned char* buffer;
2115 int size;
2116 bool rv = false;
2117
2118 bool blocked = wxPyBeginBlockThreads();
2119 if (!PyArg_Parse(data, "t#", &buffer, &size))
2120 goto done;
2121 rv = self->Create(size, buffer);
2122 done:
2123 wxPyEndBlockThreads(blocked);
2124 return rv;
2125 #else
2126 bool blocked = wxPyBeginBlockThreads();
2127 PyErr_SetString(PyExc_NotImplementedError,
2128 "Create from data is not available on this platform.");
2129 wxPyEndBlockThreads(blocked);
2130 return false;
2131 #endif
2132 }
2133
2134 #include <wx/mimetype.h>
2135
2136 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2137 wxString str;
2138 if (self->GetMimeType(&str))
2139 return wx2PyString(str);
2140 else
2141 RETURN_NONE();
2142 }
2143 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2144 wxArrayString arr;
2145 if (self->GetMimeTypes(arr))
2146 return wxArrayString2PyList_helper(arr);
2147 else
2148 RETURN_NONE();
2149 }
2150 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2151 wxArrayString arr;
2152 if (self->GetExtensions(arr))
2153 return wxArrayString2PyList_helper(arr);
2154 else
2155 RETURN_NONE();
2156 }
2157 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2158 wxIconLocation loc;
2159 if (self->GetIcon(&loc))
2160 return new wxIcon(loc);
2161 else
2162 return NULL;
2163 }
2164 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2165 wxIconLocation loc;
2166 if (self->GetIcon(&loc)) {
2167 wxString iconFile = loc.GetFileName();
2168 int iconIndex = -1;
2169
2170 iconIndex = loc.GetIndex();
2171
2172 // Make a tuple and put the values in it
2173 bool blocked = wxPyBeginBlockThreads();
2174 PyObject* tuple = PyTuple_New(3);
2175 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2176 wxT("wxIcon"), true));
2177 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2178 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2179 wxPyEndBlockThreads(blocked);
2180 return tuple;
2181 }
2182 else
2183 RETURN_NONE();
2184 }
2185 static PyObject *wxFileType_GetDescription(wxFileType *self){
2186 wxString str;
2187 if (self->GetDescription(&str))
2188 return wx2PyString(str);
2189 else
2190 RETURN_NONE();
2191 }
2192 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2193 wxString str;
2194 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2195 return wx2PyString(str);
2196 else
2197 RETURN_NONE();
2198 }
2199 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2200 wxString str;
2201 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2202 return wx2PyString(str);
2203 else
2204 RETURN_NONE();
2205 }
2206 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2207 wxArrayString verbs;
2208 wxArrayString commands;
2209 if (self->GetAllCommands(&verbs, &commands,
2210 wxFileType::MessageParameters(filename, mimetype))) {
2211 bool blocked = wxPyBeginBlockThreads();
2212 PyObject* tuple = PyTuple_New(2);
2213 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2214 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2215 wxPyEndBlockThreads(blocked);
2216 return tuple;
2217 }
2218 else
2219 RETURN_NONE();
2220 }
2221 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2222 return wxFileType::ExpandCommand(command,
2223 wxFileType::MessageParameters(filename, mimetype));
2224 }
2225 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2226 wxArrayString arr;
2227 self->EnumAllFileTypes(arr);
2228 return wxArrayString2PyList_helper(arr);
2229 }
2230
2231 #include <wx/artprov.h>
2232
2233 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2234 static const wxString wxPyART_MENU(wxART_MENU);
2235 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2236 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2237 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2238 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2239 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2240 static const wxString wxPyART_OTHER(wxART_OTHER);
2241 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2242 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2243 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2244 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2245 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2246 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2247 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2248 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2249 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2250 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2251 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2252 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2253 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2254 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2255 static const wxString wxPyART_PRINT(wxART_PRINT);
2256 static const wxString wxPyART_HELP(wxART_HELP);
2257 static const wxString wxPyART_TIP(wxART_TIP);
2258 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2259 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2260 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2261 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2262 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2263 static const wxString wxPyART_CDROM(wxART_CDROM);
2264 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2265 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2266 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2267 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2268 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2269 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2270 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2271 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2272 static const wxString wxPyART_ERROR(wxART_ERROR);
2273 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2274 static const wxString wxPyART_WARNING(wxART_WARNING);
2275 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2276 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2277 // Python aware wxArtProvider
2278 class wxPyArtProvider : public wxArtProvider {
2279 public:
2280
2281 virtual wxBitmap CreateBitmap(const wxArtID& id,
2282 const wxArtClient& client,
2283 const wxSize& size) {
2284 wxBitmap rval = wxNullBitmap;
2285 bool blocked = wxPyBeginBlockThreads();
2286 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2287 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2288 PyObject* ro;
2289 wxBitmap* ptr;
2290 PyObject* s1, *s2;
2291 s1 = wx2PyString(id);
2292 s2 = wx2PyString(client);
2293 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2294 Py_DECREF(so);
2295 Py_DECREF(s1);
2296 Py_DECREF(s2);
2297 if (ro) {
2298 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2299 rval = *ptr;
2300 Py_DECREF(ro);
2301 }
2302 }
2303 wxPyEndBlockThreads(blocked);
2304 return rval;
2305 }
2306
2307 PYPRIVATE;
2308 };
2309
2310 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2311
2312
2313
2314 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2315 PyObject* ret = PyTuple_New(3);
2316 if (ret) {
2317 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2318 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2319 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2320 }
2321 return ret;
2322 }
2323
2324 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2325 bool cont;
2326 long index = 0;
2327 wxString value;
2328
2329 cont = self->GetFirstGroup(value, index);
2330 return __EnumerationHelper(cont, value, index);
2331 }
2332 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2333 bool cont;
2334 wxString value;
2335
2336 cont = self->GetNextGroup(value, index);
2337 return __EnumerationHelper(cont, value, index);
2338 }
2339 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2340 bool cont;
2341 long index = 0;
2342 wxString value;
2343
2344 cont = self->GetFirstEntry(value, index);
2345 return __EnumerationHelper(cont, value, index);
2346 }
2347 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2348 bool cont;
2349 wxString value;
2350
2351 cont = self->GetNextEntry(value, index);
2352 return __EnumerationHelper(cont, value, index);
2353 }
2354 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2355 long rv;
2356 self->Read(key, &rv, defaultVal);
2357 return rv;
2358 }
2359
2360 SWIGINTERN int
2361 SWIG_AsVal_double(PyObject *obj, double* val)
2362 {
2363 if (PyNumber_Check(obj)) {
2364 if (val) *val = PyFloat_AsDouble(obj);
2365 return 1;
2366 }
2367 else {
2368 SWIG_type_error("number", obj);
2369 }
2370 return 0;
2371 }
2372
2373
2374 SWIGINTERNSHORT double
2375 SWIG_As_double(PyObject* obj)
2376 {
2377 double v;
2378 if (!SWIG_AsVal_double(obj, &v)) {
2379 /*
2380 this is needed to make valgrind/purify happier.
2381 */
2382 memset((void*)&v, 0, sizeof(double));
2383 }
2384 return v;
2385 }
2386
2387
2388 SWIGINTERNSHORT int
2389 SWIG_Check_double(PyObject* obj)
2390 {
2391 return SWIG_AsVal_double(obj, (double*)0);
2392 }
2393
2394 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2395 double rv;
2396 self->Read(key, &rv, defaultVal);
2397 return rv;
2398 }
2399
2400 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2401 #define SWIG_From_double PyFloat_FromDouble
2402 /*@@*/
2403
2404 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2405 bool rv;
2406 self->Read(key, &rv, defaultVal);
2407 return rv;
2408 }
2409
2410 #include <wx/datetime.h>
2411
2412
2413 static const wxString wxPyDateFormatStr(wxT("%c"));
2414 static const wxString wxPyTimeSpanFormatStr(wxT("%H:%M:%S"));
2415
2416 #define LOCAL_TZ wxDateTime::Local
2417
2418
2419 #if UINT_MAX < LONG_MAX
2420 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2421 #define SWIG_From_unsigned_SS_int SWIG_From_long
2422 /*@@*/
2423 #else
2424 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2425 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2426 /*@@*/
2427 #endif
2428
2429 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2430 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2431 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2432 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2433 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2434 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2435 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2436 return (*self < *other);
2437 }
2438 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2439 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2440 return (*self <= *other);
2441 }
2442 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2443 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2444 return (*self > *other);
2445 }
2446 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2447 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2448 return (*self >= *other);
2449 }
2450 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2451 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2452 return (*self == *other);
2453 }
2454 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2455 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2456 return (*self != *other);
2457 }
2458 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2459 const wxChar* rv;
2460 const wxChar* _date = date;
2461 rv = self->ParseRfc822Date(_date);
2462 if (rv == NULL) return -1;
2463 return rv - _date;
2464 }
2465 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDateFormatStr,wxDateTime const &dateDef=wxDefaultDateTime){
2466 const wxChar* rv;
2467 const wxChar* _date = date;
2468 rv = self->ParseFormat(_date, format, dateDef);
2469 if (rv == NULL) return -1;
2470 return rv - _date;
2471 }
2472 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2473 const wxChar* rv;
2474 const wxChar* _datetime = datetime;
2475 rv = self->ParseDateTime(_datetime);
2476 if (rv == NULL) return -1;
2477 return rv - _datetime;
2478 }
2479 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2480 const wxChar* rv;
2481 const wxChar* _date = date;
2482 rv = self->ParseDate(_date);
2483 if (rv == NULL) return -1;
2484 return rv - _date;
2485 }
2486 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2487 const wxChar* rv;
2488 const wxChar* _time = time;
2489 rv = self->ParseTime(_time);
2490 if (rv == NULL) return -1;
2491 return rv - _time;
2492 }
2493 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2494 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2495 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2496 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2497 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2498 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2499 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2500 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2501 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2502 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2503 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2504 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2505 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2506 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2507 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2508 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2509
2510 #include <wx/dataobj.h>
2511
2512 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2513 size_t count = self->GetFormatCount(dir);
2514 wxDataFormat* formats = new wxDataFormat[count];
2515 self->GetAllFormats(formats, dir);
2516
2517 bool blocked = wxPyBeginBlockThreads();
2518 PyObject* list = PyList_New(count);
2519 for (size_t i=0; i<count; i++) {
2520 wxDataFormat* format = new wxDataFormat(formats[i]);
2521 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2522 PyList_Append(list, obj);
2523 Py_DECREF(obj);
2524 }
2525 wxPyEndBlockThreads(blocked);
2526 delete [] formats;
2527 return list;
2528 }
2529 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2530 PyObject* rval = NULL;
2531 size_t size = self->GetDataSize(format);
2532 bool blocked = wxPyBeginBlockThreads();
2533 if (size) {
2534 char* buf = new char[size];
2535 if (self->GetDataHere(format, buf))
2536 rval = PyString_FromStringAndSize(buf, size);
2537 delete [] buf;
2538 }
2539 if (! rval) {
2540 rval = Py_None;
2541 Py_INCREF(rval);
2542 }
2543 wxPyEndBlockThreads(blocked);
2544 return rval;
2545 }
2546 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2547 bool rval;
2548 bool blocked = wxPyBeginBlockThreads();
2549 if (PyString_Check(data)) {
2550 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2551 }
2552 else {
2553 // raise a TypeError if not a string
2554 PyErr_SetString(PyExc_TypeError, "String expected.");
2555 rval = false;
2556 }
2557 wxPyEndBlockThreads(blocked);
2558 return rval;
2559 }
2560 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2561 PyObject* rval = NULL;
2562 size_t size = self->GetDataSize();
2563 bool blocked = wxPyBeginBlockThreads();
2564 if (size) {
2565 char* buf = new char[size];
2566 if (self->GetDataHere(buf))
2567 rval = PyString_FromStringAndSize(buf, size);
2568 delete [] buf;
2569 }
2570 if (! rval) {
2571 rval = Py_None;
2572 Py_INCREF(rval);
2573 }
2574 wxPyEndBlockThreads(blocked);
2575 return rval;
2576 }
2577 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2578 bool rval;
2579 bool blocked = wxPyBeginBlockThreads();
2580 if (PyString_Check(data)) {
2581 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2582 }
2583 else {
2584 // raise a TypeError if not a string
2585 PyErr_SetString(PyExc_TypeError, "String expected.");
2586 rval = false;
2587 }
2588 wxPyEndBlockThreads(blocked);
2589 return rval;
2590 }
2591 // Create a new class for wxPython to use
2592 class wxPyDataObjectSimple : public wxDataObjectSimple {
2593 public:
2594 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2595 : wxDataObjectSimple(format) {}
2596
2597 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2598 bool GetDataHere(void *buf) const;
2599 bool SetData(size_t len, const void *buf) const;
2600 PYPRIVATE;
2601 };
2602
2603 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2604
2605 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2606 // We need to get the data for this object and write it to buf. I think
2607 // the best way to do this for wxPython is to have the Python method
2608 // return either a string or None and then act appropriately with the
2609 // C++ version.
2610
2611 bool rval = false;
2612 bool blocked = wxPyBeginBlockThreads();
2613 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2614 PyObject* ro;
2615 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2616 if (ro) {
2617 rval = (ro != Py_None && PyString_Check(ro));
2618 if (rval)
2619 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2620 Py_DECREF(ro);
2621 }
2622 }
2623 wxPyEndBlockThreads(blocked);
2624 return rval;
2625 }
2626
2627 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2628 // For this one we simply need to make a string from buf and len
2629 // and send it to the Python method.
2630 bool rval = false;
2631 bool blocked = wxPyBeginBlockThreads();
2632 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2633 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2634 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2635 Py_DECREF(data);
2636 }
2637 wxPyEndBlockThreads(blocked);
2638 return rval;
2639 }
2640
2641 // Create a new class for wxPython to use
2642 class wxPyTextDataObject : public wxTextDataObject {
2643 public:
2644 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2645 : wxTextDataObject(text) {}
2646
2647 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2648 DEC_PYCALLBACK_STRING__const(GetText);
2649 DEC_PYCALLBACK__STRING(SetText);
2650 PYPRIVATE;
2651 };
2652
2653 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2654 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2655 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2656
2657
2658 // Create a new class for wxPython to use
2659 class wxPyBitmapDataObject : public wxBitmapDataObject {
2660 public:
2661 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2662 : wxBitmapDataObject(bitmap) {}
2663
2664 wxBitmap GetBitmap() const;
2665 void SetBitmap(const wxBitmap& bitmap);
2666 PYPRIVATE;
2667 };
2668
2669 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2670 wxBitmap* rval = &wxNullBitmap;
2671 bool blocked = wxPyBeginBlockThreads();
2672 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2673 PyObject* ro;
2674 wxBitmap* ptr;
2675 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2676 if (ro) {
2677 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2678 rval = ptr;
2679 Py_DECREF(ro);
2680 }
2681 }
2682 wxPyEndBlockThreads(blocked);
2683 return *rval;
2684 }
2685
2686 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2687 bool blocked = wxPyBeginBlockThreads();
2688 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2689 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2690 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2691 Py_DECREF(bo);
2692 }
2693 wxPyEndBlockThreads(blocked);
2694 }
2695
2696 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2697 bool rval;
2698 bool blocked = wxPyBeginBlockThreads();
2699 if (PyString_Check(data)) {
2700 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2701 }
2702 else {
2703 // raise a TypeError if not a string
2704 PyErr_SetString(PyExc_TypeError, "String expected.");
2705 rval = false;
2706 }
2707 wxPyEndBlockThreads(blocked);
2708 return rval;
2709 }
2710 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2711 PyObject* obj;
2712 bool blocked = wxPyBeginBlockThreads();
2713 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2714 wxPyEndBlockThreads(blocked);
2715 return obj;
2716 }
2717
2718 #include <wx/metafile.h>
2719
2720
2721 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2722
2723
2724 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2725 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2726 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2727 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2728 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2729
2730
2731 class wxPyTextDropTarget : public wxTextDropTarget {
2732 public:
2733 wxPyTextDropTarget() {}
2734
2735 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2736
2737 DEC_PYCALLBACK__(OnLeave);
2738 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2739 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2740 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2741 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2742
2743 PYPRIVATE;
2744 };
2745
2746 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2747 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2748 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2749 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2750 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2751 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2752
2753
2754
2755 class wxPyFileDropTarget : public wxFileDropTarget {
2756 public:
2757 wxPyFileDropTarget() {}
2758
2759 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2760
2761 DEC_PYCALLBACK__(OnLeave);
2762 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2763 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2764 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2765 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2766
2767 PYPRIVATE;
2768 };
2769
2770 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2771 const wxArrayString& filenames) {
2772 bool rval = false;
2773 bool blocked = wxPyBeginBlockThreads();
2774 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2775 PyObject* list = wxArrayString2PyList_helper(filenames);
2776 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2777 Py_DECREF(list);
2778 }
2779 wxPyEndBlockThreads(blocked);
2780 return rval;
2781 }
2782
2783
2784
2785 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2786 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2787 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2788 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2789 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2790
2791
2792
2793
2794 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2795
2796 #include <wx/display.h>
2797
2798 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2799 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2800
2801 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2802 #if !wxUSE_DISPLAY
2803 #include <wx/dynarray.h>
2804 #include <wx/vidmode.h>
2805
2806 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2807 #include "wx/arrimpl.cpp"
2808 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2809 const wxVideoMode wxDefaultVideoMode;
2810
2811 class wxDisplay
2812 {
2813 public:
2814 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2815 ~wxDisplay() {}
2816
2817 static size_t GetCount()
2818 { wxPyRaiseNotImplemented(); return 0; }
2819
2820 static int GetFromPoint(const wxPoint& pt)
2821 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2822 static int GetFromWindow(wxWindow *window)
2823 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2824
2825 virtual bool IsOk() const { return false; }
2826 virtual wxRect GetGeometry() const { wxRect r; return r; }
2827 virtual wxString GetName() const { return wxEmptyString; }
2828 bool IsPrimary() const { return false; }
2829
2830 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2831 { wxArrayVideoModes a; return a; }
2832
2833 virtual wxVideoMode GetCurrentMode() const
2834 { return wxDefaultVideoMode; }
2835
2836 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2837 { return false; }
2838
2839 void ResetMode() {}
2840 };
2841 #endif
2842
2843 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2844 PyObject* pyList = NULL;
2845 wxArrayVideoModes arr = self->GetModes(mode);
2846 bool blocked = wxPyBeginBlockThreads();
2847 pyList = PyList_New(0);
2848 for (int i=0; i < arr.GetCount(); i++) {
2849 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2850 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2851 PyList_Append(pyList, pyObj);
2852 Py_DECREF(pyObj);
2853 }
2854 wxPyEndBlockThreads(blocked);
2855 return pyList;
2856 }
2857
2858 #include <wx/stdpaths.h>
2859
2860 static wxStandardPaths *StandardPaths_Get(){
2861 return (wxStandardPaths*) &wxStandardPaths::Get();
2862 }
2863 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2864 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2865 #ifdef __cplusplus
2866 extern "C" {
2867 #endif
2868 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2869 PyObject *resultobj;
2870 wxSystemColour arg1 ;
2871 wxColour result;
2872 PyObject * obj0 = 0 ;
2873 char *kwnames[] = {
2874 (char *) "index", NULL
2875 };
2876
2877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2878 {
2879 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2880 if (SWIG_arg_fail(1)) SWIG_fail;
2881 }
2882 {
2883 if (!wxPyCheckForApp()) SWIG_fail;
2884 PyThreadState* __tstate = wxPyBeginAllowThreads();
2885 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
2886
2887 wxPyEndAllowThreads(__tstate);
2888 if (PyErr_Occurred()) SWIG_fail;
2889 }
2890 {
2891 wxColour * resultptr;
2892 resultptr = new wxColour((wxColour &)(result));
2893 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
2894 }
2895 return resultobj;
2896 fail:
2897 return NULL;
2898 }
2899
2900
2901 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
2902 PyObject *resultobj;
2903 wxSystemFont arg1 ;
2904 wxFont result;
2905 PyObject * obj0 = 0 ;
2906 char *kwnames[] = {
2907 (char *) "index", NULL
2908 };
2909
2910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
2911 {
2912 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
2913 if (SWIG_arg_fail(1)) SWIG_fail;
2914 }
2915 {
2916 if (!wxPyCheckForApp()) SWIG_fail;
2917 PyThreadState* __tstate = wxPyBeginAllowThreads();
2918 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
2919
2920 wxPyEndAllowThreads(__tstate);
2921 if (PyErr_Occurred()) SWIG_fail;
2922 }
2923 {
2924 wxFont * resultptr;
2925 resultptr = new wxFont((wxFont &)(result));
2926 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
2927 }
2928 return resultobj;
2929 fail:
2930 return NULL;
2931 }
2932
2933
2934 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
2935 PyObject *resultobj;
2936 wxSystemMetric arg1 ;
2937 int result;
2938 PyObject * obj0 = 0 ;
2939 char *kwnames[] = {
2940 (char *) "index", NULL
2941 };
2942
2943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
2944 {
2945 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
2946 if (SWIG_arg_fail(1)) SWIG_fail;
2947 }
2948 {
2949 if (!wxPyCheckForApp()) SWIG_fail;
2950 PyThreadState* __tstate = wxPyBeginAllowThreads();
2951 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
2952
2953 wxPyEndAllowThreads(__tstate);
2954 if (PyErr_Occurred()) SWIG_fail;
2955 }
2956 {
2957 resultobj = SWIG_From_int((int)(result));
2958 }
2959 return resultobj;
2960 fail:
2961 return NULL;
2962 }
2963
2964
2965 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
2966 PyObject *resultobj;
2967 wxSystemFeature arg1 ;
2968 bool result;
2969 PyObject * obj0 = 0 ;
2970 char *kwnames[] = {
2971 (char *) "index", NULL
2972 };
2973
2974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
2975 {
2976 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
2977 if (SWIG_arg_fail(1)) SWIG_fail;
2978 }
2979 {
2980 if (!wxPyCheckForApp()) SWIG_fail;
2981 PyThreadState* __tstate = wxPyBeginAllowThreads();
2982 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
2983
2984 wxPyEndAllowThreads(__tstate);
2985 if (PyErr_Occurred()) SWIG_fail;
2986 }
2987 {
2988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2989 }
2990 return resultobj;
2991 fail:
2992 return NULL;
2993 }
2994
2995
2996 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
2997 PyObject *resultobj;
2998 wxSystemScreenType result;
2999 char *kwnames[] = {
3000 NULL
3001 };
3002
3003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3004 {
3005 if (!wxPyCheckForApp()) SWIG_fail;
3006 PyThreadState* __tstate = wxPyBeginAllowThreads();
3007 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3008
3009 wxPyEndAllowThreads(__tstate);
3010 if (PyErr_Occurred()) SWIG_fail;
3011 }
3012 resultobj = SWIG_From_int((result));
3013 return resultobj;
3014 fail:
3015 return NULL;
3016 }
3017
3018
3019 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3020 PyObject *resultobj;
3021 wxSystemScreenType arg1 ;
3022 PyObject * obj0 = 0 ;
3023 char *kwnames[] = {
3024 (char *) "screen", NULL
3025 };
3026
3027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3028 {
3029 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3030 if (SWIG_arg_fail(1)) SWIG_fail;
3031 }
3032 {
3033 if (!wxPyCheckForApp()) SWIG_fail;
3034 PyThreadState* __tstate = wxPyBeginAllowThreads();
3035 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3036
3037 wxPyEndAllowThreads(__tstate);
3038 if (PyErr_Occurred()) SWIG_fail;
3039 }
3040 Py_INCREF(Py_None); resultobj = Py_None;
3041 return resultobj;
3042 fail:
3043 return NULL;
3044 }
3045
3046
3047 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3048 PyObject *obj;
3049 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3050 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3051 Py_INCREF(obj);
3052 return Py_BuildValue((char *)"");
3053 }
3054 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3055 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3056 return 1;
3057 }
3058
3059
3060 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3061 PyObject *pyobj;
3062
3063 {
3064 #if wxUSE_UNICODE
3065 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3066 #else
3067 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3068 #endif
3069 }
3070 return pyobj;
3071 }
3072
3073
3074 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3075 PyObject *resultobj;
3076 wxSystemOptions *result;
3077 char *kwnames[] = {
3078 NULL
3079 };
3080
3081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3082 {
3083 PyThreadState* __tstate = wxPyBeginAllowThreads();
3084 result = (wxSystemOptions *)new wxSystemOptions();
3085
3086 wxPyEndAllowThreads(__tstate);
3087 if (PyErr_Occurred()) SWIG_fail;
3088 }
3089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3090 return resultobj;
3091 fail:
3092 return NULL;
3093 }
3094
3095
3096 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3097 PyObject *resultobj;
3098 wxString *arg1 = 0 ;
3099 wxString *arg2 = 0 ;
3100 bool temp1 = false ;
3101 bool temp2 = false ;
3102 PyObject * obj0 = 0 ;
3103 PyObject * obj1 = 0 ;
3104 char *kwnames[] = {
3105 (char *) "name",(char *) "value", NULL
3106 };
3107
3108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3109 {
3110 arg1 = wxString_in_helper(obj0);
3111 if (arg1 == NULL) SWIG_fail;
3112 temp1 = true;
3113 }
3114 {
3115 arg2 = wxString_in_helper(obj1);
3116 if (arg2 == NULL) SWIG_fail;
3117 temp2 = true;
3118 }
3119 {
3120 PyThreadState* __tstate = wxPyBeginAllowThreads();
3121 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3122
3123 wxPyEndAllowThreads(__tstate);
3124 if (PyErr_Occurred()) SWIG_fail;
3125 }
3126 Py_INCREF(Py_None); resultobj = Py_None;
3127 {
3128 if (temp1)
3129 delete arg1;
3130 }
3131 {
3132 if (temp2)
3133 delete arg2;
3134 }
3135 return resultobj;
3136 fail:
3137 {
3138 if (temp1)
3139 delete arg1;
3140 }
3141 {
3142 if (temp2)
3143 delete arg2;
3144 }
3145 return NULL;
3146 }
3147
3148
3149 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3150 PyObject *resultobj;
3151 wxString *arg1 = 0 ;
3152 int arg2 ;
3153 bool temp1 = false ;
3154 PyObject * obj0 = 0 ;
3155 PyObject * obj1 = 0 ;
3156 char *kwnames[] = {
3157 (char *) "name",(char *) "value", NULL
3158 };
3159
3160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3161 {
3162 arg1 = wxString_in_helper(obj0);
3163 if (arg1 == NULL) SWIG_fail;
3164 temp1 = true;
3165 }
3166 {
3167 arg2 = (int)(SWIG_As_int(obj1));
3168 if (SWIG_arg_fail(2)) SWIG_fail;
3169 }
3170 {
3171 PyThreadState* __tstate = wxPyBeginAllowThreads();
3172 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3173
3174 wxPyEndAllowThreads(__tstate);
3175 if (PyErr_Occurred()) SWIG_fail;
3176 }
3177 Py_INCREF(Py_None); resultobj = Py_None;
3178 {
3179 if (temp1)
3180 delete arg1;
3181 }
3182 return resultobj;
3183 fail:
3184 {
3185 if (temp1)
3186 delete arg1;
3187 }
3188 return NULL;
3189 }
3190
3191
3192 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3193 PyObject *resultobj;
3194 wxString *arg1 = 0 ;
3195 wxString result;
3196 bool temp1 = false ;
3197 PyObject * obj0 = 0 ;
3198 char *kwnames[] = {
3199 (char *) "name", NULL
3200 };
3201
3202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3203 {
3204 arg1 = wxString_in_helper(obj0);
3205 if (arg1 == NULL) SWIG_fail;
3206 temp1 = true;
3207 }
3208 {
3209 PyThreadState* __tstate = wxPyBeginAllowThreads();
3210 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3211
3212 wxPyEndAllowThreads(__tstate);
3213 if (PyErr_Occurred()) SWIG_fail;
3214 }
3215 {
3216 #if wxUSE_UNICODE
3217 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3218 #else
3219 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3220 #endif
3221 }
3222 {
3223 if (temp1)
3224 delete arg1;
3225 }
3226 return resultobj;
3227 fail:
3228 {
3229 if (temp1)
3230 delete arg1;
3231 }
3232 return NULL;
3233 }
3234
3235
3236 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3237 PyObject *resultobj;
3238 wxString *arg1 = 0 ;
3239 int result;
3240 bool temp1 = false ;
3241 PyObject * obj0 = 0 ;
3242 char *kwnames[] = {
3243 (char *) "name", NULL
3244 };
3245
3246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3247 {
3248 arg1 = wxString_in_helper(obj0);
3249 if (arg1 == NULL) SWIG_fail;
3250 temp1 = true;
3251 }
3252 {
3253 PyThreadState* __tstate = wxPyBeginAllowThreads();
3254 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3255
3256 wxPyEndAllowThreads(__tstate);
3257 if (PyErr_Occurred()) SWIG_fail;
3258 }
3259 {
3260 resultobj = SWIG_From_int((int)(result));
3261 }
3262 {
3263 if (temp1)
3264 delete arg1;
3265 }
3266 return resultobj;
3267 fail:
3268 {
3269 if (temp1)
3270 delete arg1;
3271 }
3272 return NULL;
3273 }
3274
3275
3276 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3277 PyObject *resultobj;
3278 wxString *arg1 = 0 ;
3279 bool result;
3280 bool temp1 = false ;
3281 PyObject * obj0 = 0 ;
3282 char *kwnames[] = {
3283 (char *) "name", NULL
3284 };
3285
3286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3287 {
3288 arg1 = wxString_in_helper(obj0);
3289 if (arg1 == NULL) SWIG_fail;
3290 temp1 = true;
3291 }
3292 {
3293 PyThreadState* __tstate = wxPyBeginAllowThreads();
3294 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3295
3296 wxPyEndAllowThreads(__tstate);
3297 if (PyErr_Occurred()) SWIG_fail;
3298 }
3299 {
3300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3301 }
3302 {
3303 if (temp1)
3304 delete arg1;
3305 }
3306 return resultobj;
3307 fail:
3308 {
3309 if (temp1)
3310 delete arg1;
3311 }
3312 return NULL;
3313 }
3314
3315
3316 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3317 PyObject *obj;
3318 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3319 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3320 Py_INCREF(obj);
3321 return Py_BuildValue((char *)"");
3322 }
3323 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3324 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3325 return 1;
3326 }
3327
3328
3329 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3330 PyObject *pyobj;
3331
3332 {
3333 #if wxUSE_UNICODE
3334 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3335 #else
3336 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3337 #endif
3338 }
3339 return pyobj;
3340 }
3341
3342
3343 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3344 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3345 return 1;
3346 }
3347
3348
3349 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3350 PyObject *pyobj;
3351
3352 {
3353 #if wxUSE_UNICODE
3354 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3355 #else
3356 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3357 #endif
3358 }
3359 return pyobj;
3360 }
3361
3362
3363 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3364 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3365 return 1;
3366 }
3367
3368
3369 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3370 PyObject *pyobj;
3371
3372 {
3373 #if wxUSE_UNICODE
3374 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3375 #else
3376 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3377 #endif
3378 }
3379 return pyobj;
3380 }
3381
3382
3383 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3384 PyObject *resultobj;
3385 long result;
3386 char *kwnames[] = {
3387 NULL
3388 };
3389
3390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3391 {
3392 PyThreadState* __tstate = wxPyBeginAllowThreads();
3393 result = (long)wxNewId();
3394
3395 wxPyEndAllowThreads(__tstate);
3396 if (PyErr_Occurred()) SWIG_fail;
3397 }
3398 {
3399 resultobj = SWIG_From_long((long)(result));
3400 }
3401 return resultobj;
3402 fail:
3403 return NULL;
3404 }
3405
3406
3407 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3408 PyObject *resultobj;
3409 long arg1 ;
3410 PyObject * obj0 = 0 ;
3411 char *kwnames[] = {
3412 (char *) "id", NULL
3413 };
3414
3415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3416 {
3417 arg1 = (long)(SWIG_As_long(obj0));
3418 if (SWIG_arg_fail(1)) SWIG_fail;
3419 }
3420 {
3421 PyThreadState* __tstate = wxPyBeginAllowThreads();
3422 wxRegisterId(arg1);
3423
3424 wxPyEndAllowThreads(__tstate);
3425 if (PyErr_Occurred()) SWIG_fail;
3426 }
3427 Py_INCREF(Py_None); resultobj = Py_None;
3428 return resultobj;
3429 fail:
3430 return NULL;
3431 }
3432
3433
3434 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3435 PyObject *resultobj;
3436 long result;
3437 char *kwnames[] = {
3438 NULL
3439 };
3440
3441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3442 {
3443 PyThreadState* __tstate = wxPyBeginAllowThreads();
3444 result = (long)wxGetCurrentId();
3445
3446 wxPyEndAllowThreads(__tstate);
3447 if (PyErr_Occurred()) SWIG_fail;
3448 }
3449 {
3450 resultobj = SWIG_From_long((long)(result));
3451 }
3452 return resultobj;
3453 fail:
3454 return NULL;
3455 }
3456
3457
3458 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3459 PyObject *resultobj;
3460 int arg1 ;
3461 bool result;
3462 PyObject * obj0 = 0 ;
3463 char *kwnames[] = {
3464 (char *) "id", NULL
3465 };
3466
3467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3468 {
3469 arg1 = (int)(SWIG_As_int(obj0));
3470 if (SWIG_arg_fail(1)) SWIG_fail;
3471 }
3472 {
3473 PyThreadState* __tstate = wxPyBeginAllowThreads();
3474 result = (bool)wxIsStockID(arg1);
3475
3476 wxPyEndAllowThreads(__tstate);
3477 if (PyErr_Occurred()) SWIG_fail;
3478 }
3479 {
3480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3481 }
3482 return resultobj;
3483 fail:
3484 return NULL;
3485 }
3486
3487
3488 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3489 PyObject *resultobj;
3490 int arg1 ;
3491 wxString *arg2 = 0 ;
3492 bool result;
3493 bool temp2 = false ;
3494 PyObject * obj0 = 0 ;
3495 PyObject * obj1 = 0 ;
3496 char *kwnames[] = {
3497 (char *) "id",(char *) "label", NULL
3498 };
3499
3500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3501 {
3502 arg1 = (int)(SWIG_As_int(obj0));
3503 if (SWIG_arg_fail(1)) SWIG_fail;
3504 }
3505 {
3506 arg2 = wxString_in_helper(obj1);
3507 if (arg2 == NULL) SWIG_fail;
3508 temp2 = true;
3509 }
3510 {
3511 PyThreadState* __tstate = wxPyBeginAllowThreads();
3512 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3513
3514 wxPyEndAllowThreads(__tstate);
3515 if (PyErr_Occurred()) SWIG_fail;
3516 }
3517 {
3518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3519 }
3520 {
3521 if (temp2)
3522 delete arg2;
3523 }
3524 return resultobj;
3525 fail:
3526 {
3527 if (temp2)
3528 delete arg2;
3529 }
3530 return NULL;
3531 }
3532
3533
3534 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3535 PyObject *resultobj;
3536 int arg1 ;
3537 wxString result;
3538 PyObject * obj0 = 0 ;
3539 char *kwnames[] = {
3540 (char *) "id", NULL
3541 };
3542
3543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetStockLabel",kwnames,&obj0)) goto fail;
3544 {
3545 arg1 = (int)(SWIG_As_int(obj0));
3546 if (SWIG_arg_fail(1)) SWIG_fail;
3547 }
3548 {
3549 PyThreadState* __tstate = wxPyBeginAllowThreads();
3550 result = wxGetStockLabel(arg1);
3551
3552 wxPyEndAllowThreads(__tstate);
3553 if (PyErr_Occurred()) SWIG_fail;
3554 }
3555 {
3556 #if wxUSE_UNICODE
3557 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3558 #else
3559 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3560 #endif
3561 }
3562 return resultobj;
3563 fail:
3564 return NULL;
3565 }
3566
3567
3568 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3569 PyObject *resultobj;
3570 char *kwnames[] = {
3571 NULL
3572 };
3573
3574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3575 {
3576 if (!wxPyCheckForApp()) SWIG_fail;
3577 PyThreadState* __tstate = wxPyBeginAllowThreads();
3578 wxBell();
3579
3580 wxPyEndAllowThreads(__tstate);
3581 if (PyErr_Occurred()) SWIG_fail;
3582 }
3583 Py_INCREF(Py_None); resultobj = Py_None;
3584 return resultobj;
3585 fail:
3586 return NULL;
3587 }
3588
3589
3590 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3591 PyObject *resultobj;
3592 char *kwnames[] = {
3593 NULL
3594 };
3595
3596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3597 {
3598 if (!wxPyCheckForApp()) SWIG_fail;
3599 PyThreadState* __tstate = wxPyBeginAllowThreads();
3600 wxEndBusyCursor();
3601
3602 wxPyEndAllowThreads(__tstate);
3603 if (PyErr_Occurred()) SWIG_fail;
3604 }
3605 Py_INCREF(Py_None); resultobj = Py_None;
3606 return resultobj;
3607 fail:
3608 return NULL;
3609 }
3610
3611
3612 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3613 PyObject *resultobj;
3614 bool arg1 = (bool) true ;
3615 long result;
3616 PyObject * obj0 = 0 ;
3617 char *kwnames[] = {
3618 (char *) "resetTimer", NULL
3619 };
3620
3621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3622 if (obj0) {
3623 {
3624 arg1 = (bool)(SWIG_As_bool(obj0));
3625 if (SWIG_arg_fail(1)) SWIG_fail;
3626 }
3627 }
3628 {
3629 PyThreadState* __tstate = wxPyBeginAllowThreads();
3630 result = (long)wxGetElapsedTime(arg1);
3631
3632 wxPyEndAllowThreads(__tstate);
3633 if (PyErr_Occurred()) SWIG_fail;
3634 }
3635 {
3636 resultobj = SWIG_From_long((long)(result));
3637 }
3638 return resultobj;
3639 fail:
3640 return NULL;
3641 }
3642
3643
3644 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3645 PyObject *resultobj;
3646 int *arg1 = (int *) 0 ;
3647 int *arg2 = (int *) 0 ;
3648 int temp1 ;
3649 int res1 = 0 ;
3650 int temp2 ;
3651 int res2 = 0 ;
3652 char *kwnames[] = {
3653 NULL
3654 };
3655
3656 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3657 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3659 {
3660 if (!wxPyCheckForApp()) SWIG_fail;
3661 PyThreadState* __tstate = wxPyBeginAllowThreads();
3662 wxGetMousePosition(arg1,arg2);
3663
3664 wxPyEndAllowThreads(__tstate);
3665 if (PyErr_Occurred()) SWIG_fail;
3666 }
3667 Py_INCREF(Py_None); resultobj = Py_None;
3668 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3669 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3670 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3671 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3672 return resultobj;
3673 fail:
3674 return NULL;
3675 }
3676
3677
3678 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3679 PyObject *resultobj;
3680 bool result;
3681 char *kwnames[] = {
3682 NULL
3683 };
3684
3685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3686 {
3687 PyThreadState* __tstate = wxPyBeginAllowThreads();
3688 result = (bool)wxIsBusy();
3689
3690 wxPyEndAllowThreads(__tstate);
3691 if (PyErr_Occurred()) SWIG_fail;
3692 }
3693 {
3694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3695 }
3696 return resultobj;
3697 fail:
3698 return NULL;
3699 }
3700
3701
3702 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3703 PyObject *resultobj;
3704 wxString result;
3705 char *kwnames[] = {
3706 NULL
3707 };
3708
3709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3710 {
3711 PyThreadState* __tstate = wxPyBeginAllowThreads();
3712 result = wxNow();
3713
3714 wxPyEndAllowThreads(__tstate);
3715 if (PyErr_Occurred()) SWIG_fail;
3716 }
3717 {
3718 #if wxUSE_UNICODE
3719 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3720 #else
3721 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3722 #endif
3723 }
3724 return resultobj;
3725 fail:
3726 return NULL;
3727 }
3728
3729
3730 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3731 PyObject *resultobj;
3732 wxString const &arg1_defvalue = wxPyEmptyString ;
3733 wxString *arg1 = (wxString *) &arg1_defvalue ;
3734 bool result;
3735 bool temp1 = false ;
3736 PyObject * obj0 = 0 ;
3737 char *kwnames[] = {
3738 (char *) "command", NULL
3739 };
3740
3741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3742 if (obj0) {
3743 {
3744 arg1 = wxString_in_helper(obj0);
3745 if (arg1 == NULL) SWIG_fail;
3746 temp1 = true;
3747 }
3748 }
3749 {
3750 PyThreadState* __tstate = wxPyBeginAllowThreads();
3751 result = (bool)wxShell((wxString const &)*arg1);
3752
3753 wxPyEndAllowThreads(__tstate);
3754 if (PyErr_Occurred()) SWIG_fail;
3755 }
3756 {
3757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3758 }
3759 {
3760 if (temp1)
3761 delete arg1;
3762 }
3763 return resultobj;
3764 fail:
3765 {
3766 if (temp1)
3767 delete arg1;
3768 }
3769 return NULL;
3770 }
3771
3772
3773 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3774 PyObject *resultobj;
3775 char *kwnames[] = {
3776 NULL
3777 };
3778
3779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3780 {
3781 PyThreadState* __tstate = wxPyBeginAllowThreads();
3782 wxStartTimer();
3783
3784 wxPyEndAllowThreads(__tstate);
3785 if (PyErr_Occurred()) SWIG_fail;
3786 }
3787 Py_INCREF(Py_None); resultobj = Py_None;
3788 return resultobj;
3789 fail:
3790 return NULL;
3791 }
3792
3793
3794 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3795 PyObject *resultobj;
3796 int *arg1 = (int *) 0 ;
3797 int *arg2 = (int *) 0 ;
3798 int result;
3799 int temp1 ;
3800 int res1 = 0 ;
3801 int temp2 ;
3802 int res2 = 0 ;
3803 char *kwnames[] = {
3804 NULL
3805 };
3806
3807 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3808 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3810 {
3811 PyThreadState* __tstate = wxPyBeginAllowThreads();
3812 result = (int)wxGetOsVersion(arg1,arg2);
3813
3814 wxPyEndAllowThreads(__tstate);
3815 if (PyErr_Occurred()) SWIG_fail;
3816 }
3817 {
3818 resultobj = SWIG_From_int((int)(result));
3819 }
3820 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3821 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3822 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3823 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3824 return resultobj;
3825 fail:
3826 return NULL;
3827 }
3828
3829
3830 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3831 PyObject *resultobj;
3832 wxString result;
3833 char *kwnames[] = {
3834 NULL
3835 };
3836
3837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3838 {
3839 PyThreadState* __tstate = wxPyBeginAllowThreads();
3840 result = wxGetOsDescription();
3841
3842 wxPyEndAllowThreads(__tstate);
3843 if (PyErr_Occurred()) SWIG_fail;
3844 }
3845 {
3846 #if wxUSE_UNICODE
3847 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3848 #else
3849 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3850 #endif
3851 }
3852 return resultobj;
3853 fail:
3854 return NULL;
3855 }
3856
3857
3858 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3859 PyObject *resultobj;
3860 long result;
3861 char *kwnames[] = {
3862 NULL
3863 };
3864
3865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3866 {
3867 PyThreadState* __tstate = wxPyBeginAllowThreads();
3868 result = (long)wxGetFreeMemory();
3869
3870 wxPyEndAllowThreads(__tstate);
3871 if (PyErr_Occurred()) SWIG_fail;
3872 }
3873 {
3874 resultobj = SWIG_From_long((long)(result));
3875 }
3876 return resultobj;
3877 fail:
3878 return NULL;
3879 }
3880
3881
3882 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
3883 PyObject *resultobj;
3884 wxShutdownFlags arg1 ;
3885 bool result;
3886 PyObject * obj0 = 0 ;
3887 char *kwnames[] = {
3888 (char *) "wFlags", NULL
3889 };
3890
3891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
3892 {
3893 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
3894 if (SWIG_arg_fail(1)) SWIG_fail;
3895 }
3896 {
3897 if (!wxPyCheckForApp()) SWIG_fail;
3898 PyThreadState* __tstate = wxPyBeginAllowThreads();
3899 result = (bool)wxShutdown((wxShutdownFlags )arg1);
3900
3901 wxPyEndAllowThreads(__tstate);
3902 if (PyErr_Occurred()) SWIG_fail;
3903 }
3904 {
3905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3906 }
3907 return resultobj;
3908 fail:
3909 return NULL;
3910 }
3911
3912
3913 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
3914 PyObject *resultobj;
3915 int arg1 ;
3916 PyObject * obj0 = 0 ;
3917 char *kwnames[] = {
3918 (char *) "secs", NULL
3919 };
3920
3921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
3922 {
3923 arg1 = (int)(SWIG_As_int(obj0));
3924 if (SWIG_arg_fail(1)) SWIG_fail;
3925 }
3926 {
3927 PyThreadState* __tstate = wxPyBeginAllowThreads();
3928 wxSleep(arg1);
3929
3930 wxPyEndAllowThreads(__tstate);
3931 if (PyErr_Occurred()) SWIG_fail;
3932 }
3933 Py_INCREF(Py_None); resultobj = Py_None;
3934 return resultobj;
3935 fail:
3936 return NULL;
3937 }
3938
3939
3940 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3941 PyObject *resultobj;
3942 unsigned long arg1 ;
3943 PyObject * obj0 = 0 ;
3944 char *kwnames[] = {
3945 (char *) "milliseconds", NULL
3946 };
3947
3948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
3949 {
3950 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3951 if (SWIG_arg_fail(1)) SWIG_fail;
3952 }
3953 {
3954 PyThreadState* __tstate = wxPyBeginAllowThreads();
3955 wxMilliSleep(arg1);
3956
3957 wxPyEndAllowThreads(__tstate);
3958 if (PyErr_Occurred()) SWIG_fail;
3959 }
3960 Py_INCREF(Py_None); resultobj = Py_None;
3961 return resultobj;
3962 fail:
3963 return NULL;
3964 }
3965
3966
3967 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3968 PyObject *resultobj;
3969 unsigned long arg1 ;
3970 PyObject * obj0 = 0 ;
3971 char *kwnames[] = {
3972 (char *) "microseconds", NULL
3973 };
3974
3975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
3976 {
3977 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3978 if (SWIG_arg_fail(1)) SWIG_fail;
3979 }
3980 {
3981 PyThreadState* __tstate = wxPyBeginAllowThreads();
3982 wxMicroSleep(arg1);
3983
3984 wxPyEndAllowThreads(__tstate);
3985 if (PyErr_Occurred()) SWIG_fail;
3986 }
3987 Py_INCREF(Py_None); resultobj = Py_None;
3988 return resultobj;
3989 fail:
3990 return NULL;
3991 }
3992
3993
3994 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
3995 PyObject *resultobj;
3996 bool arg1 ;
3997 PyObject * obj0 = 0 ;
3998 char *kwnames[] = {
3999 (char *) "enable", NULL
4000 };
4001
4002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4003 {
4004 arg1 = (bool)(SWIG_As_bool(obj0));
4005 if (SWIG_arg_fail(1)) SWIG_fail;
4006 }
4007 {
4008 PyThreadState* __tstate = wxPyBeginAllowThreads();
4009 wxEnableTopLevelWindows(arg1);
4010
4011 wxPyEndAllowThreads(__tstate);
4012 if (PyErr_Occurred()) SWIG_fail;
4013 }
4014 Py_INCREF(Py_None); resultobj = Py_None;
4015 return resultobj;
4016 fail:
4017 return NULL;
4018 }
4019
4020
4021 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4022 PyObject *resultobj;
4023 wxString *arg1 = 0 ;
4024 wxString result;
4025 bool temp1 = false ;
4026 PyObject * obj0 = 0 ;
4027 char *kwnames[] = {
4028 (char *) "in", NULL
4029 };
4030
4031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4032 {
4033 arg1 = wxString_in_helper(obj0);
4034 if (arg1 == NULL) SWIG_fail;
4035 temp1 = true;
4036 }
4037 {
4038 PyThreadState* __tstate = wxPyBeginAllowThreads();
4039 result = wxStripMenuCodes((wxString const &)*arg1);
4040
4041 wxPyEndAllowThreads(__tstate);
4042 if (PyErr_Occurred()) SWIG_fail;
4043 }
4044 {
4045 #if wxUSE_UNICODE
4046 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4047 #else
4048 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4049 #endif
4050 }
4051 {
4052 if (temp1)
4053 delete arg1;
4054 }
4055 return resultobj;
4056 fail:
4057 {
4058 if (temp1)
4059 delete arg1;
4060 }
4061 return NULL;
4062 }
4063
4064
4065 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4066 PyObject *resultobj;
4067 wxString result;
4068 char *kwnames[] = {
4069 NULL
4070 };
4071
4072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4073 {
4074 PyThreadState* __tstate = wxPyBeginAllowThreads();
4075 result = wxGetEmailAddress();
4076
4077 wxPyEndAllowThreads(__tstate);
4078 if (PyErr_Occurred()) SWIG_fail;
4079 }
4080 {
4081 #if wxUSE_UNICODE
4082 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4083 #else
4084 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4085 #endif
4086 }
4087 return resultobj;
4088 fail:
4089 return NULL;
4090 }
4091
4092
4093 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4094 PyObject *resultobj;
4095 wxString result;
4096 char *kwnames[] = {
4097 NULL
4098 };
4099
4100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4101 {
4102 PyThreadState* __tstate = wxPyBeginAllowThreads();
4103 result = wxGetHostName();
4104
4105 wxPyEndAllowThreads(__tstate);
4106 if (PyErr_Occurred()) SWIG_fail;
4107 }
4108 {
4109 #if wxUSE_UNICODE
4110 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4111 #else
4112 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4113 #endif
4114 }
4115 return resultobj;
4116 fail:
4117 return NULL;
4118 }
4119
4120
4121 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4122 PyObject *resultobj;
4123 wxString result;
4124 char *kwnames[] = {
4125 NULL
4126 };
4127
4128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4129 {
4130 PyThreadState* __tstate = wxPyBeginAllowThreads();
4131 result = wxGetFullHostName();
4132
4133 wxPyEndAllowThreads(__tstate);
4134 if (PyErr_Occurred()) SWIG_fail;
4135 }
4136 {
4137 #if wxUSE_UNICODE
4138 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4139 #else
4140 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4141 #endif
4142 }
4143 return resultobj;
4144 fail:
4145 return NULL;
4146 }
4147
4148
4149 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4150 PyObject *resultobj;
4151 wxString result;
4152 char *kwnames[] = {
4153 NULL
4154 };
4155
4156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4157 {
4158 PyThreadState* __tstate = wxPyBeginAllowThreads();
4159 result = wxGetUserId();
4160
4161 wxPyEndAllowThreads(__tstate);
4162 if (PyErr_Occurred()) SWIG_fail;
4163 }
4164 {
4165 #if wxUSE_UNICODE
4166 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4167 #else
4168 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4169 #endif
4170 }
4171 return resultobj;
4172 fail:
4173 return NULL;
4174 }
4175
4176
4177 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4178 PyObject *resultobj;
4179 wxString result;
4180 char *kwnames[] = {
4181 NULL
4182 };
4183
4184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4185 {
4186 PyThreadState* __tstate = wxPyBeginAllowThreads();
4187 result = wxGetUserName();
4188
4189 wxPyEndAllowThreads(__tstate);
4190 if (PyErr_Occurred()) SWIG_fail;
4191 }
4192 {
4193 #if wxUSE_UNICODE
4194 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4195 #else
4196 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4197 #endif
4198 }
4199 return resultobj;
4200 fail:
4201 return NULL;
4202 }
4203
4204
4205 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4206 PyObject *resultobj;
4207 wxString result;
4208 char *kwnames[] = {
4209 NULL
4210 };
4211
4212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4213 {
4214 PyThreadState* __tstate = wxPyBeginAllowThreads();
4215 result = wxGetHomeDir();
4216
4217 wxPyEndAllowThreads(__tstate);
4218 if (PyErr_Occurred()) SWIG_fail;
4219 }
4220 {
4221 #if wxUSE_UNICODE
4222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4223 #else
4224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4225 #endif
4226 }
4227 return resultobj;
4228 fail:
4229 return NULL;
4230 }
4231
4232
4233 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4234 PyObject *resultobj;
4235 wxString const &arg1_defvalue = wxPyEmptyString ;
4236 wxString *arg1 = (wxString *) &arg1_defvalue ;
4237 wxString result;
4238 bool temp1 = false ;
4239 PyObject * obj0 = 0 ;
4240 char *kwnames[] = {
4241 (char *) "user", NULL
4242 };
4243
4244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4245 if (obj0) {
4246 {
4247 arg1 = wxString_in_helper(obj0);
4248 if (arg1 == NULL) SWIG_fail;
4249 temp1 = true;
4250 }
4251 }
4252 {
4253 PyThreadState* __tstate = wxPyBeginAllowThreads();
4254 result = wxGetUserHome((wxString const &)*arg1);
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 {
4267 if (temp1)
4268 delete arg1;
4269 }
4270 return resultobj;
4271 fail:
4272 {
4273 if (temp1)
4274 delete arg1;
4275 }
4276 return NULL;
4277 }
4278
4279
4280 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4281 PyObject *resultobj;
4282 unsigned long result;
4283 char *kwnames[] = {
4284 NULL
4285 };
4286
4287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4288 {
4289 PyThreadState* __tstate = wxPyBeginAllowThreads();
4290 result = (unsigned long)wxGetProcessId();
4291
4292 wxPyEndAllowThreads(__tstate);
4293 if (PyErr_Occurred()) SWIG_fail;
4294 }
4295 {
4296 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4297 }
4298 return resultobj;
4299 fail:
4300 return NULL;
4301 }
4302
4303
4304 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4305 PyObject *resultobj;
4306 char *kwnames[] = {
4307 NULL
4308 };
4309
4310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4311 {
4312 PyThreadState* __tstate = wxPyBeginAllowThreads();
4313 wxTrap();
4314
4315 wxPyEndAllowThreads(__tstate);
4316 if (PyErr_Occurred()) SWIG_fail;
4317 }
4318 Py_INCREF(Py_None); resultobj = Py_None;
4319 return resultobj;
4320 fail:
4321 return NULL;
4322 }
4323
4324
4325 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4326 PyObject *resultobj;
4327 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4328 wxString *arg1 = (wxString *) &arg1_defvalue ;
4329 wxString const &arg2_defvalue = wxPyEmptyString ;
4330 wxString *arg2 = (wxString *) &arg2_defvalue ;
4331 wxString const &arg3_defvalue = wxPyEmptyString ;
4332 wxString *arg3 = (wxString *) &arg3_defvalue ;
4333 wxString const &arg4_defvalue = wxPyEmptyString ;
4334 wxString *arg4 = (wxString *) &arg4_defvalue ;
4335 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4336 wxString *arg5 = (wxString *) &arg5_defvalue ;
4337 int arg6 = (int) 0 ;
4338 wxWindow *arg7 = (wxWindow *) NULL ;
4339 int arg8 = (int) -1 ;
4340 int arg9 = (int) -1 ;
4341 wxString result;
4342 bool temp1 = false ;
4343 bool temp2 = false ;
4344 bool temp3 = false ;
4345 bool temp4 = false ;
4346 bool temp5 = false ;
4347 PyObject * obj0 = 0 ;
4348 PyObject * obj1 = 0 ;
4349 PyObject * obj2 = 0 ;
4350 PyObject * obj3 = 0 ;
4351 PyObject * obj4 = 0 ;
4352 PyObject * obj5 = 0 ;
4353 PyObject * obj6 = 0 ;
4354 PyObject * obj7 = 0 ;
4355 PyObject * obj8 = 0 ;
4356 char *kwnames[] = {
4357 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4358 };
4359
4360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4361 if (obj0) {
4362 {
4363 arg1 = wxString_in_helper(obj0);
4364 if (arg1 == NULL) SWIG_fail;
4365 temp1 = true;
4366 }
4367 }
4368 if (obj1) {
4369 {
4370 arg2 = wxString_in_helper(obj1);
4371 if (arg2 == NULL) SWIG_fail;
4372 temp2 = true;
4373 }
4374 }
4375 if (obj2) {
4376 {
4377 arg3 = wxString_in_helper(obj2);
4378 if (arg3 == NULL) SWIG_fail;
4379 temp3 = true;
4380 }
4381 }
4382 if (obj3) {
4383 {
4384 arg4 = wxString_in_helper(obj3);
4385 if (arg4 == NULL) SWIG_fail;
4386 temp4 = true;
4387 }
4388 }
4389 if (obj4) {
4390 {
4391 arg5 = wxString_in_helper(obj4);
4392 if (arg5 == NULL) SWIG_fail;
4393 temp5 = true;
4394 }
4395 }
4396 if (obj5) {
4397 {
4398 arg6 = (int)(SWIG_As_int(obj5));
4399 if (SWIG_arg_fail(6)) SWIG_fail;
4400 }
4401 }
4402 if (obj6) {
4403 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4404 if (SWIG_arg_fail(7)) SWIG_fail;
4405 }
4406 if (obj7) {
4407 {
4408 arg8 = (int)(SWIG_As_int(obj7));
4409 if (SWIG_arg_fail(8)) SWIG_fail;
4410 }
4411 }
4412 if (obj8) {
4413 {
4414 arg9 = (int)(SWIG_As_int(obj8));
4415 if (SWIG_arg_fail(9)) SWIG_fail;
4416 }
4417 }
4418 {
4419 if (!wxPyCheckForApp()) SWIG_fail;
4420 PyThreadState* __tstate = wxPyBeginAllowThreads();
4421 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4422
4423 wxPyEndAllowThreads(__tstate);
4424 if (PyErr_Occurred()) SWIG_fail;
4425 }
4426 {
4427 #if wxUSE_UNICODE
4428 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4429 #else
4430 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4431 #endif
4432 }
4433 {
4434 if (temp1)
4435 delete arg1;
4436 }
4437 {
4438 if (temp2)
4439 delete arg2;
4440 }
4441 {
4442 if (temp3)
4443 delete arg3;
4444 }
4445 {
4446 if (temp4)
4447 delete arg4;
4448 }
4449 {
4450 if (temp5)
4451 delete arg5;
4452 }
4453 return resultobj;
4454 fail:
4455 {
4456 if (temp1)
4457 delete arg1;
4458 }
4459 {
4460 if (temp2)
4461 delete arg2;
4462 }
4463 {
4464 if (temp3)
4465 delete arg3;
4466 }
4467 {
4468 if (temp4)
4469 delete arg4;
4470 }
4471 {
4472 if (temp5)
4473 delete arg5;
4474 }
4475 return NULL;
4476 }
4477
4478
4479 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4480 PyObject *resultobj;
4481 wxString *arg1 = 0 ;
4482 wxString *arg2 = 0 ;
4483 wxString const &arg3_defvalue = wxPyEmptyString ;
4484 wxString *arg3 = (wxString *) &arg3_defvalue ;
4485 wxWindow *arg4 = (wxWindow *) NULL ;
4486 wxString result;
4487 bool temp1 = false ;
4488 bool temp2 = false ;
4489 bool temp3 = false ;
4490 PyObject * obj0 = 0 ;
4491 PyObject * obj1 = 0 ;
4492 PyObject * obj2 = 0 ;
4493 PyObject * obj3 = 0 ;
4494 char *kwnames[] = {
4495 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4496 };
4497
4498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4499 {
4500 arg1 = wxString_in_helper(obj0);
4501 if (arg1 == NULL) SWIG_fail;
4502 temp1 = true;
4503 }
4504 {
4505 arg2 = wxString_in_helper(obj1);
4506 if (arg2 == NULL) SWIG_fail;
4507 temp2 = true;
4508 }
4509 if (obj2) {
4510 {
4511 arg3 = wxString_in_helper(obj2);
4512 if (arg3 == NULL) SWIG_fail;
4513 temp3 = true;
4514 }
4515 }
4516 if (obj3) {
4517 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4518 if (SWIG_arg_fail(4)) SWIG_fail;
4519 }
4520 {
4521 if (!wxPyCheckForApp()) SWIG_fail;
4522 PyThreadState* __tstate = wxPyBeginAllowThreads();
4523 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4524
4525 wxPyEndAllowThreads(__tstate);
4526 if (PyErr_Occurred()) SWIG_fail;
4527 }
4528 {
4529 #if wxUSE_UNICODE
4530 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4531 #else
4532 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4533 #endif
4534 }
4535 {
4536 if (temp1)
4537 delete arg1;
4538 }
4539 {
4540 if (temp2)
4541 delete arg2;
4542 }
4543 {
4544 if (temp3)
4545 delete arg3;
4546 }
4547 return resultobj;
4548 fail:
4549 {
4550 if (temp1)
4551 delete arg1;
4552 }
4553 {
4554 if (temp2)
4555 delete arg2;
4556 }
4557 {
4558 if (temp3)
4559 delete arg3;
4560 }
4561 return NULL;
4562 }
4563
4564
4565 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4566 PyObject *resultobj;
4567 wxString *arg1 = 0 ;
4568 wxString *arg2 = 0 ;
4569 wxString const &arg3_defvalue = wxPyEmptyString ;
4570 wxString *arg3 = (wxString *) &arg3_defvalue ;
4571 wxWindow *arg4 = (wxWindow *) NULL ;
4572 wxString result;
4573 bool temp1 = false ;
4574 bool temp2 = false ;
4575 bool temp3 = false ;
4576 PyObject * obj0 = 0 ;
4577 PyObject * obj1 = 0 ;
4578 PyObject * obj2 = 0 ;
4579 PyObject * obj3 = 0 ;
4580 char *kwnames[] = {
4581 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4582 };
4583
4584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4585 {
4586 arg1 = wxString_in_helper(obj0);
4587 if (arg1 == NULL) SWIG_fail;
4588 temp1 = true;
4589 }
4590 {
4591 arg2 = wxString_in_helper(obj1);
4592 if (arg2 == NULL) SWIG_fail;
4593 temp2 = true;
4594 }
4595 if (obj2) {
4596 {
4597 arg3 = wxString_in_helper(obj2);
4598 if (arg3 == NULL) SWIG_fail;
4599 temp3 = true;
4600 }
4601 }
4602 if (obj3) {
4603 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4604 if (SWIG_arg_fail(4)) SWIG_fail;
4605 }
4606 {
4607 if (!wxPyCheckForApp()) SWIG_fail;
4608 PyThreadState* __tstate = wxPyBeginAllowThreads();
4609 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4610
4611 wxPyEndAllowThreads(__tstate);
4612 if (PyErr_Occurred()) SWIG_fail;
4613 }
4614 {
4615 #if wxUSE_UNICODE
4616 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4617 #else
4618 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4619 #endif
4620 }
4621 {
4622 if (temp1)
4623 delete arg1;
4624 }
4625 {
4626 if (temp2)
4627 delete arg2;
4628 }
4629 {
4630 if (temp3)
4631 delete arg3;
4632 }
4633 return resultobj;
4634 fail:
4635 {
4636 if (temp1)
4637 delete arg1;
4638 }
4639 {
4640 if (temp2)
4641 delete arg2;
4642 }
4643 {
4644 if (temp3)
4645 delete arg3;
4646 }
4647 return NULL;
4648 }
4649
4650
4651 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4652 PyObject *resultobj;
4653 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4654 wxString *arg1 = (wxString *) &arg1_defvalue ;
4655 wxString const &arg2_defvalue = wxPyEmptyString ;
4656 wxString *arg2 = (wxString *) &arg2_defvalue ;
4657 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4658 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4659 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4660 wxWindow *arg5 = (wxWindow *) NULL ;
4661 wxString result;
4662 bool temp1 = false ;
4663 bool temp2 = false ;
4664 wxPoint temp4 ;
4665 PyObject * obj0 = 0 ;
4666 PyObject * obj1 = 0 ;
4667 PyObject * obj2 = 0 ;
4668 PyObject * obj3 = 0 ;
4669 PyObject * obj4 = 0 ;
4670 char *kwnames[] = {
4671 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4672 };
4673
4674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4675 if (obj0) {
4676 {
4677 arg1 = wxString_in_helper(obj0);
4678 if (arg1 == NULL) SWIG_fail;
4679 temp1 = true;
4680 }
4681 }
4682 if (obj1) {
4683 {
4684 arg2 = wxString_in_helper(obj1);
4685 if (arg2 == NULL) SWIG_fail;
4686 temp2 = true;
4687 }
4688 }
4689 if (obj2) {
4690 {
4691 arg3 = (long)(SWIG_As_long(obj2));
4692 if (SWIG_arg_fail(3)) SWIG_fail;
4693 }
4694 }
4695 if (obj3) {
4696 {
4697 arg4 = &temp4;
4698 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4699 }
4700 }
4701 if (obj4) {
4702 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4703 if (SWIG_arg_fail(5)) SWIG_fail;
4704 }
4705 {
4706 if (!wxPyCheckForApp()) SWIG_fail;
4707 PyThreadState* __tstate = wxPyBeginAllowThreads();
4708 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4709
4710 wxPyEndAllowThreads(__tstate);
4711 if (PyErr_Occurred()) SWIG_fail;
4712 }
4713 {
4714 #if wxUSE_UNICODE
4715 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4716 #else
4717 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4718 #endif
4719 }
4720 {
4721 if (temp1)
4722 delete arg1;
4723 }
4724 {
4725 if (temp2)
4726 delete arg2;
4727 }
4728 return resultobj;
4729 fail:
4730 {
4731 if (temp1)
4732 delete arg1;
4733 }
4734 {
4735 if (temp2)
4736 delete arg2;
4737 }
4738 return NULL;
4739 }
4740
4741
4742 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4743 PyObject *resultobj;
4744 wxString *arg1 = 0 ;
4745 wxString const &arg2_defvalue = wxPyEmptyString ;
4746 wxString *arg2 = (wxString *) &arg2_defvalue ;
4747 wxString const &arg3_defvalue = wxPyEmptyString ;
4748 wxString *arg3 = (wxString *) &arg3_defvalue ;
4749 wxWindow *arg4 = (wxWindow *) NULL ;
4750 int arg5 = (int) -1 ;
4751 int arg6 = (int) -1 ;
4752 bool arg7 = (bool) true ;
4753 wxString result;
4754 bool temp1 = false ;
4755 bool temp2 = false ;
4756 bool temp3 = false ;
4757 PyObject * obj0 = 0 ;
4758 PyObject * obj1 = 0 ;
4759 PyObject * obj2 = 0 ;
4760 PyObject * obj3 = 0 ;
4761 PyObject * obj4 = 0 ;
4762 PyObject * obj5 = 0 ;
4763 PyObject * obj6 = 0 ;
4764 char *kwnames[] = {
4765 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4766 };
4767
4768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4769 {
4770 arg1 = wxString_in_helper(obj0);
4771 if (arg1 == NULL) SWIG_fail;
4772 temp1 = true;
4773 }
4774 if (obj1) {
4775 {
4776 arg2 = wxString_in_helper(obj1);
4777 if (arg2 == NULL) SWIG_fail;
4778 temp2 = true;
4779 }
4780 }
4781 if (obj2) {
4782 {
4783 arg3 = wxString_in_helper(obj2);
4784 if (arg3 == NULL) SWIG_fail;
4785 temp3 = true;
4786 }
4787 }
4788 if (obj3) {
4789 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4790 if (SWIG_arg_fail(4)) SWIG_fail;
4791 }
4792 if (obj4) {
4793 {
4794 arg5 = (int)(SWIG_As_int(obj4));
4795 if (SWIG_arg_fail(5)) SWIG_fail;
4796 }
4797 }
4798 if (obj5) {
4799 {
4800 arg6 = (int)(SWIG_As_int(obj5));
4801 if (SWIG_arg_fail(6)) SWIG_fail;
4802 }
4803 }
4804 if (obj6) {
4805 {
4806 arg7 = (bool)(SWIG_As_bool(obj6));
4807 if (SWIG_arg_fail(7)) SWIG_fail;
4808 }
4809 }
4810 {
4811 if (!wxPyCheckForApp()) SWIG_fail;
4812 PyThreadState* __tstate = wxPyBeginAllowThreads();
4813 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4814
4815 wxPyEndAllowThreads(__tstate);
4816 if (PyErr_Occurred()) SWIG_fail;
4817 }
4818 {
4819 #if wxUSE_UNICODE
4820 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4821 #else
4822 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4823 #endif
4824 }
4825 {
4826 if (temp1)
4827 delete arg1;
4828 }
4829 {
4830 if (temp2)
4831 delete arg2;
4832 }
4833 {
4834 if (temp3)
4835 delete arg3;
4836 }
4837 return resultobj;
4838 fail:
4839 {
4840 if (temp1)
4841 delete arg1;
4842 }
4843 {
4844 if (temp2)
4845 delete arg2;
4846 }
4847 {
4848 if (temp3)
4849 delete arg3;
4850 }
4851 return NULL;
4852 }
4853
4854
4855 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4856 PyObject *resultobj;
4857 wxString *arg1 = 0 ;
4858 wxString const &arg2_defvalue = wxPyEmptyString ;
4859 wxString *arg2 = (wxString *) &arg2_defvalue ;
4860 wxString const &arg3_defvalue = wxPyEmptyString ;
4861 wxString *arg3 = (wxString *) &arg3_defvalue ;
4862 wxWindow *arg4 = (wxWindow *) NULL ;
4863 wxString result;
4864 bool temp1 = false ;
4865 bool temp2 = false ;
4866 bool temp3 = false ;
4867 PyObject * obj0 = 0 ;
4868 PyObject * obj1 = 0 ;
4869 PyObject * obj2 = 0 ;
4870 PyObject * obj3 = 0 ;
4871 char *kwnames[] = {
4872 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
4873 };
4874
4875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4876 {
4877 arg1 = wxString_in_helper(obj0);
4878 if (arg1 == NULL) SWIG_fail;
4879 temp1 = true;
4880 }
4881 if (obj1) {
4882 {
4883 arg2 = wxString_in_helper(obj1);
4884 if (arg2 == NULL) SWIG_fail;
4885 temp2 = true;
4886 }
4887 }
4888 if (obj2) {
4889 {
4890 arg3 = wxString_in_helper(obj2);
4891 if (arg3 == NULL) SWIG_fail;
4892 temp3 = true;
4893 }
4894 }
4895 if (obj3) {
4896 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4897 if (SWIG_arg_fail(4)) SWIG_fail;
4898 }
4899 {
4900 if (!wxPyCheckForApp()) SWIG_fail;
4901 PyThreadState* __tstate = wxPyBeginAllowThreads();
4902 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4903
4904 wxPyEndAllowThreads(__tstate);
4905 if (PyErr_Occurred()) SWIG_fail;
4906 }
4907 {
4908 #if wxUSE_UNICODE
4909 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4910 #else
4911 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4912 #endif
4913 }
4914 {
4915 if (temp1)
4916 delete arg1;
4917 }
4918 {
4919 if (temp2)
4920 delete arg2;
4921 }
4922 {
4923 if (temp3)
4924 delete arg3;
4925 }
4926 return resultobj;
4927 fail:
4928 {
4929 if (temp1)
4930 delete arg1;
4931 }
4932 {
4933 if (temp2)
4934 delete arg2;
4935 }
4936 {
4937 if (temp3)
4938 delete arg3;
4939 }
4940 return NULL;
4941 }
4942
4943
4944 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
4945 PyObject *resultobj;
4946 wxString *arg1 = 0 ;
4947 wxString *arg2 = 0 ;
4948 int arg3 ;
4949 wxString *arg4 = (wxString *) 0 ;
4950 wxWindow *arg5 = (wxWindow *) NULL ;
4951 int arg6 = (int) -1 ;
4952 int arg7 = (int) -1 ;
4953 bool arg8 = (bool) true ;
4954 int arg9 = (int) 150 ;
4955 int arg10 = (int) 200 ;
4956 wxString result;
4957 bool temp1 = false ;
4958 bool temp2 = false ;
4959 PyObject * obj0 = 0 ;
4960 PyObject * obj1 = 0 ;
4961 PyObject * obj2 = 0 ;
4962 PyObject * obj3 = 0 ;
4963 PyObject * obj4 = 0 ;
4964 PyObject * obj5 = 0 ;
4965 PyObject * obj6 = 0 ;
4966 PyObject * obj7 = 0 ;
4967 PyObject * obj8 = 0 ;
4968 char *kwnames[] = {
4969 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
4970 };
4971
4972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4973 {
4974 arg1 = wxString_in_helper(obj0);
4975 if (arg1 == NULL) SWIG_fail;
4976 temp1 = true;
4977 }
4978 {
4979 arg2 = wxString_in_helper(obj1);
4980 if (arg2 == NULL) SWIG_fail;
4981 temp2 = true;
4982 }
4983 {
4984 arg3 = PyList_Size(obj2);
4985 arg4 = wxString_LIST_helper(obj2);
4986 if (arg4 == NULL) SWIG_fail;
4987 }
4988 if (obj3) {
4989 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4990 if (SWIG_arg_fail(5)) SWIG_fail;
4991 }
4992 if (obj4) {
4993 {
4994 arg6 = (int)(SWIG_As_int(obj4));
4995 if (SWIG_arg_fail(6)) SWIG_fail;
4996 }
4997 }
4998 if (obj5) {
4999 {
5000 arg7 = (int)(SWIG_As_int(obj5));
5001 if (SWIG_arg_fail(7)) SWIG_fail;
5002 }
5003 }
5004 if (obj6) {
5005 {
5006 arg8 = (bool)(SWIG_As_bool(obj6));
5007 if (SWIG_arg_fail(8)) SWIG_fail;
5008 }
5009 }
5010 if (obj7) {
5011 {
5012 arg9 = (int)(SWIG_As_int(obj7));
5013 if (SWIG_arg_fail(9)) SWIG_fail;
5014 }
5015 }
5016 if (obj8) {
5017 {
5018 arg10 = (int)(SWIG_As_int(obj8));
5019 if (SWIG_arg_fail(10)) SWIG_fail;
5020 }
5021 }
5022 {
5023 if (!wxPyCheckForApp()) SWIG_fail;
5024 PyThreadState* __tstate = wxPyBeginAllowThreads();
5025 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5026
5027 wxPyEndAllowThreads(__tstate);
5028 if (PyErr_Occurred()) SWIG_fail;
5029 }
5030 {
5031 #if wxUSE_UNICODE
5032 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5033 #else
5034 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5035 #endif
5036 }
5037 {
5038 if (temp1)
5039 delete arg1;
5040 }
5041 {
5042 if (temp2)
5043 delete arg2;
5044 }
5045 {
5046 if (arg4) delete [] arg4;
5047 }
5048 return resultobj;
5049 fail:
5050 {
5051 if (temp1)
5052 delete arg1;
5053 }
5054 {
5055 if (temp2)
5056 delete arg2;
5057 }
5058 {
5059 if (arg4) delete [] arg4;
5060 }
5061 return NULL;
5062 }
5063
5064
5065 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5066 PyObject *resultobj;
5067 wxString *arg1 = 0 ;
5068 wxString *arg2 = 0 ;
5069 int arg3 ;
5070 wxString *arg4 = (wxString *) 0 ;
5071 wxWindow *arg5 = (wxWindow *) NULL ;
5072 int arg6 = (int) -1 ;
5073 int arg7 = (int) -1 ;
5074 bool arg8 = (bool) true ;
5075 int arg9 = (int) 150 ;
5076 int arg10 = (int) 200 ;
5077 int result;
5078 bool temp1 = false ;
5079 bool temp2 = false ;
5080 PyObject * obj0 = 0 ;
5081 PyObject * obj1 = 0 ;
5082 PyObject * obj2 = 0 ;
5083 PyObject * obj3 = 0 ;
5084 PyObject * obj4 = 0 ;
5085 PyObject * obj5 = 0 ;
5086 PyObject * obj6 = 0 ;
5087 PyObject * obj7 = 0 ;
5088 PyObject * obj8 = 0 ;
5089 char *kwnames[] = {
5090 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5091 };
5092
5093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5094 {
5095 arg1 = wxString_in_helper(obj0);
5096 if (arg1 == NULL) SWIG_fail;
5097 temp1 = true;
5098 }
5099 {
5100 arg2 = wxString_in_helper(obj1);
5101 if (arg2 == NULL) SWIG_fail;
5102 temp2 = true;
5103 }
5104 {
5105 arg3 = PyList_Size(obj2);
5106 arg4 = wxString_LIST_helper(obj2);
5107 if (arg4 == NULL) SWIG_fail;
5108 }
5109 if (obj3) {
5110 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5111 if (SWIG_arg_fail(5)) SWIG_fail;
5112 }
5113 if (obj4) {
5114 {
5115 arg6 = (int)(SWIG_As_int(obj4));
5116 if (SWIG_arg_fail(6)) SWIG_fail;
5117 }
5118 }
5119 if (obj5) {
5120 {
5121 arg7 = (int)(SWIG_As_int(obj5));
5122 if (SWIG_arg_fail(7)) SWIG_fail;
5123 }
5124 }
5125 if (obj6) {
5126 {
5127 arg8 = (bool)(SWIG_As_bool(obj6));
5128 if (SWIG_arg_fail(8)) SWIG_fail;
5129 }
5130 }
5131 if (obj7) {
5132 {
5133 arg9 = (int)(SWIG_As_int(obj7));
5134 if (SWIG_arg_fail(9)) SWIG_fail;
5135 }
5136 }
5137 if (obj8) {
5138 {
5139 arg10 = (int)(SWIG_As_int(obj8));
5140 if (SWIG_arg_fail(10)) SWIG_fail;
5141 }
5142 }
5143 {
5144 if (!wxPyCheckForApp()) SWIG_fail;
5145 PyThreadState* __tstate = wxPyBeginAllowThreads();
5146 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5147
5148 wxPyEndAllowThreads(__tstate);
5149 if (PyErr_Occurred()) SWIG_fail;
5150 }
5151 {
5152 resultobj = SWIG_From_int((int)(result));
5153 }
5154 {
5155 if (temp1)
5156 delete arg1;
5157 }
5158 {
5159 if (temp2)
5160 delete arg2;
5161 }
5162 {
5163 if (arg4) delete [] arg4;
5164 }
5165 return resultobj;
5166 fail:
5167 {
5168 if (temp1)
5169 delete arg1;
5170 }
5171 {
5172 if (temp2)
5173 delete arg2;
5174 }
5175 {
5176 if (arg4) delete [] arg4;
5177 }
5178 return NULL;
5179 }
5180
5181
5182 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5183 PyObject *resultobj;
5184 wxString *arg1 = 0 ;
5185 wxString const &arg2_defvalue = wxPyEmptyString ;
5186 wxString *arg2 = (wxString *) &arg2_defvalue ;
5187 int arg3 = (int) wxOK|wxCENTRE ;
5188 wxWindow *arg4 = (wxWindow *) NULL ;
5189 int arg5 = (int) -1 ;
5190 int arg6 = (int) -1 ;
5191 int result;
5192 bool temp1 = false ;
5193 bool temp2 = false ;
5194 PyObject * obj0 = 0 ;
5195 PyObject * obj1 = 0 ;
5196 PyObject * obj2 = 0 ;
5197 PyObject * obj3 = 0 ;
5198 PyObject * obj4 = 0 ;
5199 PyObject * obj5 = 0 ;
5200 char *kwnames[] = {
5201 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5202 };
5203
5204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5205 {
5206 arg1 = wxString_in_helper(obj0);
5207 if (arg1 == NULL) SWIG_fail;
5208 temp1 = true;
5209 }
5210 if (obj1) {
5211 {
5212 arg2 = wxString_in_helper(obj1);
5213 if (arg2 == NULL) SWIG_fail;
5214 temp2 = true;
5215 }
5216 }
5217 if (obj2) {
5218 {
5219 arg3 = (int)(SWIG_As_int(obj2));
5220 if (SWIG_arg_fail(3)) SWIG_fail;
5221 }
5222 }
5223 if (obj3) {
5224 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5225 if (SWIG_arg_fail(4)) SWIG_fail;
5226 }
5227 if (obj4) {
5228 {
5229 arg5 = (int)(SWIG_As_int(obj4));
5230 if (SWIG_arg_fail(5)) SWIG_fail;
5231 }
5232 }
5233 if (obj5) {
5234 {
5235 arg6 = (int)(SWIG_As_int(obj5));
5236 if (SWIG_arg_fail(6)) SWIG_fail;
5237 }
5238 }
5239 {
5240 if (!wxPyCheckForApp()) SWIG_fail;
5241 PyThreadState* __tstate = wxPyBeginAllowThreads();
5242 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5243
5244 wxPyEndAllowThreads(__tstate);
5245 if (PyErr_Occurred()) SWIG_fail;
5246 }
5247 {
5248 resultobj = SWIG_From_int((int)(result));
5249 }
5250 {
5251 if (temp1)
5252 delete arg1;
5253 }
5254 {
5255 if (temp2)
5256 delete arg2;
5257 }
5258 return resultobj;
5259 fail:
5260 {
5261 if (temp1)
5262 delete arg1;
5263 }
5264 {
5265 if (temp2)
5266 delete arg2;
5267 }
5268 return NULL;
5269 }
5270
5271
5272 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5273 PyObject *resultobj;
5274 wxString *arg1 = 0 ;
5275 wxString *arg2 = 0 ;
5276 wxString *arg3 = 0 ;
5277 long arg4 ;
5278 long arg5 = (long) 0 ;
5279 long arg6 = (long) 100 ;
5280 wxWindow *arg7 = (wxWindow *) NULL ;
5281 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5282 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5283 long result;
5284 bool temp1 = false ;
5285 bool temp2 = false ;
5286 bool temp3 = false ;
5287 wxPoint temp8 ;
5288 PyObject * obj0 = 0 ;
5289 PyObject * obj1 = 0 ;
5290 PyObject * obj2 = 0 ;
5291 PyObject * obj3 = 0 ;
5292 PyObject * obj4 = 0 ;
5293 PyObject * obj5 = 0 ;
5294 PyObject * obj6 = 0 ;
5295 PyObject * obj7 = 0 ;
5296 char *kwnames[] = {
5297 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5298 };
5299
5300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5301 {
5302 arg1 = wxString_in_helper(obj0);
5303 if (arg1 == NULL) SWIG_fail;
5304 temp1 = true;
5305 }
5306 {
5307 arg2 = wxString_in_helper(obj1);
5308 if (arg2 == NULL) SWIG_fail;
5309 temp2 = true;
5310 }
5311 {
5312 arg3 = wxString_in_helper(obj2);
5313 if (arg3 == NULL) SWIG_fail;
5314 temp3 = true;
5315 }
5316 {
5317 arg4 = (long)(SWIG_As_long(obj3));
5318 if (SWIG_arg_fail(4)) SWIG_fail;
5319 }
5320 if (obj4) {
5321 {
5322 arg5 = (long)(SWIG_As_long(obj4));
5323 if (SWIG_arg_fail(5)) SWIG_fail;
5324 }
5325 }
5326 if (obj5) {
5327 {
5328 arg6 = (long)(SWIG_As_long(obj5));
5329 if (SWIG_arg_fail(6)) SWIG_fail;
5330 }
5331 }
5332 if (obj6) {
5333 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5334 if (SWIG_arg_fail(7)) SWIG_fail;
5335 }
5336 if (obj7) {
5337 {
5338 arg8 = &temp8;
5339 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5340 }
5341 }
5342 {
5343 if (!wxPyCheckForApp()) SWIG_fail;
5344 PyThreadState* __tstate = wxPyBeginAllowThreads();
5345 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5346
5347 wxPyEndAllowThreads(__tstate);
5348 if (PyErr_Occurred()) SWIG_fail;
5349 }
5350 {
5351 resultobj = SWIG_From_long((long)(result));
5352 }
5353 {
5354 if (temp1)
5355 delete arg1;
5356 }
5357 {
5358 if (temp2)
5359 delete arg2;
5360 }
5361 {
5362 if (temp3)
5363 delete arg3;
5364 }
5365 return resultobj;
5366 fail:
5367 {
5368 if (temp1)
5369 delete arg1;
5370 }
5371 {
5372 if (temp2)
5373 delete arg2;
5374 }
5375 {
5376 if (temp3)
5377 delete arg3;
5378 }
5379 return NULL;
5380 }
5381
5382
5383 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5384 PyObject *resultobj;
5385 bool result;
5386 char *kwnames[] = {
5387 NULL
5388 };
5389
5390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5391 {
5392 if (!wxPyCheckForApp()) SWIG_fail;
5393 PyThreadState* __tstate = wxPyBeginAllowThreads();
5394 result = (bool)wxColourDisplay();
5395
5396 wxPyEndAllowThreads(__tstate);
5397 if (PyErr_Occurred()) SWIG_fail;
5398 }
5399 {
5400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5401 }
5402 return resultobj;
5403 fail:
5404 return NULL;
5405 }
5406
5407
5408 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5409 PyObject *resultobj;
5410 int result;
5411 char *kwnames[] = {
5412 NULL
5413 };
5414
5415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5416 {
5417 if (!wxPyCheckForApp()) SWIG_fail;
5418 PyThreadState* __tstate = wxPyBeginAllowThreads();
5419 result = (int)wxDisplayDepth();
5420
5421 wxPyEndAllowThreads(__tstate);
5422 if (PyErr_Occurred()) SWIG_fail;
5423 }
5424 {
5425 resultobj = SWIG_From_int((int)(result));
5426 }
5427 return resultobj;
5428 fail:
5429 return NULL;
5430 }
5431
5432
5433 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5434 PyObject *resultobj;
5435 int result;
5436 char *kwnames[] = {
5437 NULL
5438 };
5439
5440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5441 {
5442 if (!wxPyCheckForApp()) SWIG_fail;
5443 PyThreadState* __tstate = wxPyBeginAllowThreads();
5444 result = (int)wxGetDisplayDepth();
5445
5446 wxPyEndAllowThreads(__tstate);
5447 if (PyErr_Occurred()) SWIG_fail;
5448 }
5449 {
5450 resultobj = SWIG_From_int((int)(result));
5451 }
5452 return resultobj;
5453 fail:
5454 return NULL;
5455 }
5456
5457
5458 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5459 PyObject *resultobj;
5460 int *arg1 = (int *) 0 ;
5461 int *arg2 = (int *) 0 ;
5462 int temp1 ;
5463 int res1 = 0 ;
5464 int temp2 ;
5465 int res2 = 0 ;
5466 char *kwnames[] = {
5467 NULL
5468 };
5469
5470 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5471 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5473 {
5474 if (!wxPyCheckForApp()) SWIG_fail;
5475 PyThreadState* __tstate = wxPyBeginAllowThreads();
5476 wxDisplaySize(arg1,arg2);
5477
5478 wxPyEndAllowThreads(__tstate);
5479 if (PyErr_Occurred()) SWIG_fail;
5480 }
5481 Py_INCREF(Py_None); resultobj = Py_None;
5482 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5483 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5484 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5485 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5486 return resultobj;
5487 fail:
5488 return NULL;
5489 }
5490
5491
5492 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5493 PyObject *resultobj;
5494 wxSize result;
5495 char *kwnames[] = {
5496 NULL
5497 };
5498
5499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5500 {
5501 if (!wxPyCheckForApp()) SWIG_fail;
5502 PyThreadState* __tstate = wxPyBeginAllowThreads();
5503 result = wxGetDisplaySize();
5504
5505 wxPyEndAllowThreads(__tstate);
5506 if (PyErr_Occurred()) SWIG_fail;
5507 }
5508 {
5509 wxSize * resultptr;
5510 resultptr = new wxSize((wxSize &)(result));
5511 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5512 }
5513 return resultobj;
5514 fail:
5515 return NULL;
5516 }
5517
5518
5519 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5520 PyObject *resultobj;
5521 int *arg1 = (int *) 0 ;
5522 int *arg2 = (int *) 0 ;
5523 int temp1 ;
5524 int res1 = 0 ;
5525 int temp2 ;
5526 int res2 = 0 ;
5527 char *kwnames[] = {
5528 NULL
5529 };
5530
5531 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5532 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5534 {
5535 if (!wxPyCheckForApp()) SWIG_fail;
5536 PyThreadState* __tstate = wxPyBeginAllowThreads();
5537 wxDisplaySizeMM(arg1,arg2);
5538
5539 wxPyEndAllowThreads(__tstate);
5540 if (PyErr_Occurred()) SWIG_fail;
5541 }
5542 Py_INCREF(Py_None); resultobj = Py_None;
5543 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5544 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5545 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5546 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5547 return resultobj;
5548 fail:
5549 return NULL;
5550 }
5551
5552
5553 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5554 PyObject *resultobj;
5555 wxSize result;
5556 char *kwnames[] = {
5557 NULL
5558 };
5559
5560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5561 {
5562 if (!wxPyCheckForApp()) SWIG_fail;
5563 PyThreadState* __tstate = wxPyBeginAllowThreads();
5564 result = wxGetDisplaySizeMM();
5565
5566 wxPyEndAllowThreads(__tstate);
5567 if (PyErr_Occurred()) SWIG_fail;
5568 }
5569 {
5570 wxSize * resultptr;
5571 resultptr = new wxSize((wxSize &)(result));
5572 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5573 }
5574 return resultobj;
5575 fail:
5576 return NULL;
5577 }
5578
5579
5580 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5581 PyObject *resultobj;
5582 int *arg1 = (int *) 0 ;
5583 int *arg2 = (int *) 0 ;
5584 int *arg3 = (int *) 0 ;
5585 int *arg4 = (int *) 0 ;
5586 int temp1 ;
5587 int res1 = 0 ;
5588 int temp2 ;
5589 int res2 = 0 ;
5590 int temp3 ;
5591 int res3 = 0 ;
5592 int temp4 ;
5593 int res4 = 0 ;
5594 char *kwnames[] = {
5595 NULL
5596 };
5597
5598 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5599 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5600 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5601 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5603 {
5604 if (!wxPyCheckForApp()) SWIG_fail;
5605 PyThreadState* __tstate = wxPyBeginAllowThreads();
5606 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5607
5608 wxPyEndAllowThreads(__tstate);
5609 if (PyErr_Occurred()) SWIG_fail;
5610 }
5611 Py_INCREF(Py_None); resultobj = Py_None;
5612 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5613 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5614 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5615 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5616 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5617 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5618 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5619 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5620 return resultobj;
5621 fail:
5622 return NULL;
5623 }
5624
5625
5626 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5627 PyObject *resultobj;
5628 wxRect result;
5629 char *kwnames[] = {
5630 NULL
5631 };
5632
5633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5634 {
5635 if (!wxPyCheckForApp()) SWIG_fail;
5636 PyThreadState* __tstate = wxPyBeginAllowThreads();
5637 result = wxGetClientDisplayRect();
5638
5639 wxPyEndAllowThreads(__tstate);
5640 if (PyErr_Occurred()) SWIG_fail;
5641 }
5642 {
5643 wxRect * resultptr;
5644 resultptr = new wxRect((wxRect &)(result));
5645 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5646 }
5647 return resultobj;
5648 fail:
5649 return NULL;
5650 }
5651
5652
5653 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5654 PyObject *resultobj;
5655 wxCursor *arg1 = 0 ;
5656 PyObject * obj0 = 0 ;
5657 char *kwnames[] = {
5658 (char *) "cursor", NULL
5659 };
5660
5661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5662 {
5663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5664 if (SWIG_arg_fail(1)) SWIG_fail;
5665 if (arg1 == NULL) {
5666 SWIG_null_ref("wxCursor");
5667 }
5668 if (SWIG_arg_fail(1)) SWIG_fail;
5669 }
5670 {
5671 if (!wxPyCheckForApp()) SWIG_fail;
5672 PyThreadState* __tstate = wxPyBeginAllowThreads();
5673 wxSetCursor(*arg1);
5674
5675 wxPyEndAllowThreads(__tstate);
5676 if (PyErr_Occurred()) SWIG_fail;
5677 }
5678 Py_INCREF(Py_None); resultobj = Py_None;
5679 return resultobj;
5680 fail:
5681 return NULL;
5682 }
5683
5684
5685 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5686 PyObject *resultobj;
5687 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5688 PyObject * obj0 = 0 ;
5689 char *kwnames[] = {
5690 (char *) "cursor", NULL
5691 };
5692
5693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5694 if (obj0) {
5695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5696 if (SWIG_arg_fail(1)) SWIG_fail;
5697 }
5698 {
5699 if (!wxPyCheckForApp()) SWIG_fail;
5700 PyThreadState* __tstate = wxPyBeginAllowThreads();
5701 wxBeginBusyCursor(arg1);
5702
5703 wxPyEndAllowThreads(__tstate);
5704 if (PyErr_Occurred()) SWIG_fail;
5705 }
5706 Py_INCREF(Py_None); resultobj = Py_None;
5707 return resultobj;
5708 fail:
5709 return NULL;
5710 }
5711
5712
5713 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5714 PyObject *resultobj;
5715 wxWindow *result;
5716 char *kwnames[] = {
5717 NULL
5718 };
5719
5720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5721 {
5722 if (!wxPyCheckForApp()) SWIG_fail;
5723 PyThreadState* __tstate = wxPyBeginAllowThreads();
5724 result = (wxWindow *)wxGetActiveWindow();
5725
5726 wxPyEndAllowThreads(__tstate);
5727 if (PyErr_Occurred()) SWIG_fail;
5728 }
5729 {
5730 resultobj = wxPyMake_wxObject(result, 0);
5731 }
5732 return resultobj;
5733 fail:
5734 return NULL;
5735 }
5736
5737
5738 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5739 PyObject *resultobj;
5740 wxPoint *arg1 = 0 ;
5741 wxWindow *result;
5742 wxPoint temp1 ;
5743 PyObject * obj0 = 0 ;
5744 char *kwnames[] = {
5745 (char *) "pt", NULL
5746 };
5747
5748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5749 {
5750 arg1 = &temp1;
5751 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5752 }
5753 {
5754 if (!wxPyCheckForApp()) SWIG_fail;
5755 PyThreadState* __tstate = wxPyBeginAllowThreads();
5756 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5757
5758 wxPyEndAllowThreads(__tstate);
5759 if (PyErr_Occurred()) SWIG_fail;
5760 }
5761 {
5762 resultobj = wxPyMake_wxObject(result, 0);
5763 }
5764 return resultobj;
5765 fail:
5766 return NULL;
5767 }
5768
5769
5770 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5771 PyObject *resultobj;
5772 wxPoint *arg1 = 0 ;
5773 wxWindow *result;
5774 wxPoint temp1 ;
5775 PyObject * obj0 = 0 ;
5776 char *kwnames[] = {
5777 (char *) "pt", NULL
5778 };
5779
5780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5781 {
5782 arg1 = &temp1;
5783 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5784 }
5785 {
5786 if (!wxPyCheckForApp()) SWIG_fail;
5787 PyThreadState* __tstate = wxPyBeginAllowThreads();
5788 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5789
5790 wxPyEndAllowThreads(__tstate);
5791 if (PyErr_Occurred()) SWIG_fail;
5792 }
5793 {
5794 resultobj = wxPyMake_wxObject(result, 0);
5795 }
5796 return resultobj;
5797 fail:
5798 return NULL;
5799 }
5800
5801
5802 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5803 PyObject *resultobj;
5804 wxWindow *arg1 = (wxWindow *) 0 ;
5805 wxWindow *result;
5806 PyObject * obj0 = 0 ;
5807 char *kwnames[] = {
5808 (char *) "win", NULL
5809 };
5810
5811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5813 if (SWIG_arg_fail(1)) SWIG_fail;
5814 {
5815 if (!wxPyCheckForApp()) SWIG_fail;
5816 PyThreadState* __tstate = wxPyBeginAllowThreads();
5817 result = (wxWindow *)wxGetTopLevelParent(arg1);
5818
5819 wxPyEndAllowThreads(__tstate);
5820 if (PyErr_Occurred()) SWIG_fail;
5821 }
5822 {
5823 resultobj = wxPyMake_wxObject(result, 0);
5824 }
5825 return resultobj;
5826 fail:
5827 return NULL;
5828 }
5829
5830
5831 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5832 PyObject *resultobj;
5833 wxKeyCode arg1 ;
5834 bool result;
5835 PyObject * obj0 = 0 ;
5836 char *kwnames[] = {
5837 (char *) "key", NULL
5838 };
5839
5840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5841 {
5842 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5843 if (SWIG_arg_fail(1)) SWIG_fail;
5844 }
5845 {
5846 if (!wxPyCheckForApp()) SWIG_fail;
5847 PyThreadState* __tstate = wxPyBeginAllowThreads();
5848 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5849
5850 wxPyEndAllowThreads(__tstate);
5851 if (PyErr_Occurred()) SWIG_fail;
5852 }
5853 {
5854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5855 }
5856 return resultobj;
5857 fail:
5858 return NULL;
5859 }
5860
5861
5862 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5863 PyObject *resultobj;
5864 char *kwnames[] = {
5865 NULL
5866 };
5867
5868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
5869 {
5870 if (!wxPyCheckForApp()) SWIG_fail;
5871 PyThreadState* __tstate = wxPyBeginAllowThreads();
5872 wxWakeUpMainThread();
5873
5874 wxPyEndAllowThreads(__tstate);
5875 if (PyErr_Occurred()) SWIG_fail;
5876 }
5877 Py_INCREF(Py_None); resultobj = Py_None;
5878 return resultobj;
5879 fail:
5880 return NULL;
5881 }
5882
5883
5884 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
5885 PyObject *resultobj;
5886 char *kwnames[] = {
5887 NULL
5888 };
5889
5890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
5891 {
5892 if (!wxPyCheckForApp()) SWIG_fail;
5893 PyThreadState* __tstate = wxPyBeginAllowThreads();
5894 wxMutexGuiEnter();
5895
5896 wxPyEndAllowThreads(__tstate);
5897 if (PyErr_Occurred()) SWIG_fail;
5898 }
5899 Py_INCREF(Py_None); resultobj = Py_None;
5900 return resultobj;
5901 fail:
5902 return NULL;
5903 }
5904
5905
5906 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
5907 PyObject *resultobj;
5908 char *kwnames[] = {
5909 NULL
5910 };
5911
5912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
5913 {
5914 if (!wxPyCheckForApp()) SWIG_fail;
5915 PyThreadState* __tstate = wxPyBeginAllowThreads();
5916 wxMutexGuiLeave();
5917
5918 wxPyEndAllowThreads(__tstate);
5919 if (PyErr_Occurred()) SWIG_fail;
5920 }
5921 Py_INCREF(Py_None); resultobj = Py_None;
5922 return resultobj;
5923 fail:
5924 return NULL;
5925 }
5926
5927
5928 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5929 PyObject *resultobj;
5930 wxMutexGuiLocker *result;
5931 char *kwnames[] = {
5932 NULL
5933 };
5934
5935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
5936 {
5937 if (!wxPyCheckForApp()) SWIG_fail;
5938 PyThreadState* __tstate = wxPyBeginAllowThreads();
5939 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
5940
5941 wxPyEndAllowThreads(__tstate);
5942 if (PyErr_Occurred()) SWIG_fail;
5943 }
5944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
5945 return resultobj;
5946 fail:
5947 return NULL;
5948 }
5949
5950
5951 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5952 PyObject *resultobj;
5953 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
5954 PyObject * obj0 = 0 ;
5955 char *kwnames[] = {
5956 (char *) "self", NULL
5957 };
5958
5959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
5960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
5961 if (SWIG_arg_fail(1)) SWIG_fail;
5962 {
5963 PyThreadState* __tstate = wxPyBeginAllowThreads();
5964 delete arg1;
5965
5966 wxPyEndAllowThreads(__tstate);
5967 if (PyErr_Occurred()) SWIG_fail;
5968 }
5969 Py_INCREF(Py_None); resultobj = Py_None;
5970 return resultobj;
5971 fail:
5972 return NULL;
5973 }
5974
5975
5976 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
5977 PyObject *obj;
5978 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5979 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
5980 Py_INCREF(obj);
5981 return Py_BuildValue((char *)"");
5982 }
5983 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
5984 PyObject *resultobj;
5985 bool result;
5986 char *kwnames[] = {
5987 NULL
5988 };
5989
5990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
5991 {
5992 PyThreadState* __tstate = wxPyBeginAllowThreads();
5993 result = (bool)wxThread_IsMain();
5994
5995 wxPyEndAllowThreads(__tstate);
5996 if (PyErr_Occurred()) SWIG_fail;
5997 }
5998 {
5999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6000 }
6001 return resultobj;
6002 fail:
6003 return NULL;
6004 }
6005
6006
6007 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6008 PyObject *resultobj;
6009 wxString *arg1 = 0 ;
6010 wxToolTip *result;
6011 bool temp1 = false ;
6012 PyObject * obj0 = 0 ;
6013 char *kwnames[] = {
6014 (char *) "tip", NULL
6015 };
6016
6017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6018 {
6019 arg1 = wxString_in_helper(obj0);
6020 if (arg1 == NULL) SWIG_fail;
6021 temp1 = true;
6022 }
6023 {
6024 if (!wxPyCheckForApp()) SWIG_fail;
6025 PyThreadState* __tstate = wxPyBeginAllowThreads();
6026 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6027
6028 wxPyEndAllowThreads(__tstate);
6029 if (PyErr_Occurred()) SWIG_fail;
6030 }
6031 {
6032 resultobj = wxPyMake_wxObject(result, 1);
6033 }
6034 {
6035 if (temp1)
6036 delete arg1;
6037 }
6038 return resultobj;
6039 fail:
6040 {
6041 if (temp1)
6042 delete arg1;
6043 }
6044 return NULL;
6045 }
6046
6047
6048 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6049 PyObject *resultobj;
6050 wxToolTip *arg1 = (wxToolTip *) 0 ;
6051 wxString *arg2 = 0 ;
6052 bool temp2 = false ;
6053 PyObject * obj0 = 0 ;
6054 PyObject * obj1 = 0 ;
6055 char *kwnames[] = {
6056 (char *) "self",(char *) "tip", NULL
6057 };
6058
6059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6061 if (SWIG_arg_fail(1)) SWIG_fail;
6062 {
6063 arg2 = wxString_in_helper(obj1);
6064 if (arg2 == NULL) SWIG_fail;
6065 temp2 = true;
6066 }
6067 {
6068 PyThreadState* __tstate = wxPyBeginAllowThreads();
6069 (arg1)->SetTip((wxString const &)*arg2);
6070
6071 wxPyEndAllowThreads(__tstate);
6072 if (PyErr_Occurred()) SWIG_fail;
6073 }
6074 Py_INCREF(Py_None); resultobj = Py_None;
6075 {
6076 if (temp2)
6077 delete arg2;
6078 }
6079 return resultobj;
6080 fail:
6081 {
6082 if (temp2)
6083 delete arg2;
6084 }
6085 return NULL;
6086 }
6087
6088
6089 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6090 PyObject *resultobj;
6091 wxToolTip *arg1 = (wxToolTip *) 0 ;
6092 wxString result;
6093 PyObject * obj0 = 0 ;
6094 char *kwnames[] = {
6095 (char *) "self", NULL
6096 };
6097
6098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6100 if (SWIG_arg_fail(1)) SWIG_fail;
6101 {
6102 PyThreadState* __tstate = wxPyBeginAllowThreads();
6103 result = (arg1)->GetTip();
6104
6105 wxPyEndAllowThreads(__tstate);
6106 if (PyErr_Occurred()) SWIG_fail;
6107 }
6108 {
6109 #if wxUSE_UNICODE
6110 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6111 #else
6112 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6113 #endif
6114 }
6115 return resultobj;
6116 fail:
6117 return NULL;
6118 }
6119
6120
6121 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6122 PyObject *resultobj;
6123 wxToolTip *arg1 = (wxToolTip *) 0 ;
6124 wxWindow *result;
6125 PyObject * obj0 = 0 ;
6126 char *kwnames[] = {
6127 (char *) "self", NULL
6128 };
6129
6130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6132 if (SWIG_arg_fail(1)) SWIG_fail;
6133 {
6134 PyThreadState* __tstate = wxPyBeginAllowThreads();
6135 result = (wxWindow *)(arg1)->GetWindow();
6136
6137 wxPyEndAllowThreads(__tstate);
6138 if (PyErr_Occurred()) SWIG_fail;
6139 }
6140 {
6141 resultobj = wxPyMake_wxObject(result, 0);
6142 }
6143 return resultobj;
6144 fail:
6145 return NULL;
6146 }
6147
6148
6149 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6150 PyObject *resultobj;
6151 bool arg1 ;
6152 PyObject * obj0 = 0 ;
6153 char *kwnames[] = {
6154 (char *) "flag", NULL
6155 };
6156
6157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6158 {
6159 arg1 = (bool)(SWIG_As_bool(obj0));
6160 if (SWIG_arg_fail(1)) SWIG_fail;
6161 }
6162 {
6163 PyThreadState* __tstate = wxPyBeginAllowThreads();
6164 wxToolTip::Enable(arg1);
6165
6166 wxPyEndAllowThreads(__tstate);
6167 if (PyErr_Occurred()) SWIG_fail;
6168 }
6169 Py_INCREF(Py_None); resultobj = Py_None;
6170 return resultobj;
6171 fail:
6172 return NULL;
6173 }
6174
6175
6176 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6177 PyObject *resultobj;
6178 long arg1 ;
6179 PyObject * obj0 = 0 ;
6180 char *kwnames[] = {
6181 (char *) "milliseconds", NULL
6182 };
6183
6184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6185 {
6186 arg1 = (long)(SWIG_As_long(obj0));
6187 if (SWIG_arg_fail(1)) SWIG_fail;
6188 }
6189 {
6190 PyThreadState* __tstate = wxPyBeginAllowThreads();
6191 wxToolTip::SetDelay(arg1);
6192
6193 wxPyEndAllowThreads(__tstate);
6194 if (PyErr_Occurred()) SWIG_fail;
6195 }
6196 Py_INCREF(Py_None); resultobj = Py_None;
6197 return resultobj;
6198 fail:
6199 return NULL;
6200 }
6201
6202
6203 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6204 PyObject *obj;
6205 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6206 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6207 Py_INCREF(obj);
6208 return Py_BuildValue((char *)"");
6209 }
6210 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6211 PyObject *resultobj;
6212 wxWindow *arg1 = (wxWindow *) 0 ;
6213 wxSize *arg2 = 0 ;
6214 wxCaret *result;
6215 wxSize temp2 ;
6216 PyObject * obj0 = 0 ;
6217 PyObject * obj1 = 0 ;
6218 char *kwnames[] = {
6219 (char *) "window",(char *) "size", NULL
6220 };
6221
6222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6224 if (SWIG_arg_fail(1)) SWIG_fail;
6225 {
6226 arg2 = &temp2;
6227 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6228 }
6229 {
6230 if (!wxPyCheckForApp()) SWIG_fail;
6231 PyThreadState* __tstate = wxPyBeginAllowThreads();
6232 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6233
6234 wxPyEndAllowThreads(__tstate);
6235 if (PyErr_Occurred()) SWIG_fail;
6236 }
6237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6238 return resultobj;
6239 fail:
6240 return NULL;
6241 }
6242
6243
6244 static PyObject *_wrap_delete_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6245 PyObject *resultobj;
6246 wxCaret *arg1 = (wxCaret *) 0 ;
6247 PyObject * obj0 = 0 ;
6248 char *kwnames[] = {
6249 (char *) "self", NULL
6250 };
6251
6252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Caret",kwnames,&obj0)) goto fail;
6253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6254 if (SWIG_arg_fail(1)) SWIG_fail;
6255 {
6256 PyThreadState* __tstate = wxPyBeginAllowThreads();
6257 delete arg1;
6258
6259 wxPyEndAllowThreads(__tstate);
6260 if (PyErr_Occurred()) SWIG_fail;
6261 }
6262 Py_INCREF(Py_None); resultobj = Py_None;
6263 return resultobj;
6264 fail:
6265 return NULL;
6266 }
6267
6268
6269 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6270 PyObject *resultobj;
6271 wxCaret *arg1 = (wxCaret *) 0 ;
6272 bool result;
6273 PyObject * obj0 = 0 ;
6274 char *kwnames[] = {
6275 (char *) "self", NULL
6276 };
6277
6278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6280 if (SWIG_arg_fail(1)) SWIG_fail;
6281 {
6282 PyThreadState* __tstate = wxPyBeginAllowThreads();
6283 result = (bool)(arg1)->IsOk();
6284
6285 wxPyEndAllowThreads(__tstate);
6286 if (PyErr_Occurred()) SWIG_fail;
6287 }
6288 {
6289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6290 }
6291 return resultobj;
6292 fail:
6293 return NULL;
6294 }
6295
6296
6297 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6298 PyObject *resultobj;
6299 wxCaret *arg1 = (wxCaret *) 0 ;
6300 bool result;
6301 PyObject * obj0 = 0 ;
6302 char *kwnames[] = {
6303 (char *) "self", NULL
6304 };
6305
6306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6308 if (SWIG_arg_fail(1)) SWIG_fail;
6309 {
6310 PyThreadState* __tstate = wxPyBeginAllowThreads();
6311 result = (bool)(arg1)->IsVisible();
6312
6313 wxPyEndAllowThreads(__tstate);
6314 if (PyErr_Occurred()) SWIG_fail;
6315 }
6316 {
6317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6318 }
6319 return resultobj;
6320 fail:
6321 return NULL;
6322 }
6323
6324
6325 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6326 PyObject *resultobj;
6327 wxCaret *arg1 = (wxCaret *) 0 ;
6328 wxPoint result;
6329 PyObject * obj0 = 0 ;
6330 char *kwnames[] = {
6331 (char *) "self", NULL
6332 };
6333
6334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6336 if (SWIG_arg_fail(1)) SWIG_fail;
6337 {
6338 PyThreadState* __tstate = wxPyBeginAllowThreads();
6339 result = (arg1)->GetPosition();
6340
6341 wxPyEndAllowThreads(__tstate);
6342 if (PyErr_Occurred()) SWIG_fail;
6343 }
6344 {
6345 wxPoint * resultptr;
6346 resultptr = new wxPoint((wxPoint &)(result));
6347 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6348 }
6349 return resultobj;
6350 fail:
6351 return NULL;
6352 }
6353
6354
6355 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6356 PyObject *resultobj;
6357 wxCaret *arg1 = (wxCaret *) 0 ;
6358 int *arg2 = (int *) 0 ;
6359 int *arg3 = (int *) 0 ;
6360 int temp2 ;
6361 int res2 = 0 ;
6362 int temp3 ;
6363 int res3 = 0 ;
6364 PyObject * obj0 = 0 ;
6365 char *kwnames[] = {
6366 (char *) "self", NULL
6367 };
6368
6369 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6370 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6373 if (SWIG_arg_fail(1)) SWIG_fail;
6374 {
6375 PyThreadState* __tstate = wxPyBeginAllowThreads();
6376 (arg1)->GetPosition(arg2,arg3);
6377
6378 wxPyEndAllowThreads(__tstate);
6379 if (PyErr_Occurred()) SWIG_fail;
6380 }
6381 Py_INCREF(Py_None); resultobj = Py_None;
6382 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6383 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6384 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6385 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6386 return resultobj;
6387 fail:
6388 return NULL;
6389 }
6390
6391
6392 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6393 PyObject *resultobj;
6394 wxCaret *arg1 = (wxCaret *) 0 ;
6395 wxSize result;
6396 PyObject * obj0 = 0 ;
6397 char *kwnames[] = {
6398 (char *) "self", NULL
6399 };
6400
6401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6403 if (SWIG_arg_fail(1)) SWIG_fail;
6404 {
6405 PyThreadState* __tstate = wxPyBeginAllowThreads();
6406 result = (arg1)->GetSize();
6407
6408 wxPyEndAllowThreads(__tstate);
6409 if (PyErr_Occurred()) SWIG_fail;
6410 }
6411 {
6412 wxSize * resultptr;
6413 resultptr = new wxSize((wxSize &)(result));
6414 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6415 }
6416 return resultobj;
6417 fail:
6418 return NULL;
6419 }
6420
6421
6422 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6423 PyObject *resultobj;
6424 wxCaret *arg1 = (wxCaret *) 0 ;
6425 int *arg2 = (int *) 0 ;
6426 int *arg3 = (int *) 0 ;
6427 int temp2 ;
6428 int res2 = 0 ;
6429 int temp3 ;
6430 int res3 = 0 ;
6431 PyObject * obj0 = 0 ;
6432 char *kwnames[] = {
6433 (char *) "self", NULL
6434 };
6435
6436 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6437 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6440 if (SWIG_arg_fail(1)) SWIG_fail;
6441 {
6442 PyThreadState* __tstate = wxPyBeginAllowThreads();
6443 (arg1)->GetSize(arg2,arg3);
6444
6445 wxPyEndAllowThreads(__tstate);
6446 if (PyErr_Occurred()) SWIG_fail;
6447 }
6448 Py_INCREF(Py_None); resultobj = Py_None;
6449 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6450 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6451 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6452 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6453 return resultobj;
6454 fail:
6455 return NULL;
6456 }
6457
6458
6459 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6460 PyObject *resultobj;
6461 wxCaret *arg1 = (wxCaret *) 0 ;
6462 wxWindow *result;
6463 PyObject * obj0 = 0 ;
6464 char *kwnames[] = {
6465 (char *) "self", NULL
6466 };
6467
6468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6470 if (SWIG_arg_fail(1)) SWIG_fail;
6471 {
6472 PyThreadState* __tstate = wxPyBeginAllowThreads();
6473 result = (wxWindow *)(arg1)->GetWindow();
6474
6475 wxPyEndAllowThreads(__tstate);
6476 if (PyErr_Occurred()) SWIG_fail;
6477 }
6478 {
6479 resultobj = wxPyMake_wxObject(result, 0);
6480 }
6481 return resultobj;
6482 fail:
6483 return NULL;
6484 }
6485
6486
6487 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6488 PyObject *resultobj;
6489 wxCaret *arg1 = (wxCaret *) 0 ;
6490 int arg2 ;
6491 int arg3 ;
6492 PyObject * obj0 = 0 ;
6493 PyObject * obj1 = 0 ;
6494 PyObject * obj2 = 0 ;
6495 char *kwnames[] = {
6496 (char *) "self",(char *) "x",(char *) "y", NULL
6497 };
6498
6499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6501 if (SWIG_arg_fail(1)) SWIG_fail;
6502 {
6503 arg2 = (int)(SWIG_As_int(obj1));
6504 if (SWIG_arg_fail(2)) SWIG_fail;
6505 }
6506 {
6507 arg3 = (int)(SWIG_As_int(obj2));
6508 if (SWIG_arg_fail(3)) SWIG_fail;
6509 }
6510 {
6511 PyThreadState* __tstate = wxPyBeginAllowThreads();
6512 (arg1)->Move(arg2,arg3);
6513
6514 wxPyEndAllowThreads(__tstate);
6515 if (PyErr_Occurred()) SWIG_fail;
6516 }
6517 Py_INCREF(Py_None); resultobj = Py_None;
6518 return resultobj;
6519 fail:
6520 return NULL;
6521 }
6522
6523
6524 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6525 PyObject *resultobj;
6526 wxCaret *arg1 = (wxCaret *) 0 ;
6527 wxPoint *arg2 = 0 ;
6528 wxPoint temp2 ;
6529 PyObject * obj0 = 0 ;
6530 PyObject * obj1 = 0 ;
6531 char *kwnames[] = {
6532 (char *) "self",(char *) "pt", NULL
6533 };
6534
6535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6537 if (SWIG_arg_fail(1)) SWIG_fail;
6538 {
6539 arg2 = &temp2;
6540 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6541 }
6542 {
6543 PyThreadState* __tstate = wxPyBeginAllowThreads();
6544 (arg1)->Move((wxPoint const &)*arg2);
6545
6546 wxPyEndAllowThreads(__tstate);
6547 if (PyErr_Occurred()) SWIG_fail;
6548 }
6549 Py_INCREF(Py_None); resultobj = Py_None;
6550 return resultobj;
6551 fail:
6552 return NULL;
6553 }
6554
6555
6556 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6557 PyObject *resultobj;
6558 wxCaret *arg1 = (wxCaret *) 0 ;
6559 int arg2 ;
6560 int arg3 ;
6561 PyObject * obj0 = 0 ;
6562 PyObject * obj1 = 0 ;
6563 PyObject * obj2 = 0 ;
6564 char *kwnames[] = {
6565 (char *) "self",(char *) "width",(char *) "height", NULL
6566 };
6567
6568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6570 if (SWIG_arg_fail(1)) SWIG_fail;
6571 {
6572 arg2 = (int)(SWIG_As_int(obj1));
6573 if (SWIG_arg_fail(2)) SWIG_fail;
6574 }
6575 {
6576 arg3 = (int)(SWIG_As_int(obj2));
6577 if (SWIG_arg_fail(3)) SWIG_fail;
6578 }
6579 {
6580 PyThreadState* __tstate = wxPyBeginAllowThreads();
6581 (arg1)->SetSize(arg2,arg3);
6582
6583 wxPyEndAllowThreads(__tstate);
6584 if (PyErr_Occurred()) SWIG_fail;
6585 }
6586 Py_INCREF(Py_None); resultobj = Py_None;
6587 return resultobj;
6588 fail:
6589 return NULL;
6590 }
6591
6592
6593 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6594 PyObject *resultobj;
6595 wxCaret *arg1 = (wxCaret *) 0 ;
6596 wxSize *arg2 = 0 ;
6597 wxSize temp2 ;
6598 PyObject * obj0 = 0 ;
6599 PyObject * obj1 = 0 ;
6600 char *kwnames[] = {
6601 (char *) "self",(char *) "size", NULL
6602 };
6603
6604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6606 if (SWIG_arg_fail(1)) SWIG_fail;
6607 {
6608 arg2 = &temp2;
6609 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6610 }
6611 {
6612 PyThreadState* __tstate = wxPyBeginAllowThreads();
6613 (arg1)->SetSize((wxSize const &)*arg2);
6614
6615 wxPyEndAllowThreads(__tstate);
6616 if (PyErr_Occurred()) SWIG_fail;
6617 }
6618 Py_INCREF(Py_None); resultobj = Py_None;
6619 return resultobj;
6620 fail:
6621 return NULL;
6622 }
6623
6624
6625 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6626 PyObject *resultobj;
6627 wxCaret *arg1 = (wxCaret *) 0 ;
6628 int arg2 = (int) true ;
6629 PyObject * obj0 = 0 ;
6630 PyObject * obj1 = 0 ;
6631 char *kwnames[] = {
6632 (char *) "self",(char *) "show", NULL
6633 };
6634
6635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6637 if (SWIG_arg_fail(1)) SWIG_fail;
6638 if (obj1) {
6639 {
6640 arg2 = (int)(SWIG_As_int(obj1));
6641 if (SWIG_arg_fail(2)) SWIG_fail;
6642 }
6643 }
6644 {
6645 PyThreadState* __tstate = wxPyBeginAllowThreads();
6646 (arg1)->Show(arg2);
6647
6648 wxPyEndAllowThreads(__tstate);
6649 if (PyErr_Occurred()) SWIG_fail;
6650 }
6651 Py_INCREF(Py_None); resultobj = Py_None;
6652 return resultobj;
6653 fail:
6654 return NULL;
6655 }
6656
6657
6658 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6659 PyObject *resultobj;
6660 wxCaret *arg1 = (wxCaret *) 0 ;
6661 PyObject * obj0 = 0 ;
6662 char *kwnames[] = {
6663 (char *) "self", NULL
6664 };
6665
6666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6668 if (SWIG_arg_fail(1)) SWIG_fail;
6669 {
6670 PyThreadState* __tstate = wxPyBeginAllowThreads();
6671 (arg1)->Hide();
6672
6673 wxPyEndAllowThreads(__tstate);
6674 if (PyErr_Occurred()) SWIG_fail;
6675 }
6676 Py_INCREF(Py_None); resultobj = Py_None;
6677 return resultobj;
6678 fail:
6679 return NULL;
6680 }
6681
6682
6683 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6684 PyObject *obj;
6685 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6686 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6687 Py_INCREF(obj);
6688 return Py_BuildValue((char *)"");
6689 }
6690 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6691 PyObject *resultobj;
6692 int result;
6693 char *kwnames[] = {
6694 NULL
6695 };
6696
6697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6698 {
6699 PyThreadState* __tstate = wxPyBeginAllowThreads();
6700 result = (int)wxCaret_GetBlinkTime();
6701
6702 wxPyEndAllowThreads(__tstate);
6703 if (PyErr_Occurred()) SWIG_fail;
6704 }
6705 {
6706 resultobj = SWIG_From_int((int)(result));
6707 }
6708 return resultobj;
6709 fail:
6710 return NULL;
6711 }
6712
6713
6714 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6715 PyObject *resultobj;
6716 int arg1 ;
6717 PyObject * obj0 = 0 ;
6718 char *kwnames[] = {
6719 (char *) "milliseconds", NULL
6720 };
6721
6722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6723 {
6724 arg1 = (int)(SWIG_As_int(obj0));
6725 if (SWIG_arg_fail(1)) SWIG_fail;
6726 }
6727 {
6728 PyThreadState* __tstate = wxPyBeginAllowThreads();
6729 wxCaret_SetBlinkTime(arg1);
6730
6731 wxPyEndAllowThreads(__tstate);
6732 if (PyErr_Occurred()) SWIG_fail;
6733 }
6734 Py_INCREF(Py_None); resultobj = Py_None;
6735 return resultobj;
6736 fail:
6737 return NULL;
6738 }
6739
6740
6741 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6742 PyObject *resultobj;
6743 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6744 wxBusyCursor *result;
6745 PyObject * obj0 = 0 ;
6746 char *kwnames[] = {
6747 (char *) "cursor", NULL
6748 };
6749
6750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6751 if (obj0) {
6752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6753 if (SWIG_arg_fail(1)) SWIG_fail;
6754 }
6755 {
6756 if (!wxPyCheckForApp()) SWIG_fail;
6757 PyThreadState* __tstate = wxPyBeginAllowThreads();
6758 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6759
6760 wxPyEndAllowThreads(__tstate);
6761 if (PyErr_Occurred()) SWIG_fail;
6762 }
6763 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6764 return resultobj;
6765 fail:
6766 return NULL;
6767 }
6768
6769
6770 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6771 PyObject *resultobj;
6772 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6773 PyObject * obj0 = 0 ;
6774 char *kwnames[] = {
6775 (char *) "self", NULL
6776 };
6777
6778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6780 if (SWIG_arg_fail(1)) SWIG_fail;
6781 {
6782 PyThreadState* __tstate = wxPyBeginAllowThreads();
6783 delete arg1;
6784
6785 wxPyEndAllowThreads(__tstate);
6786 if (PyErr_Occurred()) SWIG_fail;
6787 }
6788 Py_INCREF(Py_None); resultobj = Py_None;
6789 return resultobj;
6790 fail:
6791 return NULL;
6792 }
6793
6794
6795 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6796 PyObject *obj;
6797 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6798 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6799 Py_INCREF(obj);
6800 return Py_BuildValue((char *)"");
6801 }
6802 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6803 PyObject *resultobj;
6804 wxWindow *arg1 = (wxWindow *) NULL ;
6805 wxWindowDisabler *result;
6806 PyObject * obj0 = 0 ;
6807 char *kwnames[] = {
6808 (char *) "winToSkip", NULL
6809 };
6810
6811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6812 if (obj0) {
6813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6814 if (SWIG_arg_fail(1)) SWIG_fail;
6815 }
6816 {
6817 if (!wxPyCheckForApp()) SWIG_fail;
6818 PyThreadState* __tstate = wxPyBeginAllowThreads();
6819 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6820
6821 wxPyEndAllowThreads(__tstate);
6822 if (PyErr_Occurred()) SWIG_fail;
6823 }
6824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6825 return resultobj;
6826 fail:
6827 return NULL;
6828 }
6829
6830
6831 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6832 PyObject *resultobj;
6833 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6834 PyObject * obj0 = 0 ;
6835 char *kwnames[] = {
6836 (char *) "self", NULL
6837 };
6838
6839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6841 if (SWIG_arg_fail(1)) SWIG_fail;
6842 {
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 delete arg1;
6845
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 Py_INCREF(Py_None); resultobj = Py_None;
6850 return resultobj;
6851 fail:
6852 return NULL;
6853 }
6854
6855
6856 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6857 PyObject *obj;
6858 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6859 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6860 Py_INCREF(obj);
6861 return Py_BuildValue((char *)"");
6862 }
6863 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6864 PyObject *resultobj;
6865 wxString *arg1 = 0 ;
6866 wxBusyInfo *result;
6867 bool temp1 = false ;
6868 PyObject * obj0 = 0 ;
6869 char *kwnames[] = {
6870 (char *) "message", NULL
6871 };
6872
6873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
6874 {
6875 arg1 = wxString_in_helper(obj0);
6876 if (arg1 == NULL) SWIG_fail;
6877 temp1 = true;
6878 }
6879 {
6880 if (!wxPyCheckForApp()) SWIG_fail;
6881 PyThreadState* __tstate = wxPyBeginAllowThreads();
6882 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
6883
6884 wxPyEndAllowThreads(__tstate);
6885 if (PyErr_Occurred()) SWIG_fail;
6886 }
6887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
6888 {
6889 if (temp1)
6890 delete arg1;
6891 }
6892 return resultobj;
6893 fail:
6894 {
6895 if (temp1)
6896 delete arg1;
6897 }
6898 return NULL;
6899 }
6900
6901
6902 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6903 PyObject *resultobj;
6904 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
6905 PyObject * obj0 = 0 ;
6906 char *kwnames[] = {
6907 (char *) "self", NULL
6908 };
6909
6910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
6911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
6912 if (SWIG_arg_fail(1)) SWIG_fail;
6913 {
6914 PyThreadState* __tstate = wxPyBeginAllowThreads();
6915 delete arg1;
6916
6917 wxPyEndAllowThreads(__tstate);
6918 if (PyErr_Occurred()) SWIG_fail;
6919 }
6920 Py_INCREF(Py_None); resultobj = Py_None;
6921 return resultobj;
6922 fail:
6923 return NULL;
6924 }
6925
6926
6927 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
6928 PyObject *obj;
6929 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6930 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
6931 Py_INCREF(obj);
6932 return Py_BuildValue((char *)"");
6933 }
6934 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
6935 PyObject *resultobj;
6936 wxStopWatch *result;
6937 char *kwnames[] = {
6938 NULL
6939 };
6940
6941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
6942 {
6943 PyThreadState* __tstate = wxPyBeginAllowThreads();
6944 result = (wxStopWatch *)new wxStopWatch();
6945
6946 wxPyEndAllowThreads(__tstate);
6947 if (PyErr_Occurred()) SWIG_fail;
6948 }
6949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
6950 return resultobj;
6951 fail:
6952 return NULL;
6953 }
6954
6955
6956 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
6957 PyObject *resultobj;
6958 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
6959 long arg2 = (long) 0 ;
6960 PyObject * obj0 = 0 ;
6961 PyObject * obj1 = 0 ;
6962 char *kwnames[] = {
6963 (char *) "self",(char *) "t0", NULL
6964 };
6965
6966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
6967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
6968 if (SWIG_arg_fail(1)) SWIG_fail;
6969 if (obj1) {
6970 {
6971 arg2 = (long)(SWIG_As_long(obj1));
6972 if (SWIG_arg_fail(2)) SWIG_fail;
6973 }
6974 }
6975 {
6976 PyThreadState* __tstate = wxPyBeginAllowThreads();
6977 (arg1)->Start(arg2);
6978
6979 wxPyEndAllowThreads(__tstate);
6980 if (PyErr_Occurred()) SWIG_fail;
6981 }
6982 Py_INCREF(Py_None); resultobj = Py_None;
6983 return resultobj;
6984 fail:
6985 return NULL;
6986 }
6987
6988
6989 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
6990 PyObject *resultobj;
6991 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
6992 PyObject * obj0 = 0 ;
6993 char *kwnames[] = {
6994 (char *) "self", NULL
6995 };
6996
6997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
6998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
6999 if (SWIG_arg_fail(1)) SWIG_fail;
7000 {
7001 PyThreadState* __tstate = wxPyBeginAllowThreads();
7002 (arg1)->Pause();
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 *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7015 PyObject *resultobj;
7016 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7017 PyObject * obj0 = 0 ;
7018 char *kwnames[] = {
7019 (char *) "self", NULL
7020 };
7021
7022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7024 if (SWIG_arg_fail(1)) SWIG_fail;
7025 {
7026 PyThreadState* __tstate = wxPyBeginAllowThreads();
7027 (arg1)->Resume();
7028
7029 wxPyEndAllowThreads(__tstate);
7030 if (PyErr_Occurred()) SWIG_fail;
7031 }
7032 Py_INCREF(Py_None); resultobj = Py_None;
7033 return resultobj;
7034 fail:
7035 return NULL;
7036 }
7037
7038
7039 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7040 PyObject *resultobj;
7041 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7042 long result;
7043 PyObject * obj0 = 0 ;
7044 char *kwnames[] = {
7045 (char *) "self", NULL
7046 };
7047
7048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7050 if (SWIG_arg_fail(1)) SWIG_fail;
7051 {
7052 PyThreadState* __tstate = wxPyBeginAllowThreads();
7053 result = (long)((wxStopWatch const *)arg1)->Time();
7054
7055 wxPyEndAllowThreads(__tstate);
7056 if (PyErr_Occurred()) SWIG_fail;
7057 }
7058 {
7059 resultobj = SWIG_From_long((long)(result));
7060 }
7061 return resultobj;
7062 fail:
7063 return NULL;
7064 }
7065
7066
7067 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7068 PyObject *obj;
7069 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7070 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7071 Py_INCREF(obj);
7072 return Py_BuildValue((char *)"");
7073 }
7074 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7075 PyObject *resultobj;
7076 int arg1 = (int) 9 ;
7077 int arg2 = (int) wxID_FILE1 ;
7078 wxFileHistory *result;
7079 PyObject * obj0 = 0 ;
7080 PyObject * obj1 = 0 ;
7081 char *kwnames[] = {
7082 (char *) "maxFiles",(char *) "idBase", NULL
7083 };
7084
7085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7086 if (obj0) {
7087 {
7088 arg1 = (int)(SWIG_As_int(obj0));
7089 if (SWIG_arg_fail(1)) SWIG_fail;
7090 }
7091 }
7092 if (obj1) {
7093 {
7094 arg2 = (int)(SWIG_As_int(obj1));
7095 if (SWIG_arg_fail(2)) SWIG_fail;
7096 }
7097 }
7098 {
7099 PyThreadState* __tstate = wxPyBeginAllowThreads();
7100 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7101
7102 wxPyEndAllowThreads(__tstate);
7103 if (PyErr_Occurred()) SWIG_fail;
7104 }
7105 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7106 return resultobj;
7107 fail:
7108 return NULL;
7109 }
7110
7111
7112 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7113 PyObject *resultobj;
7114 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7115 PyObject * obj0 = 0 ;
7116 char *kwnames[] = {
7117 (char *) "self", NULL
7118 };
7119
7120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7122 if (SWIG_arg_fail(1)) SWIG_fail;
7123 {
7124 PyThreadState* __tstate = wxPyBeginAllowThreads();
7125 delete arg1;
7126
7127 wxPyEndAllowThreads(__tstate);
7128 if (PyErr_Occurred()) SWIG_fail;
7129 }
7130 Py_INCREF(Py_None); resultobj = Py_None;
7131 return resultobj;
7132 fail:
7133 return NULL;
7134 }
7135
7136
7137 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7138 PyObject *resultobj;
7139 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7140 wxString *arg2 = 0 ;
7141 bool temp2 = false ;
7142 PyObject * obj0 = 0 ;
7143 PyObject * obj1 = 0 ;
7144 char *kwnames[] = {
7145 (char *) "self",(char *) "file", NULL
7146 };
7147
7148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7150 if (SWIG_arg_fail(1)) SWIG_fail;
7151 {
7152 arg2 = wxString_in_helper(obj1);
7153 if (arg2 == NULL) SWIG_fail;
7154 temp2 = true;
7155 }
7156 {
7157 PyThreadState* __tstate = wxPyBeginAllowThreads();
7158 (arg1)->AddFileToHistory((wxString const &)*arg2);
7159
7160 wxPyEndAllowThreads(__tstate);
7161 if (PyErr_Occurred()) SWIG_fail;
7162 }
7163 Py_INCREF(Py_None); resultobj = Py_None;
7164 {
7165 if (temp2)
7166 delete arg2;
7167 }
7168 return resultobj;
7169 fail:
7170 {
7171 if (temp2)
7172 delete arg2;
7173 }
7174 return NULL;
7175 }
7176
7177
7178 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7179 PyObject *resultobj;
7180 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7181 int arg2 ;
7182 PyObject * obj0 = 0 ;
7183 PyObject * obj1 = 0 ;
7184 char *kwnames[] = {
7185 (char *) "self",(char *) "i", NULL
7186 };
7187
7188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7190 if (SWIG_arg_fail(1)) SWIG_fail;
7191 {
7192 arg2 = (int)(SWIG_As_int(obj1));
7193 if (SWIG_arg_fail(2)) SWIG_fail;
7194 }
7195 {
7196 PyThreadState* __tstate = wxPyBeginAllowThreads();
7197 (arg1)->RemoveFileFromHistory(arg2);
7198
7199 wxPyEndAllowThreads(__tstate);
7200 if (PyErr_Occurred()) SWIG_fail;
7201 }
7202 Py_INCREF(Py_None); resultobj = Py_None;
7203 return resultobj;
7204 fail:
7205 return NULL;
7206 }
7207
7208
7209 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7210 PyObject *resultobj;
7211 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7212 int result;
7213 PyObject * obj0 = 0 ;
7214 char *kwnames[] = {
7215 (char *) "self", NULL
7216 };
7217
7218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7220 if (SWIG_arg_fail(1)) SWIG_fail;
7221 {
7222 PyThreadState* __tstate = wxPyBeginAllowThreads();
7223 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7224
7225 wxPyEndAllowThreads(__tstate);
7226 if (PyErr_Occurred()) SWIG_fail;
7227 }
7228 {
7229 resultobj = SWIG_From_int((int)(result));
7230 }
7231 return resultobj;
7232 fail:
7233 return NULL;
7234 }
7235
7236
7237 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7238 PyObject *resultobj;
7239 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7240 wxMenu *arg2 = (wxMenu *) 0 ;
7241 PyObject * obj0 = 0 ;
7242 PyObject * obj1 = 0 ;
7243 char *kwnames[] = {
7244 (char *) "self",(char *) "menu", NULL
7245 };
7246
7247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7249 if (SWIG_arg_fail(1)) SWIG_fail;
7250 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7251 if (SWIG_arg_fail(2)) SWIG_fail;
7252 {
7253 PyThreadState* __tstate = wxPyBeginAllowThreads();
7254 (arg1)->UseMenu(arg2);
7255
7256 wxPyEndAllowThreads(__tstate);
7257 if (PyErr_Occurred()) SWIG_fail;
7258 }
7259 Py_INCREF(Py_None); resultobj = Py_None;
7260 return resultobj;
7261 fail:
7262 return NULL;
7263 }
7264
7265
7266 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7267 PyObject *resultobj;
7268 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7269 wxMenu *arg2 = (wxMenu *) 0 ;
7270 PyObject * obj0 = 0 ;
7271 PyObject * obj1 = 0 ;
7272 char *kwnames[] = {
7273 (char *) "self",(char *) "menu", NULL
7274 };
7275
7276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7278 if (SWIG_arg_fail(1)) SWIG_fail;
7279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7280 if (SWIG_arg_fail(2)) SWIG_fail;
7281 {
7282 PyThreadState* __tstate = wxPyBeginAllowThreads();
7283 (arg1)->RemoveMenu(arg2);
7284
7285 wxPyEndAllowThreads(__tstate);
7286 if (PyErr_Occurred()) SWIG_fail;
7287 }
7288 Py_INCREF(Py_None); resultobj = Py_None;
7289 return resultobj;
7290 fail:
7291 return NULL;
7292 }
7293
7294
7295 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7296 PyObject *resultobj;
7297 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7298 wxConfigBase *arg2 = 0 ;
7299 PyObject * obj0 = 0 ;
7300 PyObject * obj1 = 0 ;
7301 char *kwnames[] = {
7302 (char *) "self",(char *) "config", NULL
7303 };
7304
7305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7307 if (SWIG_arg_fail(1)) SWIG_fail;
7308 {
7309 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7310 if (SWIG_arg_fail(2)) SWIG_fail;
7311 if (arg2 == NULL) {
7312 SWIG_null_ref("wxConfigBase");
7313 }
7314 if (SWIG_arg_fail(2)) SWIG_fail;
7315 }
7316 {
7317 PyThreadState* __tstate = wxPyBeginAllowThreads();
7318 (arg1)->Load(*arg2);
7319
7320 wxPyEndAllowThreads(__tstate);
7321 if (PyErr_Occurred()) SWIG_fail;
7322 }
7323 Py_INCREF(Py_None); resultobj = Py_None;
7324 return resultobj;
7325 fail:
7326 return NULL;
7327 }
7328
7329
7330 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7331 PyObject *resultobj;
7332 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7333 wxConfigBase *arg2 = 0 ;
7334 PyObject * obj0 = 0 ;
7335 PyObject * obj1 = 0 ;
7336 char *kwnames[] = {
7337 (char *) "self",(char *) "config", NULL
7338 };
7339
7340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7342 if (SWIG_arg_fail(1)) SWIG_fail;
7343 {
7344 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7345 if (SWIG_arg_fail(2)) SWIG_fail;
7346 if (arg2 == NULL) {
7347 SWIG_null_ref("wxConfigBase");
7348 }
7349 if (SWIG_arg_fail(2)) SWIG_fail;
7350 }
7351 {
7352 PyThreadState* __tstate = wxPyBeginAllowThreads();
7353 (arg1)->Save(*arg2);
7354
7355 wxPyEndAllowThreads(__tstate);
7356 if (PyErr_Occurred()) SWIG_fail;
7357 }
7358 Py_INCREF(Py_None); resultobj = Py_None;
7359 return resultobj;
7360 fail:
7361 return NULL;
7362 }
7363
7364
7365 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7366 PyObject *resultobj;
7367 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7368 PyObject * obj0 = 0 ;
7369 char *kwnames[] = {
7370 (char *) "self", NULL
7371 };
7372
7373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7375 if (SWIG_arg_fail(1)) SWIG_fail;
7376 {
7377 PyThreadState* __tstate = wxPyBeginAllowThreads();
7378 (arg1)->AddFilesToMenu();
7379
7380 wxPyEndAllowThreads(__tstate);
7381 if (PyErr_Occurred()) SWIG_fail;
7382 }
7383 Py_INCREF(Py_None); resultobj = Py_None;
7384 return resultobj;
7385 fail:
7386 return NULL;
7387 }
7388
7389
7390 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7391 PyObject *resultobj;
7392 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7393 wxMenu *arg2 = (wxMenu *) 0 ;
7394 PyObject * obj0 = 0 ;
7395 PyObject * obj1 = 0 ;
7396 char *kwnames[] = {
7397 (char *) "self",(char *) "menu", NULL
7398 };
7399
7400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7402 if (SWIG_arg_fail(1)) SWIG_fail;
7403 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7404 if (SWIG_arg_fail(2)) SWIG_fail;
7405 {
7406 PyThreadState* __tstate = wxPyBeginAllowThreads();
7407 (arg1)->AddFilesToMenu(arg2);
7408
7409 wxPyEndAllowThreads(__tstate);
7410 if (PyErr_Occurred()) SWIG_fail;
7411 }
7412 Py_INCREF(Py_None); resultobj = Py_None;
7413 return resultobj;
7414 fail:
7415 return NULL;
7416 }
7417
7418
7419 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7420 PyObject *resultobj;
7421 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7422 int arg2 ;
7423 wxString result;
7424 PyObject * obj0 = 0 ;
7425 PyObject * obj1 = 0 ;
7426 char *kwnames[] = {
7427 (char *) "self",(char *) "i", NULL
7428 };
7429
7430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7432 if (SWIG_arg_fail(1)) SWIG_fail;
7433 {
7434 arg2 = (int)(SWIG_As_int(obj1));
7435 if (SWIG_arg_fail(2)) SWIG_fail;
7436 }
7437 {
7438 PyThreadState* __tstate = wxPyBeginAllowThreads();
7439 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7440
7441 wxPyEndAllowThreads(__tstate);
7442 if (PyErr_Occurred()) SWIG_fail;
7443 }
7444 {
7445 #if wxUSE_UNICODE
7446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7447 #else
7448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7449 #endif
7450 }
7451 return resultobj;
7452 fail:
7453 return NULL;
7454 }
7455
7456
7457 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7458 PyObject *resultobj;
7459 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7460 int result;
7461 PyObject * obj0 = 0 ;
7462 char *kwnames[] = {
7463 (char *) "self", NULL
7464 };
7465
7466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) 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 {
7470 PyThreadState* __tstate = wxPyBeginAllowThreads();
7471 result = (int)((wxFileHistory const *)arg1)->GetCount();
7472
7473 wxPyEndAllowThreads(__tstate);
7474 if (PyErr_Occurred()) SWIG_fail;
7475 }
7476 {
7477 resultobj = SWIG_From_int((int)(result));
7478 }
7479 return resultobj;
7480 fail:
7481 return NULL;
7482 }
7483
7484
7485 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7486 PyObject *obj;
7487 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7488 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7489 Py_INCREF(obj);
7490 return Py_BuildValue((char *)"");
7491 }
7492 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7493 PyObject *resultobj;
7494 wxString *arg1 = 0 ;
7495 wxString const &arg2_defvalue = wxPyEmptyString ;
7496 wxString *arg2 = (wxString *) &arg2_defvalue ;
7497 wxSingleInstanceChecker *result;
7498 bool temp1 = false ;
7499 bool temp2 = false ;
7500 PyObject * obj0 = 0 ;
7501 PyObject * obj1 = 0 ;
7502 char *kwnames[] = {
7503 (char *) "name",(char *) "path", NULL
7504 };
7505
7506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7507 {
7508 arg1 = wxString_in_helper(obj0);
7509 if (arg1 == NULL) SWIG_fail;
7510 temp1 = true;
7511 }
7512 if (obj1) {
7513 {
7514 arg2 = wxString_in_helper(obj1);
7515 if (arg2 == NULL) SWIG_fail;
7516 temp2 = true;
7517 }
7518 }
7519 {
7520 PyThreadState* __tstate = wxPyBeginAllowThreads();
7521 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7522
7523 wxPyEndAllowThreads(__tstate);
7524 if (PyErr_Occurred()) SWIG_fail;
7525 }
7526 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7527 {
7528 if (temp1)
7529 delete arg1;
7530 }
7531 {
7532 if (temp2)
7533 delete arg2;
7534 }
7535 return resultobj;
7536 fail:
7537 {
7538 if (temp1)
7539 delete arg1;
7540 }
7541 {
7542 if (temp2)
7543 delete arg2;
7544 }
7545 return NULL;
7546 }
7547
7548
7549 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7550 PyObject *resultobj;
7551 wxSingleInstanceChecker *result;
7552 char *kwnames[] = {
7553 NULL
7554 };
7555
7556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7557 {
7558 PyThreadState* __tstate = wxPyBeginAllowThreads();
7559 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7560
7561 wxPyEndAllowThreads(__tstate);
7562 if (PyErr_Occurred()) SWIG_fail;
7563 }
7564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7565 return resultobj;
7566 fail:
7567 return NULL;
7568 }
7569
7570
7571 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7572 PyObject *resultobj;
7573 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7574 PyObject * obj0 = 0 ;
7575 char *kwnames[] = {
7576 (char *) "self", NULL
7577 };
7578
7579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7581 if (SWIG_arg_fail(1)) SWIG_fail;
7582 {
7583 PyThreadState* __tstate = wxPyBeginAllowThreads();
7584 delete arg1;
7585
7586 wxPyEndAllowThreads(__tstate);
7587 if (PyErr_Occurred()) SWIG_fail;
7588 }
7589 Py_INCREF(Py_None); resultobj = Py_None;
7590 return resultobj;
7591 fail:
7592 return NULL;
7593 }
7594
7595
7596 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7597 PyObject *resultobj;
7598 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7599 wxString *arg2 = 0 ;
7600 wxString const &arg3_defvalue = wxPyEmptyString ;
7601 wxString *arg3 = (wxString *) &arg3_defvalue ;
7602 bool result;
7603 bool temp2 = false ;
7604 bool temp3 = false ;
7605 PyObject * obj0 = 0 ;
7606 PyObject * obj1 = 0 ;
7607 PyObject * obj2 = 0 ;
7608 char *kwnames[] = {
7609 (char *) "self",(char *) "name",(char *) "path", NULL
7610 };
7611
7612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7614 if (SWIG_arg_fail(1)) SWIG_fail;
7615 {
7616 arg2 = wxString_in_helper(obj1);
7617 if (arg2 == NULL) SWIG_fail;
7618 temp2 = true;
7619 }
7620 if (obj2) {
7621 {
7622 arg3 = wxString_in_helper(obj2);
7623 if (arg3 == NULL) SWIG_fail;
7624 temp3 = true;
7625 }
7626 }
7627 {
7628 PyThreadState* __tstate = wxPyBeginAllowThreads();
7629 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7630
7631 wxPyEndAllowThreads(__tstate);
7632 if (PyErr_Occurred()) SWIG_fail;
7633 }
7634 {
7635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7636 }
7637 {
7638 if (temp2)
7639 delete arg2;
7640 }
7641 {
7642 if (temp3)
7643 delete arg3;
7644 }
7645 return resultobj;
7646 fail:
7647 {
7648 if (temp2)
7649 delete arg2;
7650 }
7651 {
7652 if (temp3)
7653 delete arg3;
7654 }
7655 return NULL;
7656 }
7657
7658
7659 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7660 PyObject *resultobj;
7661 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7662 bool result;
7663 PyObject * obj0 = 0 ;
7664 char *kwnames[] = {
7665 (char *) "self", NULL
7666 };
7667
7668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7670 if (SWIG_arg_fail(1)) SWIG_fail;
7671 {
7672 PyThreadState* __tstate = wxPyBeginAllowThreads();
7673 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7674
7675 wxPyEndAllowThreads(__tstate);
7676 if (PyErr_Occurred()) SWIG_fail;
7677 }
7678 {
7679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7680 }
7681 return resultobj;
7682 fail:
7683 return NULL;
7684 }
7685
7686
7687 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7688 PyObject *obj;
7689 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7690 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7691 Py_INCREF(obj);
7692 return Py_BuildValue((char *)"");
7693 }
7694 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7695 PyObject *resultobj;
7696 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7697 PyObject * obj0 = 0 ;
7698 char *kwnames[] = {
7699 (char *) "self", NULL
7700 };
7701
7702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7704 if (SWIG_arg_fail(1)) SWIG_fail;
7705 {
7706 PyThreadState* __tstate = wxPyBeginAllowThreads();
7707 delete arg1;
7708
7709 wxPyEndAllowThreads(__tstate);
7710 if (PyErr_Occurred()) SWIG_fail;
7711 }
7712 Py_INCREF(Py_None); resultobj = Py_None;
7713 return resultobj;
7714 fail:
7715 return NULL;
7716 }
7717
7718
7719 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7720 PyObject *resultobj;
7721 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7722 wxString result;
7723 PyObject * obj0 = 0 ;
7724 char *kwnames[] = {
7725 (char *) "self", NULL
7726 };
7727
7728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7730 if (SWIG_arg_fail(1)) SWIG_fail;
7731 {
7732 PyThreadState* __tstate = wxPyBeginAllowThreads();
7733 result = (arg1)->GetTip();
7734
7735 wxPyEndAllowThreads(__tstate);
7736 if (PyErr_Occurred()) SWIG_fail;
7737 }
7738 {
7739 #if wxUSE_UNICODE
7740 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7741 #else
7742 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7743 #endif
7744 }
7745 return resultobj;
7746 fail:
7747 return NULL;
7748 }
7749
7750
7751 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7752 PyObject *resultobj;
7753 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7754 size_t result;
7755 PyObject * obj0 = 0 ;
7756 char *kwnames[] = {
7757 (char *) "self", NULL
7758 };
7759
7760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7762 if (SWIG_arg_fail(1)) SWIG_fail;
7763 {
7764 PyThreadState* __tstate = wxPyBeginAllowThreads();
7765 result = (size_t)(arg1)->GetCurrentTip();
7766
7767 wxPyEndAllowThreads(__tstate);
7768 if (PyErr_Occurred()) SWIG_fail;
7769 }
7770 {
7771 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7772 }
7773 return resultobj;
7774 fail:
7775 return NULL;
7776 }
7777
7778
7779 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7780 PyObject *resultobj;
7781 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7782 wxString *arg2 = 0 ;
7783 wxString result;
7784 bool temp2 = false ;
7785 PyObject * obj0 = 0 ;
7786 PyObject * obj1 = 0 ;
7787 char *kwnames[] = {
7788 (char *) "self",(char *) "tip", NULL
7789 };
7790
7791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7793 if (SWIG_arg_fail(1)) SWIG_fail;
7794 {
7795 arg2 = wxString_in_helper(obj1);
7796 if (arg2 == NULL) SWIG_fail;
7797 temp2 = true;
7798 }
7799 {
7800 PyThreadState* __tstate = wxPyBeginAllowThreads();
7801 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7802
7803 wxPyEndAllowThreads(__tstate);
7804 if (PyErr_Occurred()) SWIG_fail;
7805 }
7806 {
7807 #if wxUSE_UNICODE
7808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7809 #else
7810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7811 #endif
7812 }
7813 {
7814 if (temp2)
7815 delete arg2;
7816 }
7817 return resultobj;
7818 fail:
7819 {
7820 if (temp2)
7821 delete arg2;
7822 }
7823 return NULL;
7824 }
7825
7826
7827 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7828 PyObject *obj;
7829 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7830 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
7831 Py_INCREF(obj);
7832 return Py_BuildValue((char *)"");
7833 }
7834 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7835 PyObject *resultobj;
7836 size_t arg1 ;
7837 wxPyTipProvider *result;
7838 PyObject * obj0 = 0 ;
7839 char *kwnames[] = {
7840 (char *) "currentTip", NULL
7841 };
7842
7843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
7844 {
7845 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
7846 if (SWIG_arg_fail(1)) SWIG_fail;
7847 }
7848 {
7849 PyThreadState* __tstate = wxPyBeginAllowThreads();
7850 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
7851
7852 wxPyEndAllowThreads(__tstate);
7853 if (PyErr_Occurred()) SWIG_fail;
7854 }
7855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
7856 return resultobj;
7857 fail:
7858 return NULL;
7859 }
7860
7861
7862 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7863 PyObject *resultobj;
7864 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
7865 PyObject *arg2 = (PyObject *) 0 ;
7866 PyObject *arg3 = (PyObject *) 0 ;
7867 PyObject * obj0 = 0 ;
7868 PyObject * obj1 = 0 ;
7869 PyObject * obj2 = 0 ;
7870 char *kwnames[] = {
7871 (char *) "self",(char *) "self",(char *) "_class", NULL
7872 };
7873
7874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
7875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
7876 if (SWIG_arg_fail(1)) SWIG_fail;
7877 arg2 = obj1;
7878 arg3 = obj2;
7879 {
7880 PyThreadState* __tstate = wxPyBeginAllowThreads();
7881 (arg1)->_setCallbackInfo(arg2,arg3);
7882
7883 wxPyEndAllowThreads(__tstate);
7884 if (PyErr_Occurred()) SWIG_fail;
7885 }
7886 Py_INCREF(Py_None); resultobj = Py_None;
7887 return resultobj;
7888 fail:
7889 return NULL;
7890 }
7891
7892
7893 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
7894 PyObject *obj;
7895 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7896 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
7897 Py_INCREF(obj);
7898 return Py_BuildValue((char *)"");
7899 }
7900 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
7901 PyObject *resultobj;
7902 wxWindow *arg1 = (wxWindow *) 0 ;
7903 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
7904 bool arg3 = (bool) true ;
7905 bool result;
7906 PyObject * obj0 = 0 ;
7907 PyObject * obj1 = 0 ;
7908 PyObject * obj2 = 0 ;
7909 char *kwnames[] = {
7910 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
7911 };
7912
7913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
7914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7915 if (SWIG_arg_fail(1)) SWIG_fail;
7916 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7917 if (SWIG_arg_fail(2)) SWIG_fail;
7918 if (obj2) {
7919 {
7920 arg3 = (bool)(SWIG_As_bool(obj2));
7921 if (SWIG_arg_fail(3)) SWIG_fail;
7922 }
7923 }
7924 {
7925 if (!wxPyCheckForApp()) SWIG_fail;
7926 PyThreadState* __tstate = wxPyBeginAllowThreads();
7927 result = (bool)wxShowTip(arg1,arg2,arg3);
7928
7929 wxPyEndAllowThreads(__tstate);
7930 if (PyErr_Occurred()) SWIG_fail;
7931 }
7932 {
7933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7934 }
7935 return resultobj;
7936 fail:
7937 return NULL;
7938 }
7939
7940
7941 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7942 PyObject *resultobj;
7943 wxString *arg1 = 0 ;
7944 size_t arg2 ;
7945 wxTipProvider *result;
7946 bool temp1 = false ;
7947 PyObject * obj0 = 0 ;
7948 PyObject * obj1 = 0 ;
7949 char *kwnames[] = {
7950 (char *) "filename",(char *) "currentTip", NULL
7951 };
7952
7953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
7954 {
7955 arg1 = wxString_in_helper(obj0);
7956 if (arg1 == NULL) SWIG_fail;
7957 temp1 = true;
7958 }
7959 {
7960 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7961 if (SWIG_arg_fail(2)) SWIG_fail;
7962 }
7963 {
7964 if (!wxPyCheckForApp()) SWIG_fail;
7965 PyThreadState* __tstate = wxPyBeginAllowThreads();
7966 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
7967
7968 wxPyEndAllowThreads(__tstate);
7969 if (PyErr_Occurred()) SWIG_fail;
7970 }
7971 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
7972 {
7973 if (temp1)
7974 delete arg1;
7975 }
7976 return resultobj;
7977 fail:
7978 {
7979 if (temp1)
7980 delete arg1;
7981 }
7982 return NULL;
7983 }
7984
7985
7986 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
7987 PyObject *resultobj;
7988 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
7989 int arg2 = (int) -1 ;
7990 wxPyTimer *result;
7991 PyObject * obj0 = 0 ;
7992 PyObject * obj1 = 0 ;
7993 char *kwnames[] = {
7994 (char *) "owner",(char *) "id", NULL
7995 };
7996
7997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
7998 if (obj0) {
7999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8000 if (SWIG_arg_fail(1)) SWIG_fail;
8001 }
8002 if (obj1) {
8003 {
8004 arg2 = (int)(SWIG_As_int(obj1));
8005 if (SWIG_arg_fail(2)) SWIG_fail;
8006 }
8007 }
8008 {
8009 if (!wxPyCheckForApp()) SWIG_fail;
8010 PyThreadState* __tstate = wxPyBeginAllowThreads();
8011 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8012
8013 wxPyEndAllowThreads(__tstate);
8014 if (PyErr_Occurred()) SWIG_fail;
8015 }
8016 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8017 return resultobj;
8018 fail:
8019 return NULL;
8020 }
8021
8022
8023 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8024 PyObject *resultobj;
8025 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8026 PyObject * obj0 = 0 ;
8027 char *kwnames[] = {
8028 (char *) "self", NULL
8029 };
8030
8031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8033 if (SWIG_arg_fail(1)) SWIG_fail;
8034 {
8035 PyThreadState* __tstate = wxPyBeginAllowThreads();
8036 delete arg1;
8037
8038 wxPyEndAllowThreads(__tstate);
8039 if (PyErr_Occurred()) SWIG_fail;
8040 }
8041 Py_INCREF(Py_None); resultobj = Py_None;
8042 return resultobj;
8043 fail:
8044 return NULL;
8045 }
8046
8047
8048 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8049 PyObject *resultobj;
8050 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8051 PyObject *arg2 = (PyObject *) 0 ;
8052 PyObject *arg3 = (PyObject *) 0 ;
8053 int arg4 = (int) 1 ;
8054 PyObject * obj0 = 0 ;
8055 PyObject * obj1 = 0 ;
8056 PyObject * obj2 = 0 ;
8057 PyObject * obj3 = 0 ;
8058 char *kwnames[] = {
8059 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8060 };
8061
8062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8064 if (SWIG_arg_fail(1)) SWIG_fail;
8065 arg2 = obj1;
8066 arg3 = obj2;
8067 if (obj3) {
8068 {
8069 arg4 = (int)(SWIG_As_int(obj3));
8070 if (SWIG_arg_fail(4)) SWIG_fail;
8071 }
8072 }
8073 {
8074 PyThreadState* __tstate = wxPyBeginAllowThreads();
8075 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8076
8077 wxPyEndAllowThreads(__tstate);
8078 if (PyErr_Occurred()) SWIG_fail;
8079 }
8080 Py_INCREF(Py_None); resultobj = Py_None;
8081 return resultobj;
8082 fail:
8083 return NULL;
8084 }
8085
8086
8087 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8088 PyObject *resultobj;
8089 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8090 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8091 int arg3 = (int) -1 ;
8092 PyObject * obj0 = 0 ;
8093 PyObject * obj1 = 0 ;
8094 PyObject * obj2 = 0 ;
8095 char *kwnames[] = {
8096 (char *) "self",(char *) "owner",(char *) "id", NULL
8097 };
8098
8099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8101 if (SWIG_arg_fail(1)) SWIG_fail;
8102 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8103 if (SWIG_arg_fail(2)) SWIG_fail;
8104 if (obj2) {
8105 {
8106 arg3 = (int)(SWIG_As_int(obj2));
8107 if (SWIG_arg_fail(3)) SWIG_fail;
8108 }
8109 }
8110 {
8111 PyThreadState* __tstate = wxPyBeginAllowThreads();
8112 (arg1)->SetOwner(arg2,arg3);
8113
8114 wxPyEndAllowThreads(__tstate);
8115 if (PyErr_Occurred()) SWIG_fail;
8116 }
8117 Py_INCREF(Py_None); resultobj = Py_None;
8118 return resultobj;
8119 fail:
8120 return NULL;
8121 }
8122
8123
8124 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8125 PyObject *resultobj;
8126 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8127 wxEvtHandler *result;
8128 PyObject * obj0 = 0 ;
8129 char *kwnames[] = {
8130 (char *) "self", NULL
8131 };
8132
8133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8135 if (SWIG_arg_fail(1)) SWIG_fail;
8136 {
8137 PyThreadState* __tstate = wxPyBeginAllowThreads();
8138 result = (wxEvtHandler *)(arg1)->GetOwner();
8139
8140 wxPyEndAllowThreads(__tstate);
8141 if (PyErr_Occurred()) SWIG_fail;
8142 }
8143 {
8144 resultobj = wxPyMake_wxObject(result, 0);
8145 }
8146 return resultobj;
8147 fail:
8148 return NULL;
8149 }
8150
8151
8152 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8153 PyObject *resultobj;
8154 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8155 int arg2 = (int) -1 ;
8156 bool arg3 = (bool) false ;
8157 bool result;
8158 PyObject * obj0 = 0 ;
8159 PyObject * obj1 = 0 ;
8160 PyObject * obj2 = 0 ;
8161 char *kwnames[] = {
8162 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8163 };
8164
8165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8167 if (SWIG_arg_fail(1)) SWIG_fail;
8168 if (obj1) {
8169 {
8170 arg2 = (int)(SWIG_As_int(obj1));
8171 if (SWIG_arg_fail(2)) SWIG_fail;
8172 }
8173 }
8174 if (obj2) {
8175 {
8176 arg3 = (bool)(SWIG_As_bool(obj2));
8177 if (SWIG_arg_fail(3)) SWIG_fail;
8178 }
8179 }
8180 {
8181 PyThreadState* __tstate = wxPyBeginAllowThreads();
8182 result = (bool)(arg1)->Start(arg2,arg3);
8183
8184 wxPyEndAllowThreads(__tstate);
8185 if (PyErr_Occurred()) SWIG_fail;
8186 }
8187 {
8188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8189 }
8190 return resultobj;
8191 fail:
8192 return NULL;
8193 }
8194
8195
8196 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8197 PyObject *resultobj;
8198 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8199 PyObject * obj0 = 0 ;
8200 char *kwnames[] = {
8201 (char *) "self", NULL
8202 };
8203
8204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8206 if (SWIG_arg_fail(1)) SWIG_fail;
8207 {
8208 PyThreadState* __tstate = wxPyBeginAllowThreads();
8209 (arg1)->Stop();
8210
8211 wxPyEndAllowThreads(__tstate);
8212 if (PyErr_Occurred()) SWIG_fail;
8213 }
8214 Py_INCREF(Py_None); resultobj = Py_None;
8215 return resultobj;
8216 fail:
8217 return NULL;
8218 }
8219
8220
8221 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8222 PyObject *resultobj;
8223 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8224 bool result;
8225 PyObject * obj0 = 0 ;
8226 char *kwnames[] = {
8227 (char *) "self", NULL
8228 };
8229
8230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8232 if (SWIG_arg_fail(1)) SWIG_fail;
8233 {
8234 PyThreadState* __tstate = wxPyBeginAllowThreads();
8235 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8236
8237 wxPyEndAllowThreads(__tstate);
8238 if (PyErr_Occurred()) SWIG_fail;
8239 }
8240 {
8241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8242 }
8243 return resultobj;
8244 fail:
8245 return NULL;
8246 }
8247
8248
8249 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8250 PyObject *resultobj;
8251 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8252 int result;
8253 PyObject * obj0 = 0 ;
8254 char *kwnames[] = {
8255 (char *) "self", NULL
8256 };
8257
8258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8260 if (SWIG_arg_fail(1)) SWIG_fail;
8261 {
8262 PyThreadState* __tstate = wxPyBeginAllowThreads();
8263 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8264
8265 wxPyEndAllowThreads(__tstate);
8266 if (PyErr_Occurred()) SWIG_fail;
8267 }
8268 {
8269 resultobj = SWIG_From_int((int)(result));
8270 }
8271 return resultobj;
8272 fail:
8273 return NULL;
8274 }
8275
8276
8277 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8278 PyObject *resultobj;
8279 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8280 bool result;
8281 PyObject * obj0 = 0 ;
8282 char *kwnames[] = {
8283 (char *) "self", NULL
8284 };
8285
8286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8288 if (SWIG_arg_fail(1)) SWIG_fail;
8289 {
8290 PyThreadState* __tstate = wxPyBeginAllowThreads();
8291 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8292
8293 wxPyEndAllowThreads(__tstate);
8294 if (PyErr_Occurred()) SWIG_fail;
8295 }
8296 {
8297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8298 }
8299 return resultobj;
8300 fail:
8301 return NULL;
8302 }
8303
8304
8305 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8306 PyObject *resultobj;
8307 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8308 int result;
8309 PyObject * obj0 = 0 ;
8310 char *kwnames[] = {
8311 (char *) "self", NULL
8312 };
8313
8314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8316 if (SWIG_arg_fail(1)) SWIG_fail;
8317 {
8318 PyThreadState* __tstate = wxPyBeginAllowThreads();
8319 result = (int)((wxPyTimer const *)arg1)->GetId();
8320
8321 wxPyEndAllowThreads(__tstate);
8322 if (PyErr_Occurred()) SWIG_fail;
8323 }
8324 {
8325 resultobj = SWIG_From_int((int)(result));
8326 }
8327 return resultobj;
8328 fail:
8329 return NULL;
8330 }
8331
8332
8333 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8334 PyObject *obj;
8335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8336 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8337 Py_INCREF(obj);
8338 return Py_BuildValue((char *)"");
8339 }
8340 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8341 PyObject *resultobj;
8342 int arg1 = (int) 0 ;
8343 int arg2 = (int) 0 ;
8344 wxTimerEvent *result;
8345 PyObject * obj0 = 0 ;
8346 PyObject * obj1 = 0 ;
8347 char *kwnames[] = {
8348 (char *) "timerid",(char *) "interval", NULL
8349 };
8350
8351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8352 if (obj0) {
8353 {
8354 arg1 = (int)(SWIG_As_int(obj0));
8355 if (SWIG_arg_fail(1)) SWIG_fail;
8356 }
8357 }
8358 if (obj1) {
8359 {
8360 arg2 = (int)(SWIG_As_int(obj1));
8361 if (SWIG_arg_fail(2)) SWIG_fail;
8362 }
8363 }
8364 {
8365 PyThreadState* __tstate = wxPyBeginAllowThreads();
8366 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8367
8368 wxPyEndAllowThreads(__tstate);
8369 if (PyErr_Occurred()) SWIG_fail;
8370 }
8371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8372 return resultobj;
8373 fail:
8374 return NULL;
8375 }
8376
8377
8378 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8379 PyObject *resultobj;
8380 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8381 int result;
8382 PyObject * obj0 = 0 ;
8383 char *kwnames[] = {
8384 (char *) "self", NULL
8385 };
8386
8387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8389 if (SWIG_arg_fail(1)) SWIG_fail;
8390 {
8391 PyThreadState* __tstate = wxPyBeginAllowThreads();
8392 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8393
8394 wxPyEndAllowThreads(__tstate);
8395 if (PyErr_Occurred()) SWIG_fail;
8396 }
8397 {
8398 resultobj = SWIG_From_int((int)(result));
8399 }
8400 return resultobj;
8401 fail:
8402 return NULL;
8403 }
8404
8405
8406 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8407 PyObject *obj;
8408 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8409 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8410 Py_INCREF(obj);
8411 return Py_BuildValue((char *)"");
8412 }
8413 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8414 PyObject *resultobj;
8415 wxTimer *arg1 = 0 ;
8416 wxTimerRunner *result;
8417 PyObject * obj0 = 0 ;
8418
8419 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8420 {
8421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8422 if (SWIG_arg_fail(1)) SWIG_fail;
8423 if (arg1 == NULL) {
8424 SWIG_null_ref("wxTimer");
8425 }
8426 if (SWIG_arg_fail(1)) SWIG_fail;
8427 }
8428 {
8429 if (!wxPyCheckForApp()) SWIG_fail;
8430 PyThreadState* __tstate = wxPyBeginAllowThreads();
8431 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8432
8433 wxPyEndAllowThreads(__tstate);
8434 if (PyErr_Occurred()) SWIG_fail;
8435 }
8436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8437 return resultobj;
8438 fail:
8439 return NULL;
8440 }
8441
8442
8443 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8444 PyObject *resultobj;
8445 wxTimer *arg1 = 0 ;
8446 int arg2 ;
8447 bool arg3 = (bool) false ;
8448 wxTimerRunner *result;
8449 PyObject * obj0 = 0 ;
8450 PyObject * obj1 = 0 ;
8451 PyObject * obj2 = 0 ;
8452
8453 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8454 {
8455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8456 if (SWIG_arg_fail(1)) SWIG_fail;
8457 if (arg1 == NULL) {
8458 SWIG_null_ref("wxTimer");
8459 }
8460 if (SWIG_arg_fail(1)) SWIG_fail;
8461 }
8462 {
8463 arg2 = (int)(SWIG_As_int(obj1));
8464 if (SWIG_arg_fail(2)) SWIG_fail;
8465 }
8466 if (obj2) {
8467 {
8468 arg3 = (bool)(SWIG_As_bool(obj2));
8469 if (SWIG_arg_fail(3)) SWIG_fail;
8470 }
8471 }
8472 {
8473 if (!wxPyCheckForApp()) SWIG_fail;
8474 PyThreadState* __tstate = wxPyBeginAllowThreads();
8475 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8476
8477 wxPyEndAllowThreads(__tstate);
8478 if (PyErr_Occurred()) SWIG_fail;
8479 }
8480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8481 return resultobj;
8482 fail:
8483 return NULL;
8484 }
8485
8486
8487 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8488 int argc;
8489 PyObject *argv[4];
8490 int ii;
8491
8492 argc = PyObject_Length(args);
8493 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8494 argv[ii] = PyTuple_GetItem(args,ii);
8495 }
8496 if (argc == 1) {
8497 int _v;
8498 {
8499 void *ptr = 0;
8500 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8501 _v = 0;
8502 PyErr_Clear();
8503 } else {
8504 _v = (ptr != 0);
8505 }
8506 }
8507 if (_v) {
8508 return _wrap_new_TimerRunner__SWIG_0(self,args);
8509 }
8510 }
8511 if ((argc >= 2) && (argc <= 3)) {
8512 int _v;
8513 {
8514 void *ptr = 0;
8515 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8516 _v = 0;
8517 PyErr_Clear();
8518 } else {
8519 _v = (ptr != 0);
8520 }
8521 }
8522 if (_v) {
8523 _v = SWIG_Check_int(argv[1]);
8524 if (_v) {
8525 if (argc <= 2) {
8526 return _wrap_new_TimerRunner__SWIG_1(self,args);
8527 }
8528 _v = SWIG_Check_bool(argv[2]);
8529 if (_v) {
8530 return _wrap_new_TimerRunner__SWIG_1(self,args);
8531 }
8532 }
8533 }
8534 }
8535
8536 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8537 return NULL;
8538 }
8539
8540
8541 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8542 PyObject *resultobj;
8543 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8544 PyObject * obj0 = 0 ;
8545 char *kwnames[] = {
8546 (char *) "self", NULL
8547 };
8548
8549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8551 if (SWIG_arg_fail(1)) SWIG_fail;
8552 {
8553 PyThreadState* __tstate = wxPyBeginAllowThreads();
8554 delete arg1;
8555
8556 wxPyEndAllowThreads(__tstate);
8557 if (PyErr_Occurred()) SWIG_fail;
8558 }
8559 Py_INCREF(Py_None); resultobj = Py_None;
8560 return resultobj;
8561 fail:
8562 return NULL;
8563 }
8564
8565
8566 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8567 PyObject *resultobj;
8568 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8569 int arg2 ;
8570 bool arg3 = (bool) false ;
8571 PyObject * obj0 = 0 ;
8572 PyObject * obj1 = 0 ;
8573 PyObject * obj2 = 0 ;
8574 char *kwnames[] = {
8575 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8576 };
8577
8578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8580 if (SWIG_arg_fail(1)) SWIG_fail;
8581 {
8582 arg2 = (int)(SWIG_As_int(obj1));
8583 if (SWIG_arg_fail(2)) SWIG_fail;
8584 }
8585 if (obj2) {
8586 {
8587 arg3 = (bool)(SWIG_As_bool(obj2));
8588 if (SWIG_arg_fail(3)) SWIG_fail;
8589 }
8590 }
8591 {
8592 PyThreadState* __tstate = wxPyBeginAllowThreads();
8593 (arg1)->Start(arg2,arg3);
8594
8595 wxPyEndAllowThreads(__tstate);
8596 if (PyErr_Occurred()) SWIG_fail;
8597 }
8598 Py_INCREF(Py_None); resultobj = Py_None;
8599 return resultobj;
8600 fail:
8601 return NULL;
8602 }
8603
8604
8605 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8606 PyObject *obj;
8607 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8608 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8609 Py_INCREF(obj);
8610 return Py_BuildValue((char *)"");
8611 }
8612 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8613 PyObject *resultobj;
8614 wxLog *result;
8615 char *kwnames[] = {
8616 NULL
8617 };
8618
8619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8620 {
8621 PyThreadState* __tstate = wxPyBeginAllowThreads();
8622 result = (wxLog *)new wxLog();
8623
8624 wxPyEndAllowThreads(__tstate);
8625 if (PyErr_Occurred()) SWIG_fail;
8626 }
8627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8628 return resultobj;
8629 fail:
8630 return NULL;
8631 }
8632
8633
8634 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8635 PyObject *resultobj;
8636 bool result;
8637 char *kwnames[] = {
8638 NULL
8639 };
8640
8641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8642 {
8643 PyThreadState* __tstate = wxPyBeginAllowThreads();
8644 result = (bool)wxLog::IsEnabled();
8645
8646 wxPyEndAllowThreads(__tstate);
8647 if (PyErr_Occurred()) SWIG_fail;
8648 }
8649 {
8650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8651 }
8652 return resultobj;
8653 fail:
8654 return NULL;
8655 }
8656
8657
8658 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8659 PyObject *resultobj;
8660 bool arg1 = (bool) true ;
8661 bool result;
8662 PyObject * obj0 = 0 ;
8663 char *kwnames[] = {
8664 (char *) "doIt", NULL
8665 };
8666
8667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8668 if (obj0) {
8669 {
8670 arg1 = (bool)(SWIG_As_bool(obj0));
8671 if (SWIG_arg_fail(1)) SWIG_fail;
8672 }
8673 }
8674 {
8675 PyThreadState* __tstate = wxPyBeginAllowThreads();
8676 result = (bool)wxLog::EnableLogging(arg1);
8677
8678 wxPyEndAllowThreads(__tstate);
8679 if (PyErr_Occurred()) SWIG_fail;
8680 }
8681 {
8682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8683 }
8684 return resultobj;
8685 fail:
8686 return NULL;
8687 }
8688
8689
8690 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8691 PyObject *resultobj;
8692 wxLogLevel arg1 ;
8693 wxChar *arg2 = (wxChar *) 0 ;
8694 time_t arg3 ;
8695 PyObject * obj0 = 0 ;
8696 PyObject * obj1 = 0 ;
8697 PyObject * obj2 = 0 ;
8698 char *kwnames[] = {
8699 (char *) "level",(char *) "szString",(char *) "t", NULL
8700 };
8701
8702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8703 {
8704 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8705 if (SWIG_arg_fail(1)) SWIG_fail;
8706 }
8707 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8708 if (SWIG_arg_fail(2)) SWIG_fail;
8709 {
8710 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8711 if (SWIG_arg_fail(3)) SWIG_fail;
8712 }
8713 {
8714 PyThreadState* __tstate = wxPyBeginAllowThreads();
8715 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8716
8717 wxPyEndAllowThreads(__tstate);
8718 if (PyErr_Occurred()) SWIG_fail;
8719 }
8720 Py_INCREF(Py_None); resultobj = Py_None;
8721 return resultobj;
8722 fail:
8723 return NULL;
8724 }
8725
8726
8727 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8728 PyObject *resultobj;
8729 wxLog *arg1 = (wxLog *) 0 ;
8730 PyObject * obj0 = 0 ;
8731 char *kwnames[] = {
8732 (char *) "self", NULL
8733 };
8734
8735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8737 if (SWIG_arg_fail(1)) SWIG_fail;
8738 {
8739 PyThreadState* __tstate = wxPyBeginAllowThreads();
8740 (arg1)->Flush();
8741
8742 wxPyEndAllowThreads(__tstate);
8743 if (PyErr_Occurred()) SWIG_fail;
8744 }
8745 Py_INCREF(Py_None); resultobj = Py_None;
8746 return resultobj;
8747 fail:
8748 return NULL;
8749 }
8750
8751
8752 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8753 PyObject *resultobj;
8754 char *kwnames[] = {
8755 NULL
8756 };
8757
8758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8759 {
8760 PyThreadState* __tstate = wxPyBeginAllowThreads();
8761 wxLog::FlushActive();
8762
8763 wxPyEndAllowThreads(__tstate);
8764 if (PyErr_Occurred()) SWIG_fail;
8765 }
8766 Py_INCREF(Py_None); resultobj = Py_None;
8767 return resultobj;
8768 fail:
8769 return NULL;
8770 }
8771
8772
8773 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8774 PyObject *resultobj;
8775 wxLog *result;
8776 char *kwnames[] = {
8777 NULL
8778 };
8779
8780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8781 {
8782 PyThreadState* __tstate = wxPyBeginAllowThreads();
8783 result = (wxLog *)wxLog::GetActiveTarget();
8784
8785 wxPyEndAllowThreads(__tstate);
8786 if (PyErr_Occurred()) SWIG_fail;
8787 }
8788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8789 return resultobj;
8790 fail:
8791 return NULL;
8792 }
8793
8794
8795 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8796 PyObject *resultobj;
8797 wxLog *arg1 = (wxLog *) 0 ;
8798 wxLog *result;
8799 PyObject * obj0 = 0 ;
8800 char *kwnames[] = {
8801 (char *) "pLogger", NULL
8802 };
8803
8804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8806 if (SWIG_arg_fail(1)) SWIG_fail;
8807 {
8808 PyThreadState* __tstate = wxPyBeginAllowThreads();
8809 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8810
8811 wxPyEndAllowThreads(__tstate);
8812 if (PyErr_Occurred()) SWIG_fail;
8813 }
8814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8815 return resultobj;
8816 fail:
8817 return NULL;
8818 }
8819
8820
8821 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8822 PyObject *resultobj;
8823 char *kwnames[] = {
8824 NULL
8825 };
8826
8827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8828 {
8829 PyThreadState* __tstate = wxPyBeginAllowThreads();
8830 wxLog::Suspend();
8831
8832 wxPyEndAllowThreads(__tstate);
8833 if (PyErr_Occurred()) SWIG_fail;
8834 }
8835 Py_INCREF(Py_None); resultobj = Py_None;
8836 return resultobj;
8837 fail:
8838 return NULL;
8839 }
8840
8841
8842 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8843 PyObject *resultobj;
8844 char *kwnames[] = {
8845 NULL
8846 };
8847
8848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
8849 {
8850 PyThreadState* __tstate = wxPyBeginAllowThreads();
8851 wxLog::Resume();
8852
8853 wxPyEndAllowThreads(__tstate);
8854 if (PyErr_Occurred()) SWIG_fail;
8855 }
8856 Py_INCREF(Py_None); resultobj = Py_None;
8857 return resultobj;
8858 fail:
8859 return NULL;
8860 }
8861
8862
8863 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
8864 PyObject *resultobj;
8865 bool arg1 = (bool) true ;
8866 PyObject * obj0 = 0 ;
8867 char *kwnames[] = {
8868 (char *) "bVerbose", NULL
8869 };
8870
8871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
8872 if (obj0) {
8873 {
8874 arg1 = (bool)(SWIG_As_bool(obj0));
8875 if (SWIG_arg_fail(1)) SWIG_fail;
8876 }
8877 }
8878 {
8879 PyThreadState* __tstate = wxPyBeginAllowThreads();
8880 wxLog::SetVerbose(arg1);
8881
8882 wxPyEndAllowThreads(__tstate);
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 Py_INCREF(Py_None); resultobj = Py_None;
8886 return resultobj;
8887 fail:
8888 return NULL;
8889 }
8890
8891
8892 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
8893 PyObject *resultobj;
8894 wxLogLevel arg1 ;
8895 PyObject * obj0 = 0 ;
8896 char *kwnames[] = {
8897 (char *) "logLevel", NULL
8898 };
8899
8900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
8901 {
8902 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8903 if (SWIG_arg_fail(1)) SWIG_fail;
8904 }
8905 {
8906 PyThreadState* __tstate = wxPyBeginAllowThreads();
8907 wxLog::SetLogLevel(arg1);
8908
8909 wxPyEndAllowThreads(__tstate);
8910 if (PyErr_Occurred()) SWIG_fail;
8911 }
8912 Py_INCREF(Py_None); resultobj = Py_None;
8913 return resultobj;
8914 fail:
8915 return NULL;
8916 }
8917
8918
8919 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
8920 PyObject *resultobj;
8921 char *kwnames[] = {
8922 NULL
8923 };
8924
8925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
8926 {
8927 PyThreadState* __tstate = wxPyBeginAllowThreads();
8928 wxLog::DontCreateOnDemand();
8929
8930 wxPyEndAllowThreads(__tstate);
8931 if (PyErr_Occurred()) SWIG_fail;
8932 }
8933 Py_INCREF(Py_None); resultobj = Py_None;
8934 return resultobj;
8935 fail:
8936 return NULL;
8937 }
8938
8939
8940 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8941 PyObject *resultobj;
8942 wxTraceMask arg1 ;
8943 PyObject * obj0 = 0 ;
8944 char *kwnames[] = {
8945 (char *) "ulMask", NULL
8946 };
8947
8948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
8949 {
8950 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
8951 if (SWIG_arg_fail(1)) SWIG_fail;
8952 }
8953 {
8954 PyThreadState* __tstate = wxPyBeginAllowThreads();
8955 wxLog::SetTraceMask(arg1);
8956
8957 wxPyEndAllowThreads(__tstate);
8958 if (PyErr_Occurred()) SWIG_fail;
8959 }
8960 Py_INCREF(Py_None); resultobj = Py_None;
8961 return resultobj;
8962 fail:
8963 return NULL;
8964 }
8965
8966
8967 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8968 PyObject *resultobj;
8969 wxString *arg1 = 0 ;
8970 bool temp1 = false ;
8971 PyObject * obj0 = 0 ;
8972 char *kwnames[] = {
8973 (char *) "str", NULL
8974 };
8975
8976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
8977 {
8978 arg1 = wxString_in_helper(obj0);
8979 if (arg1 == NULL) SWIG_fail;
8980 temp1 = true;
8981 }
8982 {
8983 PyThreadState* __tstate = wxPyBeginAllowThreads();
8984 wxLog::AddTraceMask((wxString const &)*arg1);
8985
8986 wxPyEndAllowThreads(__tstate);
8987 if (PyErr_Occurred()) SWIG_fail;
8988 }
8989 Py_INCREF(Py_None); resultobj = Py_None;
8990 {
8991 if (temp1)
8992 delete arg1;
8993 }
8994 return resultobj;
8995 fail:
8996 {
8997 if (temp1)
8998 delete arg1;
8999 }
9000 return NULL;
9001 }
9002
9003
9004 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9005 PyObject *resultobj;
9006 wxString *arg1 = 0 ;
9007 bool temp1 = false ;
9008 PyObject * obj0 = 0 ;
9009 char *kwnames[] = {
9010 (char *) "str", NULL
9011 };
9012
9013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9014 {
9015 arg1 = wxString_in_helper(obj0);
9016 if (arg1 == NULL) SWIG_fail;
9017 temp1 = true;
9018 }
9019 {
9020 PyThreadState* __tstate = wxPyBeginAllowThreads();
9021 wxLog::RemoveTraceMask((wxString const &)*arg1);
9022
9023 wxPyEndAllowThreads(__tstate);
9024 if (PyErr_Occurred()) SWIG_fail;
9025 }
9026 Py_INCREF(Py_None); resultobj = Py_None;
9027 {
9028 if (temp1)
9029 delete arg1;
9030 }
9031 return resultobj;
9032 fail:
9033 {
9034 if (temp1)
9035 delete arg1;
9036 }
9037 return NULL;
9038 }
9039
9040
9041 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9042 PyObject *resultobj;
9043 char *kwnames[] = {
9044 NULL
9045 };
9046
9047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9048 {
9049 PyThreadState* __tstate = wxPyBeginAllowThreads();
9050 wxLog::ClearTraceMasks();
9051
9052 wxPyEndAllowThreads(__tstate);
9053 if (PyErr_Occurred()) SWIG_fail;
9054 }
9055 Py_INCREF(Py_None); resultobj = Py_None;
9056 return resultobj;
9057 fail:
9058 return NULL;
9059 }
9060
9061
9062 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9063 PyObject *resultobj;
9064 wxArrayString *result;
9065 char *kwnames[] = {
9066 NULL
9067 };
9068
9069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9070 {
9071 PyThreadState* __tstate = wxPyBeginAllowThreads();
9072 {
9073 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9074 result = (wxArrayString *) &_result_ref;
9075 }
9076
9077 wxPyEndAllowThreads(__tstate);
9078 if (PyErr_Occurred()) SWIG_fail;
9079 }
9080 {
9081 resultobj = wxArrayString2PyList_helper(*result);
9082 }
9083 return resultobj;
9084 fail:
9085 return NULL;
9086 }
9087
9088
9089 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9090 PyObject *resultobj;
9091 wxChar *arg1 = (wxChar *) 0 ;
9092 PyObject * obj0 = 0 ;
9093 char *kwnames[] = {
9094 (char *) "ts", NULL
9095 };
9096
9097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9099 if (SWIG_arg_fail(1)) SWIG_fail;
9100 {
9101 PyThreadState* __tstate = wxPyBeginAllowThreads();
9102 wxLog::SetTimestamp((wxChar const *)arg1);
9103
9104 wxPyEndAllowThreads(__tstate);
9105 if (PyErr_Occurred()) SWIG_fail;
9106 }
9107 Py_INCREF(Py_None); resultobj = Py_None;
9108 return resultobj;
9109 fail:
9110 return NULL;
9111 }
9112
9113
9114 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9115 PyObject *resultobj;
9116 bool result;
9117 char *kwnames[] = {
9118 NULL
9119 };
9120
9121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9122 {
9123 PyThreadState* __tstate = wxPyBeginAllowThreads();
9124 result = (bool)wxLog::GetVerbose();
9125
9126 wxPyEndAllowThreads(__tstate);
9127 if (PyErr_Occurred()) SWIG_fail;
9128 }
9129 {
9130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9131 }
9132 return resultobj;
9133 fail:
9134 return NULL;
9135 }
9136
9137
9138 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9139 PyObject *resultobj;
9140 wxTraceMask result;
9141 char *kwnames[] = {
9142 NULL
9143 };
9144
9145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9146 {
9147 PyThreadState* __tstate = wxPyBeginAllowThreads();
9148 result = (wxTraceMask)wxLog::GetTraceMask();
9149
9150 wxPyEndAllowThreads(__tstate);
9151 if (PyErr_Occurred()) SWIG_fail;
9152 }
9153 {
9154 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9155 }
9156 return resultobj;
9157 fail:
9158 return NULL;
9159 }
9160
9161
9162 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9163 PyObject *resultobj;
9164 wxChar *arg1 = (wxChar *) 0 ;
9165 bool result;
9166 PyObject * obj0 = 0 ;
9167 char *kwnames[] = {
9168 (char *) "mask", NULL
9169 };
9170
9171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9173 if (SWIG_arg_fail(1)) SWIG_fail;
9174 {
9175 PyThreadState* __tstate = wxPyBeginAllowThreads();
9176 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9177
9178 wxPyEndAllowThreads(__tstate);
9179 if (PyErr_Occurred()) SWIG_fail;
9180 }
9181 {
9182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9183 }
9184 return resultobj;
9185 fail:
9186 return NULL;
9187 }
9188
9189
9190 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9191 PyObject *resultobj;
9192 wxLogLevel result;
9193 char *kwnames[] = {
9194 NULL
9195 };
9196
9197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9198 {
9199 PyThreadState* __tstate = wxPyBeginAllowThreads();
9200 result = (wxLogLevel)wxLog::GetLogLevel();
9201
9202 wxPyEndAllowThreads(__tstate);
9203 if (PyErr_Occurred()) SWIG_fail;
9204 }
9205 {
9206 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9207 }
9208 return resultobj;
9209 fail:
9210 return NULL;
9211 }
9212
9213
9214 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9215 PyObject *resultobj;
9216 wxChar *result;
9217 char *kwnames[] = {
9218 NULL
9219 };
9220
9221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9222 {
9223 PyThreadState* __tstate = wxPyBeginAllowThreads();
9224 result = (wxChar *)wxLog::GetTimestamp();
9225
9226 wxPyEndAllowThreads(__tstate);
9227 if (PyErr_Occurred()) SWIG_fail;
9228 }
9229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9230 return resultobj;
9231 fail:
9232 return NULL;
9233 }
9234
9235
9236 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9237 PyObject *resultobj;
9238 wxString result;
9239 char *kwnames[] = {
9240 NULL
9241 };
9242
9243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9244 {
9245 PyThreadState* __tstate = wxPyBeginAllowThreads();
9246 result = Log_TimeStamp();
9247
9248 wxPyEndAllowThreads(__tstate);
9249 if (PyErr_Occurred()) SWIG_fail;
9250 }
9251 {
9252 #if wxUSE_UNICODE
9253 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9254 #else
9255 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9256 #endif
9257 }
9258 return resultobj;
9259 fail:
9260 return NULL;
9261 }
9262
9263
9264 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9265 PyObject *resultobj;
9266 wxLog *arg1 = (wxLog *) 0 ;
9267 PyObject * obj0 = 0 ;
9268 char *kwnames[] = {
9269 (char *) "self", NULL
9270 };
9271
9272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9274 if (SWIG_arg_fail(1)) SWIG_fail;
9275 {
9276 PyThreadState* __tstate = wxPyBeginAllowThreads();
9277 wxLog_Destroy(arg1);
9278
9279 wxPyEndAllowThreads(__tstate);
9280 if (PyErr_Occurred()) SWIG_fail;
9281 }
9282 Py_INCREF(Py_None); resultobj = Py_None;
9283 return resultobj;
9284 fail:
9285 return NULL;
9286 }
9287
9288
9289 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9290 PyObject *obj;
9291 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9292 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9293 Py_INCREF(obj);
9294 return Py_BuildValue((char *)"");
9295 }
9296 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9297 PyObject *resultobj;
9298 wxLogStderr *result;
9299 char *kwnames[] = {
9300 NULL
9301 };
9302
9303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9304 {
9305 PyThreadState* __tstate = wxPyBeginAllowThreads();
9306 result = (wxLogStderr *)new wxLogStderr();
9307
9308 wxPyEndAllowThreads(__tstate);
9309 if (PyErr_Occurred()) SWIG_fail;
9310 }
9311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9312 return resultobj;
9313 fail:
9314 return NULL;
9315 }
9316
9317
9318 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9319 PyObject *obj;
9320 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9321 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9322 Py_INCREF(obj);
9323 return Py_BuildValue((char *)"");
9324 }
9325 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9326 PyObject *resultobj;
9327 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9328 wxLogTextCtrl *result;
9329 PyObject * obj0 = 0 ;
9330 char *kwnames[] = {
9331 (char *) "pTextCtrl", NULL
9332 };
9333
9334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9336 if (SWIG_arg_fail(1)) SWIG_fail;
9337 {
9338 PyThreadState* __tstate = wxPyBeginAllowThreads();
9339 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9340
9341 wxPyEndAllowThreads(__tstate);
9342 if (PyErr_Occurred()) SWIG_fail;
9343 }
9344 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9345 return resultobj;
9346 fail:
9347 return NULL;
9348 }
9349
9350
9351 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9352 PyObject *obj;
9353 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9354 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9355 Py_INCREF(obj);
9356 return Py_BuildValue((char *)"");
9357 }
9358 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9359 PyObject *resultobj;
9360 wxLogGui *result;
9361 char *kwnames[] = {
9362 NULL
9363 };
9364
9365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9366 {
9367 PyThreadState* __tstate = wxPyBeginAllowThreads();
9368 result = (wxLogGui *)new wxLogGui();
9369
9370 wxPyEndAllowThreads(__tstate);
9371 if (PyErr_Occurred()) SWIG_fail;
9372 }
9373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9374 return resultobj;
9375 fail:
9376 return NULL;
9377 }
9378
9379
9380 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9381 PyObject *obj;
9382 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9383 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9384 Py_INCREF(obj);
9385 return Py_BuildValue((char *)"");
9386 }
9387 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9388 PyObject *resultobj;
9389 wxFrame *arg1 = (wxFrame *) 0 ;
9390 wxString *arg2 = 0 ;
9391 bool arg3 = (bool) true ;
9392 bool arg4 = (bool) true ;
9393 wxLogWindow *result;
9394 bool temp2 = false ;
9395 PyObject * obj0 = 0 ;
9396 PyObject * obj1 = 0 ;
9397 PyObject * obj2 = 0 ;
9398 PyObject * obj3 = 0 ;
9399 char *kwnames[] = {
9400 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9401 };
9402
9403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9405 if (SWIG_arg_fail(1)) SWIG_fail;
9406 {
9407 arg2 = wxString_in_helper(obj1);
9408 if (arg2 == NULL) SWIG_fail;
9409 temp2 = true;
9410 }
9411 if (obj2) {
9412 {
9413 arg3 = (bool)(SWIG_As_bool(obj2));
9414 if (SWIG_arg_fail(3)) SWIG_fail;
9415 }
9416 }
9417 if (obj3) {
9418 {
9419 arg4 = (bool)(SWIG_As_bool(obj3));
9420 if (SWIG_arg_fail(4)) SWIG_fail;
9421 }
9422 }
9423 {
9424 PyThreadState* __tstate = wxPyBeginAllowThreads();
9425 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9426
9427 wxPyEndAllowThreads(__tstate);
9428 if (PyErr_Occurred()) SWIG_fail;
9429 }
9430 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9431 {
9432 if (temp2)
9433 delete arg2;
9434 }
9435 return resultobj;
9436 fail:
9437 {
9438 if (temp2)
9439 delete arg2;
9440 }
9441 return NULL;
9442 }
9443
9444
9445 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9446 PyObject *resultobj;
9447 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9448 bool arg2 = (bool) true ;
9449 PyObject * obj0 = 0 ;
9450 PyObject * obj1 = 0 ;
9451 char *kwnames[] = {
9452 (char *) "self",(char *) "bShow", NULL
9453 };
9454
9455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9457 if (SWIG_arg_fail(1)) SWIG_fail;
9458 if (obj1) {
9459 {
9460 arg2 = (bool)(SWIG_As_bool(obj1));
9461 if (SWIG_arg_fail(2)) SWIG_fail;
9462 }
9463 }
9464 {
9465 PyThreadState* __tstate = wxPyBeginAllowThreads();
9466 (arg1)->Show(arg2);
9467
9468 wxPyEndAllowThreads(__tstate);
9469 if (PyErr_Occurred()) SWIG_fail;
9470 }
9471 Py_INCREF(Py_None); resultobj = Py_None;
9472 return resultobj;
9473 fail:
9474 return NULL;
9475 }
9476
9477
9478 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9479 PyObject *resultobj;
9480 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9481 wxFrame *result;
9482 PyObject * obj0 = 0 ;
9483 char *kwnames[] = {
9484 (char *) "self", NULL
9485 };
9486
9487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9489 if (SWIG_arg_fail(1)) SWIG_fail;
9490 {
9491 PyThreadState* __tstate = wxPyBeginAllowThreads();
9492 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9493
9494 wxPyEndAllowThreads(__tstate);
9495 if (PyErr_Occurred()) SWIG_fail;
9496 }
9497 {
9498 resultobj = wxPyMake_wxObject(result, 0);
9499 }
9500 return resultobj;
9501 fail:
9502 return NULL;
9503 }
9504
9505
9506 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9507 PyObject *resultobj;
9508 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9509 wxLog *result;
9510 PyObject * obj0 = 0 ;
9511 char *kwnames[] = {
9512 (char *) "self", NULL
9513 };
9514
9515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9517 if (SWIG_arg_fail(1)) SWIG_fail;
9518 {
9519 PyThreadState* __tstate = wxPyBeginAllowThreads();
9520 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9521
9522 wxPyEndAllowThreads(__tstate);
9523 if (PyErr_Occurred()) SWIG_fail;
9524 }
9525 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9526 return resultobj;
9527 fail:
9528 return NULL;
9529 }
9530
9531
9532 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9533 PyObject *resultobj;
9534 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9535 bool result;
9536 PyObject * obj0 = 0 ;
9537 char *kwnames[] = {
9538 (char *) "self", NULL
9539 };
9540
9541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9543 if (SWIG_arg_fail(1)) SWIG_fail;
9544 {
9545 PyThreadState* __tstate = wxPyBeginAllowThreads();
9546 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9547
9548 wxPyEndAllowThreads(__tstate);
9549 if (PyErr_Occurred()) SWIG_fail;
9550 }
9551 {
9552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9553 }
9554 return resultobj;
9555 fail:
9556 return NULL;
9557 }
9558
9559
9560 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9561 PyObject *resultobj;
9562 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9563 bool arg2 ;
9564 PyObject * obj0 = 0 ;
9565 PyObject * obj1 = 0 ;
9566 char *kwnames[] = {
9567 (char *) "self",(char *) "bDoPass", NULL
9568 };
9569
9570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9572 if (SWIG_arg_fail(1)) SWIG_fail;
9573 {
9574 arg2 = (bool)(SWIG_As_bool(obj1));
9575 if (SWIG_arg_fail(2)) SWIG_fail;
9576 }
9577 {
9578 PyThreadState* __tstate = wxPyBeginAllowThreads();
9579 (arg1)->PassMessages(arg2);
9580
9581 wxPyEndAllowThreads(__tstate);
9582 if (PyErr_Occurred()) SWIG_fail;
9583 }
9584 Py_INCREF(Py_None); resultobj = Py_None;
9585 return resultobj;
9586 fail:
9587 return NULL;
9588 }
9589
9590
9591 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9592 PyObject *obj;
9593 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9594 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9595 Py_INCREF(obj);
9596 return Py_BuildValue((char *)"");
9597 }
9598 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9599 PyObject *resultobj;
9600 wxLog *arg1 = (wxLog *) 0 ;
9601 wxLogChain *result;
9602 PyObject * obj0 = 0 ;
9603 char *kwnames[] = {
9604 (char *) "logger", NULL
9605 };
9606
9607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9609 if (SWIG_arg_fail(1)) SWIG_fail;
9610 {
9611 PyThreadState* __tstate = wxPyBeginAllowThreads();
9612 result = (wxLogChain *)new wxLogChain(arg1);
9613
9614 wxPyEndAllowThreads(__tstate);
9615 if (PyErr_Occurred()) SWIG_fail;
9616 }
9617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9618 return resultobj;
9619 fail:
9620 return NULL;
9621 }
9622
9623
9624 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9625 PyObject *resultobj;
9626 wxLogChain *arg1 = (wxLogChain *) 0 ;
9627 wxLog *arg2 = (wxLog *) 0 ;
9628 PyObject * obj0 = 0 ;
9629 PyObject * obj1 = 0 ;
9630 char *kwnames[] = {
9631 (char *) "self",(char *) "logger", NULL
9632 };
9633
9634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9636 if (SWIG_arg_fail(1)) SWIG_fail;
9637 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9638 if (SWIG_arg_fail(2)) SWIG_fail;
9639 {
9640 PyThreadState* __tstate = wxPyBeginAllowThreads();
9641 (arg1)->SetLog(arg2);
9642
9643 wxPyEndAllowThreads(__tstate);
9644 if (PyErr_Occurred()) SWIG_fail;
9645 }
9646 Py_INCREF(Py_None); resultobj = Py_None;
9647 return resultobj;
9648 fail:
9649 return NULL;
9650 }
9651
9652
9653 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9654 PyObject *resultobj;
9655 wxLogChain *arg1 = (wxLogChain *) 0 ;
9656 bool arg2 ;
9657 PyObject * obj0 = 0 ;
9658 PyObject * obj1 = 0 ;
9659 char *kwnames[] = {
9660 (char *) "self",(char *) "bDoPass", NULL
9661 };
9662
9663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9665 if (SWIG_arg_fail(1)) SWIG_fail;
9666 {
9667 arg2 = (bool)(SWIG_As_bool(obj1));
9668 if (SWIG_arg_fail(2)) SWIG_fail;
9669 }
9670 {
9671 PyThreadState* __tstate = wxPyBeginAllowThreads();
9672 (arg1)->PassMessages(arg2);
9673
9674 wxPyEndAllowThreads(__tstate);
9675 if (PyErr_Occurred()) SWIG_fail;
9676 }
9677 Py_INCREF(Py_None); resultobj = Py_None;
9678 return resultobj;
9679 fail:
9680 return NULL;
9681 }
9682
9683
9684 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9685 PyObject *resultobj;
9686 wxLogChain *arg1 = (wxLogChain *) 0 ;
9687 bool result;
9688 PyObject * obj0 = 0 ;
9689 char *kwnames[] = {
9690 (char *) "self", NULL
9691 };
9692
9693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9695 if (SWIG_arg_fail(1)) SWIG_fail;
9696 {
9697 PyThreadState* __tstate = wxPyBeginAllowThreads();
9698 result = (bool)(arg1)->IsPassingMessages();
9699
9700 wxPyEndAllowThreads(__tstate);
9701 if (PyErr_Occurred()) SWIG_fail;
9702 }
9703 {
9704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9705 }
9706 return resultobj;
9707 fail:
9708 return NULL;
9709 }
9710
9711
9712 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9713 PyObject *resultobj;
9714 wxLogChain *arg1 = (wxLogChain *) 0 ;
9715 wxLog *result;
9716 PyObject * obj0 = 0 ;
9717 char *kwnames[] = {
9718 (char *) "self", NULL
9719 };
9720
9721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9723 if (SWIG_arg_fail(1)) SWIG_fail;
9724 {
9725 PyThreadState* __tstate = wxPyBeginAllowThreads();
9726 result = (wxLog *)(arg1)->GetOldLog();
9727
9728 wxPyEndAllowThreads(__tstate);
9729 if (PyErr_Occurred()) SWIG_fail;
9730 }
9731 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9732 return resultobj;
9733 fail:
9734 return NULL;
9735 }
9736
9737
9738 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9739 PyObject *obj;
9740 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9741 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9742 Py_INCREF(obj);
9743 return Py_BuildValue((char *)"");
9744 }
9745 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9746 PyObject *resultobj;
9747 unsigned long result;
9748 char *kwnames[] = {
9749 NULL
9750 };
9751
9752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9753 {
9754 PyThreadState* __tstate = wxPyBeginAllowThreads();
9755 result = (unsigned long)wxSysErrorCode();
9756
9757 wxPyEndAllowThreads(__tstate);
9758 if (PyErr_Occurred()) SWIG_fail;
9759 }
9760 {
9761 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9762 }
9763 return resultobj;
9764 fail:
9765 return NULL;
9766 }
9767
9768
9769 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9770 PyObject *resultobj;
9771 unsigned long arg1 = (unsigned long) 0 ;
9772 wxString result;
9773 PyObject * obj0 = 0 ;
9774 char *kwnames[] = {
9775 (char *) "nErrCode", NULL
9776 };
9777
9778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9779 if (obj0) {
9780 {
9781 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9782 if (SWIG_arg_fail(1)) SWIG_fail;
9783 }
9784 }
9785 {
9786 PyThreadState* __tstate = wxPyBeginAllowThreads();
9787 result = wxSysErrorMsg(arg1);
9788
9789 wxPyEndAllowThreads(__tstate);
9790 if (PyErr_Occurred()) SWIG_fail;
9791 }
9792 {
9793 #if wxUSE_UNICODE
9794 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9795 #else
9796 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9797 #endif
9798 }
9799 return resultobj;
9800 fail:
9801 return NULL;
9802 }
9803
9804
9805 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9806 PyObject *resultobj;
9807 wxString *arg1 = 0 ;
9808 bool temp1 = false ;
9809 PyObject * obj0 = 0 ;
9810 char *kwnames[] = {
9811 (char *) "msg", NULL
9812 };
9813
9814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9815 {
9816 arg1 = wxString_in_helper(obj0);
9817 if (arg1 == NULL) SWIG_fail;
9818 temp1 = true;
9819 }
9820 {
9821 PyThreadState* __tstate = wxPyBeginAllowThreads();
9822 wxPyLogFatalError((wxString const &)*arg1);
9823
9824 wxPyEndAllowThreads(__tstate);
9825 if (PyErr_Occurred()) SWIG_fail;
9826 }
9827 Py_INCREF(Py_None); resultobj = Py_None;
9828 {
9829 if (temp1)
9830 delete arg1;
9831 }
9832 return resultobj;
9833 fail:
9834 {
9835 if (temp1)
9836 delete arg1;
9837 }
9838 return NULL;
9839 }
9840
9841
9842 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
9843 PyObject *resultobj;
9844 wxString *arg1 = 0 ;
9845 bool temp1 = false ;
9846 PyObject * obj0 = 0 ;
9847 char *kwnames[] = {
9848 (char *) "msg", NULL
9849 };
9850
9851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
9852 {
9853 arg1 = wxString_in_helper(obj0);
9854 if (arg1 == NULL) SWIG_fail;
9855 temp1 = true;
9856 }
9857 {
9858 PyThreadState* __tstate = wxPyBeginAllowThreads();
9859 wxPyLogError((wxString const &)*arg1);
9860
9861 wxPyEndAllowThreads(__tstate);
9862 if (PyErr_Occurred()) SWIG_fail;
9863 }
9864 Py_INCREF(Py_None); resultobj = Py_None;
9865 {
9866 if (temp1)
9867 delete arg1;
9868 }
9869 return resultobj;
9870 fail:
9871 {
9872 if (temp1)
9873 delete arg1;
9874 }
9875 return NULL;
9876 }
9877
9878
9879 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
9880 PyObject *resultobj;
9881 wxString *arg1 = 0 ;
9882 bool temp1 = false ;
9883 PyObject * obj0 = 0 ;
9884 char *kwnames[] = {
9885 (char *) "msg", NULL
9886 };
9887
9888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
9889 {
9890 arg1 = wxString_in_helper(obj0);
9891 if (arg1 == NULL) SWIG_fail;
9892 temp1 = true;
9893 }
9894 {
9895 PyThreadState* __tstate = wxPyBeginAllowThreads();
9896 wxPyLogWarning((wxString const &)*arg1);
9897
9898 wxPyEndAllowThreads(__tstate);
9899 if (PyErr_Occurred()) SWIG_fail;
9900 }
9901 Py_INCREF(Py_None); resultobj = Py_None;
9902 {
9903 if (temp1)
9904 delete arg1;
9905 }
9906 return resultobj;
9907 fail:
9908 {
9909 if (temp1)
9910 delete arg1;
9911 }
9912 return NULL;
9913 }
9914
9915
9916 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9917 PyObject *resultobj;
9918 wxString *arg1 = 0 ;
9919 bool temp1 = false ;
9920 PyObject * obj0 = 0 ;
9921 char *kwnames[] = {
9922 (char *) "msg", NULL
9923 };
9924
9925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
9926 {
9927 arg1 = wxString_in_helper(obj0);
9928 if (arg1 == NULL) SWIG_fail;
9929 temp1 = true;
9930 }
9931 {
9932 PyThreadState* __tstate = wxPyBeginAllowThreads();
9933 wxPyLogMessage((wxString const &)*arg1);
9934
9935 wxPyEndAllowThreads(__tstate);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 Py_INCREF(Py_None); resultobj = Py_None;
9939 {
9940 if (temp1)
9941 delete arg1;
9942 }
9943 return resultobj;
9944 fail:
9945 {
9946 if (temp1)
9947 delete arg1;
9948 }
9949 return NULL;
9950 }
9951
9952
9953 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9954 PyObject *resultobj;
9955 wxString *arg1 = 0 ;
9956 bool temp1 = false ;
9957 PyObject * obj0 = 0 ;
9958 char *kwnames[] = {
9959 (char *) "msg", NULL
9960 };
9961
9962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
9963 {
9964 arg1 = wxString_in_helper(obj0);
9965 if (arg1 == NULL) SWIG_fail;
9966 temp1 = true;
9967 }
9968 {
9969 PyThreadState* __tstate = wxPyBeginAllowThreads();
9970 wxPyLogInfo((wxString const &)*arg1);
9971
9972 wxPyEndAllowThreads(__tstate);
9973 if (PyErr_Occurred()) SWIG_fail;
9974 }
9975 Py_INCREF(Py_None); resultobj = Py_None;
9976 {
9977 if (temp1)
9978 delete arg1;
9979 }
9980 return resultobj;
9981 fail:
9982 {
9983 if (temp1)
9984 delete arg1;
9985 }
9986 return NULL;
9987 }
9988
9989
9990 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
9991 PyObject *resultobj;
9992 wxString *arg1 = 0 ;
9993 bool temp1 = false ;
9994 PyObject * obj0 = 0 ;
9995 char *kwnames[] = {
9996 (char *) "msg", NULL
9997 };
9998
9999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10000 {
10001 arg1 = wxString_in_helper(obj0);
10002 if (arg1 == NULL) SWIG_fail;
10003 temp1 = true;
10004 }
10005 {
10006 PyThreadState* __tstate = wxPyBeginAllowThreads();
10007 wxPyLogDebug((wxString const &)*arg1);
10008
10009 wxPyEndAllowThreads(__tstate);
10010 if (PyErr_Occurred()) SWIG_fail;
10011 }
10012 Py_INCREF(Py_None); resultobj = Py_None;
10013 {
10014 if (temp1)
10015 delete arg1;
10016 }
10017 return resultobj;
10018 fail:
10019 {
10020 if (temp1)
10021 delete arg1;
10022 }
10023 return NULL;
10024 }
10025
10026
10027 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10028 PyObject *resultobj;
10029 wxString *arg1 = 0 ;
10030 bool temp1 = false ;
10031 PyObject * obj0 = 0 ;
10032 char *kwnames[] = {
10033 (char *) "msg", NULL
10034 };
10035
10036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10037 {
10038 arg1 = wxString_in_helper(obj0);
10039 if (arg1 == NULL) SWIG_fail;
10040 temp1 = true;
10041 }
10042 {
10043 PyThreadState* __tstate = wxPyBeginAllowThreads();
10044 wxPyLogVerbose((wxString const &)*arg1);
10045
10046 wxPyEndAllowThreads(__tstate);
10047 if (PyErr_Occurred()) SWIG_fail;
10048 }
10049 Py_INCREF(Py_None); resultobj = Py_None;
10050 {
10051 if (temp1)
10052 delete arg1;
10053 }
10054 return resultobj;
10055 fail:
10056 {
10057 if (temp1)
10058 delete arg1;
10059 }
10060 return NULL;
10061 }
10062
10063
10064 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10065 PyObject *resultobj;
10066 wxString *arg1 = 0 ;
10067 bool temp1 = false ;
10068 PyObject * obj0 = 0 ;
10069 char *kwnames[] = {
10070 (char *) "msg", NULL
10071 };
10072
10073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10074 {
10075 arg1 = wxString_in_helper(obj0);
10076 if (arg1 == NULL) SWIG_fail;
10077 temp1 = true;
10078 }
10079 {
10080 PyThreadState* __tstate = wxPyBeginAllowThreads();
10081 wxPyLogStatus((wxString const &)*arg1);
10082
10083 wxPyEndAllowThreads(__tstate);
10084 if (PyErr_Occurred()) SWIG_fail;
10085 }
10086 Py_INCREF(Py_None); resultobj = Py_None;
10087 {
10088 if (temp1)
10089 delete arg1;
10090 }
10091 return resultobj;
10092 fail:
10093 {
10094 if (temp1)
10095 delete arg1;
10096 }
10097 return NULL;
10098 }
10099
10100
10101 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10102 PyObject *resultobj;
10103 wxFrame *arg1 = (wxFrame *) 0 ;
10104 wxString *arg2 = 0 ;
10105 bool temp2 = false ;
10106 PyObject * obj0 = 0 ;
10107 PyObject * obj1 = 0 ;
10108 char *kwnames[] = {
10109 (char *) "pFrame",(char *) "msg", NULL
10110 };
10111
10112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10114 if (SWIG_arg_fail(1)) SWIG_fail;
10115 {
10116 arg2 = wxString_in_helper(obj1);
10117 if (arg2 == NULL) SWIG_fail;
10118 temp2 = true;
10119 }
10120 {
10121 PyThreadState* __tstate = wxPyBeginAllowThreads();
10122 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10123
10124 wxPyEndAllowThreads(__tstate);
10125 if (PyErr_Occurred()) SWIG_fail;
10126 }
10127 Py_INCREF(Py_None); resultobj = Py_None;
10128 {
10129 if (temp2)
10130 delete arg2;
10131 }
10132 return resultobj;
10133 fail:
10134 {
10135 if (temp2)
10136 delete arg2;
10137 }
10138 return NULL;
10139 }
10140
10141
10142 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10143 PyObject *resultobj;
10144 wxString *arg1 = 0 ;
10145 bool temp1 = false ;
10146 PyObject * obj0 = 0 ;
10147 char *kwnames[] = {
10148 (char *) "msg", NULL
10149 };
10150
10151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10152 {
10153 arg1 = wxString_in_helper(obj0);
10154 if (arg1 == NULL) SWIG_fail;
10155 temp1 = true;
10156 }
10157 {
10158 PyThreadState* __tstate = wxPyBeginAllowThreads();
10159 wxPyLogSysError((wxString const &)*arg1);
10160
10161 wxPyEndAllowThreads(__tstate);
10162 if (PyErr_Occurred()) SWIG_fail;
10163 }
10164 Py_INCREF(Py_None); resultobj = Py_None;
10165 {
10166 if (temp1)
10167 delete arg1;
10168 }
10169 return resultobj;
10170 fail:
10171 {
10172 if (temp1)
10173 delete arg1;
10174 }
10175 return NULL;
10176 }
10177
10178
10179 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10180 PyObject *resultobj;
10181 unsigned long arg1 ;
10182 wxString *arg2 = 0 ;
10183 bool temp2 = false ;
10184 PyObject * obj0 = 0 ;
10185 PyObject * obj1 = 0 ;
10186 char *kwnames[] = {
10187 (char *) "level",(char *) "msg", NULL
10188 };
10189
10190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10191 {
10192 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10193 if (SWIG_arg_fail(1)) SWIG_fail;
10194 }
10195 {
10196 arg2 = wxString_in_helper(obj1);
10197 if (arg2 == NULL) SWIG_fail;
10198 temp2 = true;
10199 }
10200 {
10201 PyThreadState* __tstate = wxPyBeginAllowThreads();
10202 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10203
10204 wxPyEndAllowThreads(__tstate);
10205 if (PyErr_Occurred()) SWIG_fail;
10206 }
10207 Py_INCREF(Py_None); resultobj = Py_None;
10208 {
10209 if (temp2)
10210 delete arg2;
10211 }
10212 return resultobj;
10213 fail:
10214 {
10215 if (temp2)
10216 delete arg2;
10217 }
10218 return NULL;
10219 }
10220
10221
10222 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10223 PyObject *resultobj;
10224 unsigned long arg1 ;
10225 wxString *arg2 = 0 ;
10226 bool temp2 = false ;
10227 PyObject * obj0 = 0 ;
10228 PyObject * obj1 = 0 ;
10229
10230 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10231 {
10232 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10233 if (SWIG_arg_fail(1)) SWIG_fail;
10234 }
10235 {
10236 arg2 = wxString_in_helper(obj1);
10237 if (arg2 == NULL) SWIG_fail;
10238 temp2 = true;
10239 }
10240 {
10241 PyThreadState* __tstate = wxPyBeginAllowThreads();
10242 wxPyLogTrace(arg1,(wxString const &)*arg2);
10243
10244 wxPyEndAllowThreads(__tstate);
10245 if (PyErr_Occurred()) SWIG_fail;
10246 }
10247 Py_INCREF(Py_None); resultobj = Py_None;
10248 {
10249 if (temp2)
10250 delete arg2;
10251 }
10252 return resultobj;
10253 fail:
10254 {
10255 if (temp2)
10256 delete arg2;
10257 }
10258 return NULL;
10259 }
10260
10261
10262 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10263 PyObject *resultobj;
10264 wxString *arg1 = 0 ;
10265 wxString *arg2 = 0 ;
10266 bool temp1 = false ;
10267 bool temp2 = false ;
10268 PyObject * obj0 = 0 ;
10269 PyObject * obj1 = 0 ;
10270
10271 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10272 {
10273 arg1 = wxString_in_helper(obj0);
10274 if (arg1 == NULL) SWIG_fail;
10275 temp1 = true;
10276 }
10277 {
10278 arg2 = wxString_in_helper(obj1);
10279 if (arg2 == NULL) SWIG_fail;
10280 temp2 = true;
10281 }
10282 {
10283 PyThreadState* __tstate = wxPyBeginAllowThreads();
10284 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10285
10286 wxPyEndAllowThreads(__tstate);
10287 if (PyErr_Occurred()) SWIG_fail;
10288 }
10289 Py_INCREF(Py_None); resultobj = Py_None;
10290 {
10291 if (temp1)
10292 delete arg1;
10293 }
10294 {
10295 if (temp2)
10296 delete arg2;
10297 }
10298 return resultobj;
10299 fail:
10300 {
10301 if (temp1)
10302 delete arg1;
10303 }
10304 {
10305 if (temp2)
10306 delete arg2;
10307 }
10308 return NULL;
10309 }
10310
10311
10312 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10313 int argc;
10314 PyObject *argv[3];
10315 int ii;
10316
10317 argc = PyObject_Length(args);
10318 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10319 argv[ii] = PyTuple_GetItem(args,ii);
10320 }
10321 if (argc == 2) {
10322 int _v;
10323 {
10324 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10325 }
10326 if (_v) {
10327 {
10328 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10329 }
10330 if (_v) {
10331 return _wrap_LogTrace__SWIG_1(self,args);
10332 }
10333 }
10334 }
10335 if (argc == 2) {
10336 int _v;
10337 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10338 if (_v) {
10339 {
10340 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10341 }
10342 if (_v) {
10343 return _wrap_LogTrace__SWIG_0(self,args);
10344 }
10345 }
10346 }
10347
10348 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10349 return NULL;
10350 }
10351
10352
10353 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10354 PyObject *resultobj;
10355 wxString *arg1 = 0 ;
10356 wxString *arg2 = 0 ;
10357 bool temp1 = false ;
10358 bool temp2 = false ;
10359 PyObject * obj0 = 0 ;
10360 PyObject * obj1 = 0 ;
10361 char *kwnames[] = {
10362 (char *) "title",(char *) "text", NULL
10363 };
10364
10365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10366 {
10367 arg1 = wxString_in_helper(obj0);
10368 if (arg1 == NULL) SWIG_fail;
10369 temp1 = true;
10370 }
10371 {
10372 arg2 = wxString_in_helper(obj1);
10373 if (arg2 == NULL) SWIG_fail;
10374 temp2 = true;
10375 }
10376 {
10377 PyThreadState* __tstate = wxPyBeginAllowThreads();
10378 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10379
10380 wxPyEndAllowThreads(__tstate);
10381 if (PyErr_Occurred()) SWIG_fail;
10382 }
10383 Py_INCREF(Py_None); resultobj = Py_None;
10384 {
10385 if (temp1)
10386 delete arg1;
10387 }
10388 {
10389 if (temp2)
10390 delete arg2;
10391 }
10392 return resultobj;
10393 fail:
10394 {
10395 if (temp1)
10396 delete arg1;
10397 }
10398 {
10399 if (temp2)
10400 delete arg2;
10401 }
10402 return NULL;
10403 }
10404
10405
10406 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10407 PyObject *resultobj;
10408 wxLogNull *result;
10409 char *kwnames[] = {
10410 NULL
10411 };
10412
10413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10414 {
10415 PyThreadState* __tstate = wxPyBeginAllowThreads();
10416 result = (wxLogNull *)new wxLogNull();
10417
10418 wxPyEndAllowThreads(__tstate);
10419 if (PyErr_Occurred()) SWIG_fail;
10420 }
10421 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10422 return resultobj;
10423 fail:
10424 return NULL;
10425 }
10426
10427
10428 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10429 PyObject *resultobj;
10430 wxLogNull *arg1 = (wxLogNull *) 0 ;
10431 PyObject * obj0 = 0 ;
10432 char *kwnames[] = {
10433 (char *) "self", NULL
10434 };
10435
10436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10438 if (SWIG_arg_fail(1)) SWIG_fail;
10439 {
10440 PyThreadState* __tstate = wxPyBeginAllowThreads();
10441 delete arg1;
10442
10443 wxPyEndAllowThreads(__tstate);
10444 if (PyErr_Occurred()) SWIG_fail;
10445 }
10446 Py_INCREF(Py_None); resultobj = Py_None;
10447 return resultobj;
10448 fail:
10449 return NULL;
10450 }
10451
10452
10453 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10454 PyObject *obj;
10455 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10456 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10457 Py_INCREF(obj);
10458 return Py_BuildValue((char *)"");
10459 }
10460 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10461 PyObject *resultobj;
10462 wxPyLog *result;
10463 char *kwnames[] = {
10464 NULL
10465 };
10466
10467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10468 {
10469 PyThreadState* __tstate = wxPyBeginAllowThreads();
10470 result = (wxPyLog *)new wxPyLog();
10471
10472 wxPyEndAllowThreads(__tstate);
10473 if (PyErr_Occurred()) SWIG_fail;
10474 }
10475 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10476 return resultobj;
10477 fail:
10478 return NULL;
10479 }
10480
10481
10482 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10483 PyObject *resultobj;
10484 wxPyLog *arg1 = (wxPyLog *) 0 ;
10485 PyObject *arg2 = (PyObject *) 0 ;
10486 PyObject *arg3 = (PyObject *) 0 ;
10487 PyObject * obj0 = 0 ;
10488 PyObject * obj1 = 0 ;
10489 PyObject * obj2 = 0 ;
10490 char *kwnames[] = {
10491 (char *) "self",(char *) "self",(char *) "_class", NULL
10492 };
10493
10494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10496 if (SWIG_arg_fail(1)) SWIG_fail;
10497 arg2 = obj1;
10498 arg3 = obj2;
10499 {
10500 PyThreadState* __tstate = wxPyBeginAllowThreads();
10501 (arg1)->_setCallbackInfo(arg2,arg3);
10502
10503 wxPyEndAllowThreads(__tstate);
10504 if (PyErr_Occurred()) SWIG_fail;
10505 }
10506 Py_INCREF(Py_None); resultobj = Py_None;
10507 return resultobj;
10508 fail:
10509 return NULL;
10510 }
10511
10512
10513 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10514 PyObject *obj;
10515 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10516 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10517 Py_INCREF(obj);
10518 return Py_BuildValue((char *)"");
10519 }
10520 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10521 PyObject *resultobj;
10522 int arg1 ;
10523 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10524 int arg3 = (int) wxKILL_NOCHILDREN ;
10525 wxKillError result;
10526 PyObject * obj0 = 0 ;
10527 PyObject * obj1 = 0 ;
10528 PyObject * obj2 = 0 ;
10529 char *kwnames[] = {
10530 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10531 };
10532
10533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10534 {
10535 arg1 = (int)(SWIG_As_int(obj0));
10536 if (SWIG_arg_fail(1)) SWIG_fail;
10537 }
10538 if (obj1) {
10539 {
10540 arg2 = (wxSignal)(SWIG_As_int(obj1));
10541 if (SWIG_arg_fail(2)) SWIG_fail;
10542 }
10543 }
10544 if (obj2) {
10545 {
10546 arg3 = (int)(SWIG_As_int(obj2));
10547 if (SWIG_arg_fail(3)) SWIG_fail;
10548 }
10549 }
10550 {
10551 PyThreadState* __tstate = wxPyBeginAllowThreads();
10552 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10553
10554 wxPyEndAllowThreads(__tstate);
10555 if (PyErr_Occurred()) SWIG_fail;
10556 }
10557 resultobj = SWIG_From_int((result));
10558 return resultobj;
10559 fail:
10560 return NULL;
10561 }
10562
10563
10564 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10565 PyObject *resultobj;
10566 int arg1 ;
10567 bool result;
10568 PyObject * obj0 = 0 ;
10569 char *kwnames[] = {
10570 (char *) "pid", NULL
10571 };
10572
10573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10574 {
10575 arg1 = (int)(SWIG_As_int(obj0));
10576 if (SWIG_arg_fail(1)) SWIG_fail;
10577 }
10578 {
10579 PyThreadState* __tstate = wxPyBeginAllowThreads();
10580 result = (bool)wxPyProcess::Exists(arg1);
10581
10582 wxPyEndAllowThreads(__tstate);
10583 if (PyErr_Occurred()) SWIG_fail;
10584 }
10585 {
10586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10587 }
10588 return resultobj;
10589 fail:
10590 return NULL;
10591 }
10592
10593
10594 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10595 PyObject *resultobj;
10596 wxString *arg1 = 0 ;
10597 int arg2 = (int) wxEXEC_ASYNC ;
10598 wxPyProcess *result;
10599 bool temp1 = false ;
10600 PyObject * obj0 = 0 ;
10601 PyObject * obj1 = 0 ;
10602 char *kwnames[] = {
10603 (char *) "cmd",(char *) "flags", NULL
10604 };
10605
10606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10607 {
10608 arg1 = wxString_in_helper(obj0);
10609 if (arg1 == NULL) SWIG_fail;
10610 temp1 = true;
10611 }
10612 if (obj1) {
10613 {
10614 arg2 = (int)(SWIG_As_int(obj1));
10615 if (SWIG_arg_fail(2)) SWIG_fail;
10616 }
10617 }
10618 {
10619 PyThreadState* __tstate = wxPyBeginAllowThreads();
10620 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10621
10622 wxPyEndAllowThreads(__tstate);
10623 if (PyErr_Occurred()) SWIG_fail;
10624 }
10625 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10626 {
10627 if (temp1)
10628 delete arg1;
10629 }
10630 return resultobj;
10631 fail:
10632 {
10633 if (temp1)
10634 delete arg1;
10635 }
10636 return NULL;
10637 }
10638
10639
10640 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10641 PyObject *resultobj;
10642 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10643 int arg2 = (int) -1 ;
10644 wxPyProcess *result;
10645 PyObject * obj0 = 0 ;
10646 PyObject * obj1 = 0 ;
10647 char *kwnames[] = {
10648 (char *) "parent",(char *) "id", NULL
10649 };
10650
10651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10652 if (obj0) {
10653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10654 if (SWIG_arg_fail(1)) SWIG_fail;
10655 }
10656 if (obj1) {
10657 {
10658 arg2 = (int)(SWIG_As_int(obj1));
10659 if (SWIG_arg_fail(2)) SWIG_fail;
10660 }
10661 }
10662 {
10663 PyThreadState* __tstate = wxPyBeginAllowThreads();
10664 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10665
10666 wxPyEndAllowThreads(__tstate);
10667 if (PyErr_Occurred()) SWIG_fail;
10668 }
10669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10670 return resultobj;
10671 fail:
10672 return NULL;
10673 }
10674
10675
10676 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10677 PyObject *resultobj;
10678 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10679 PyObject *arg2 = (PyObject *) 0 ;
10680 PyObject *arg3 = (PyObject *) 0 ;
10681 PyObject * obj0 = 0 ;
10682 PyObject * obj1 = 0 ;
10683 PyObject * obj2 = 0 ;
10684 char *kwnames[] = {
10685 (char *) "self",(char *) "self",(char *) "_class", NULL
10686 };
10687
10688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10690 if (SWIG_arg_fail(1)) SWIG_fail;
10691 arg2 = obj1;
10692 arg3 = obj2;
10693 {
10694 PyThreadState* __tstate = wxPyBeginAllowThreads();
10695 (arg1)->_setCallbackInfo(arg2,arg3);
10696
10697 wxPyEndAllowThreads(__tstate);
10698 if (PyErr_Occurred()) SWIG_fail;
10699 }
10700 Py_INCREF(Py_None); resultobj = Py_None;
10701 return resultobj;
10702 fail:
10703 return NULL;
10704 }
10705
10706
10707 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10708 PyObject *resultobj;
10709 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10710 int arg2 ;
10711 int arg3 ;
10712 PyObject * obj0 = 0 ;
10713 PyObject * obj1 = 0 ;
10714 PyObject * obj2 = 0 ;
10715 char *kwnames[] = {
10716 (char *) "self",(char *) "pid",(char *) "status", NULL
10717 };
10718
10719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10721 if (SWIG_arg_fail(1)) SWIG_fail;
10722 {
10723 arg2 = (int)(SWIG_As_int(obj1));
10724 if (SWIG_arg_fail(2)) SWIG_fail;
10725 }
10726 {
10727 arg3 = (int)(SWIG_As_int(obj2));
10728 if (SWIG_arg_fail(3)) SWIG_fail;
10729 }
10730 {
10731 PyThreadState* __tstate = wxPyBeginAllowThreads();
10732 (arg1)->base_OnTerminate(arg2,arg3);
10733
10734 wxPyEndAllowThreads(__tstate);
10735 if (PyErr_Occurred()) SWIG_fail;
10736 }
10737 Py_INCREF(Py_None); resultobj = Py_None;
10738 return resultobj;
10739 fail:
10740 return NULL;
10741 }
10742
10743
10744 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10745 PyObject *resultobj;
10746 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10747 PyObject * obj0 = 0 ;
10748 char *kwnames[] = {
10749 (char *) "self", NULL
10750 };
10751
10752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10754 if (SWIG_arg_fail(1)) SWIG_fail;
10755 {
10756 PyThreadState* __tstate = wxPyBeginAllowThreads();
10757 (arg1)->Redirect();
10758
10759 wxPyEndAllowThreads(__tstate);
10760 if (PyErr_Occurred()) SWIG_fail;
10761 }
10762 Py_INCREF(Py_None); resultobj = Py_None;
10763 return resultobj;
10764 fail:
10765 return NULL;
10766 }
10767
10768
10769 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10770 PyObject *resultobj;
10771 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10772 bool result;
10773 PyObject * obj0 = 0 ;
10774 char *kwnames[] = {
10775 (char *) "self", NULL
10776 };
10777
10778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10780 if (SWIG_arg_fail(1)) SWIG_fail;
10781 {
10782 PyThreadState* __tstate = wxPyBeginAllowThreads();
10783 result = (bool)(arg1)->IsRedirected();
10784
10785 wxPyEndAllowThreads(__tstate);
10786 if (PyErr_Occurred()) SWIG_fail;
10787 }
10788 {
10789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10790 }
10791 return resultobj;
10792 fail:
10793 return NULL;
10794 }
10795
10796
10797 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10798 PyObject *resultobj;
10799 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10800 PyObject * obj0 = 0 ;
10801 char *kwnames[] = {
10802 (char *) "self", NULL
10803 };
10804
10805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10807 if (SWIG_arg_fail(1)) SWIG_fail;
10808 {
10809 PyThreadState* __tstate = wxPyBeginAllowThreads();
10810 (arg1)->Detach();
10811
10812 wxPyEndAllowThreads(__tstate);
10813 if (PyErr_Occurred()) SWIG_fail;
10814 }
10815 Py_INCREF(Py_None); resultobj = Py_None;
10816 return resultobj;
10817 fail:
10818 return NULL;
10819 }
10820
10821
10822 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10823 PyObject *resultobj;
10824 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10825 wxInputStream *result;
10826 PyObject * obj0 = 0 ;
10827 char *kwnames[] = {
10828 (char *) "self", NULL
10829 };
10830
10831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
10832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10833 if (SWIG_arg_fail(1)) SWIG_fail;
10834 {
10835 PyThreadState* __tstate = wxPyBeginAllowThreads();
10836 result = (wxInputStream *)(arg1)->GetInputStream();
10837
10838 wxPyEndAllowThreads(__tstate);
10839 if (PyErr_Occurred()) SWIG_fail;
10840 }
10841 {
10842 wxPyInputStream * _ptr = NULL;
10843
10844 if (result) {
10845 _ptr = new wxPyInputStream(result);
10846 }
10847 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10848 }
10849 return resultobj;
10850 fail:
10851 return NULL;
10852 }
10853
10854
10855 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
10856 PyObject *resultobj;
10857 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10858 wxInputStream *result;
10859 PyObject * obj0 = 0 ;
10860 char *kwnames[] = {
10861 (char *) "self", NULL
10862 };
10863
10864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
10865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10866 if (SWIG_arg_fail(1)) SWIG_fail;
10867 {
10868 PyThreadState* __tstate = wxPyBeginAllowThreads();
10869 result = (wxInputStream *)(arg1)->GetErrorStream();
10870
10871 wxPyEndAllowThreads(__tstate);
10872 if (PyErr_Occurred()) SWIG_fail;
10873 }
10874 {
10875 wxPyInputStream * _ptr = NULL;
10876
10877 if (result) {
10878 _ptr = new wxPyInputStream(result);
10879 }
10880 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10881 }
10882 return resultobj;
10883 fail:
10884 return NULL;
10885 }
10886
10887
10888 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10889 PyObject *resultobj;
10890 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10891 wxOutputStream *result;
10892 PyObject * obj0 = 0 ;
10893 char *kwnames[] = {
10894 (char *) "self", NULL
10895 };
10896
10897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
10898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10899 if (SWIG_arg_fail(1)) SWIG_fail;
10900 {
10901 PyThreadState* __tstate = wxPyBeginAllowThreads();
10902 result = (wxOutputStream *)(arg1)->GetOutputStream();
10903
10904 wxPyEndAllowThreads(__tstate);
10905 if (PyErr_Occurred()) SWIG_fail;
10906 }
10907 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
10908 return resultobj;
10909 fail:
10910 return NULL;
10911 }
10912
10913
10914 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
10915 PyObject *resultobj;
10916 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10917 PyObject * obj0 = 0 ;
10918 char *kwnames[] = {
10919 (char *) "self", NULL
10920 };
10921
10922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
10923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10924 if (SWIG_arg_fail(1)) SWIG_fail;
10925 {
10926 PyThreadState* __tstate = wxPyBeginAllowThreads();
10927 (arg1)->CloseOutput();
10928
10929 wxPyEndAllowThreads(__tstate);
10930 if (PyErr_Occurred()) SWIG_fail;
10931 }
10932 Py_INCREF(Py_None); resultobj = Py_None;
10933 return resultobj;
10934 fail:
10935 return NULL;
10936 }
10937
10938
10939 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
10940 PyObject *resultobj;
10941 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10942 bool result;
10943 PyObject * obj0 = 0 ;
10944 char *kwnames[] = {
10945 (char *) "self", NULL
10946 };
10947
10948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
10949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10950 if (SWIG_arg_fail(1)) SWIG_fail;
10951 {
10952 PyThreadState* __tstate = wxPyBeginAllowThreads();
10953 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
10954
10955 wxPyEndAllowThreads(__tstate);
10956 if (PyErr_Occurred()) SWIG_fail;
10957 }
10958 {
10959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10960 }
10961 return resultobj;
10962 fail:
10963 return NULL;
10964 }
10965
10966
10967 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
10968 PyObject *resultobj;
10969 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10970 bool result;
10971 PyObject * obj0 = 0 ;
10972 char *kwnames[] = {
10973 (char *) "self", NULL
10974 };
10975
10976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
10981 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
10982
10983 wxPyEndAllowThreads(__tstate);
10984 if (PyErr_Occurred()) SWIG_fail;
10985 }
10986 {
10987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10988 }
10989 return resultobj;
10990 fail:
10991 return NULL;
10992 }
10993
10994
10995 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
10996 PyObject *resultobj;
10997 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10998 bool result;
10999 PyObject * obj0 = 0 ;
11000 char *kwnames[] = {
11001 (char *) "self", NULL
11002 };
11003
11004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11006 if (SWIG_arg_fail(1)) SWIG_fail;
11007 {
11008 PyThreadState* __tstate = wxPyBeginAllowThreads();
11009 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11010
11011 wxPyEndAllowThreads(__tstate);
11012 if (PyErr_Occurred()) SWIG_fail;
11013 }
11014 {
11015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11016 }
11017 return resultobj;
11018 fail:
11019 return NULL;
11020 }
11021
11022
11023 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11024 PyObject *obj;
11025 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11026 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11027 Py_INCREF(obj);
11028 return Py_BuildValue((char *)"");
11029 }
11030 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11031 PyObject *resultobj;
11032 int arg1 = (int) 0 ;
11033 int arg2 = (int) 0 ;
11034 int arg3 = (int) 0 ;
11035 wxProcessEvent *result;
11036 PyObject * obj0 = 0 ;
11037 PyObject * obj1 = 0 ;
11038 PyObject * obj2 = 0 ;
11039 char *kwnames[] = {
11040 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11041 };
11042
11043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11044 if (obj0) {
11045 {
11046 arg1 = (int)(SWIG_As_int(obj0));
11047 if (SWIG_arg_fail(1)) SWIG_fail;
11048 }
11049 }
11050 if (obj1) {
11051 {
11052 arg2 = (int)(SWIG_As_int(obj1));
11053 if (SWIG_arg_fail(2)) SWIG_fail;
11054 }
11055 }
11056 if (obj2) {
11057 {
11058 arg3 = (int)(SWIG_As_int(obj2));
11059 if (SWIG_arg_fail(3)) SWIG_fail;
11060 }
11061 }
11062 {
11063 PyThreadState* __tstate = wxPyBeginAllowThreads();
11064 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11065
11066 wxPyEndAllowThreads(__tstate);
11067 if (PyErr_Occurred()) SWIG_fail;
11068 }
11069 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11070 return resultobj;
11071 fail:
11072 return NULL;
11073 }
11074
11075
11076 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11077 PyObject *resultobj;
11078 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11079 int result;
11080 PyObject * obj0 = 0 ;
11081 char *kwnames[] = {
11082 (char *) "self", NULL
11083 };
11084
11085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11087 if (SWIG_arg_fail(1)) SWIG_fail;
11088 {
11089 PyThreadState* __tstate = wxPyBeginAllowThreads();
11090 result = (int)(arg1)->GetPid();
11091
11092 wxPyEndAllowThreads(__tstate);
11093 if (PyErr_Occurred()) SWIG_fail;
11094 }
11095 {
11096 resultobj = SWIG_From_int((int)(result));
11097 }
11098 return resultobj;
11099 fail:
11100 return NULL;
11101 }
11102
11103
11104 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11105 PyObject *resultobj;
11106 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11107 int result;
11108 PyObject * obj0 = 0 ;
11109 char *kwnames[] = {
11110 (char *) "self", NULL
11111 };
11112
11113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11115 if (SWIG_arg_fail(1)) SWIG_fail;
11116 {
11117 PyThreadState* __tstate = wxPyBeginAllowThreads();
11118 result = (int)(arg1)->GetExitCode();
11119
11120 wxPyEndAllowThreads(__tstate);
11121 if (PyErr_Occurred()) SWIG_fail;
11122 }
11123 {
11124 resultobj = SWIG_From_int((int)(result));
11125 }
11126 return resultobj;
11127 fail:
11128 return NULL;
11129 }
11130
11131
11132 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11133 PyObject *resultobj;
11134 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11135 int arg2 ;
11136 PyObject * obj0 = 0 ;
11137 PyObject * obj1 = 0 ;
11138 char *kwnames[] = {
11139 (char *) "self",(char *) "m_pid", NULL
11140 };
11141
11142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11144 if (SWIG_arg_fail(1)) SWIG_fail;
11145 {
11146 arg2 = (int)(SWIG_As_int(obj1));
11147 if (SWIG_arg_fail(2)) SWIG_fail;
11148 }
11149 if (arg1) (arg1)->m_pid = arg2;
11150
11151 Py_INCREF(Py_None); resultobj = Py_None;
11152 return resultobj;
11153 fail:
11154 return NULL;
11155 }
11156
11157
11158 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11159 PyObject *resultobj;
11160 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11161 int result;
11162 PyObject * obj0 = 0 ;
11163 char *kwnames[] = {
11164 (char *) "self", NULL
11165 };
11166
11167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11169 if (SWIG_arg_fail(1)) SWIG_fail;
11170 result = (int) ((arg1)->m_pid);
11171
11172 {
11173 resultobj = SWIG_From_int((int)(result));
11174 }
11175 return resultobj;
11176 fail:
11177 return NULL;
11178 }
11179
11180
11181 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11182 PyObject *resultobj;
11183 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11184 int arg2 ;
11185 PyObject * obj0 = 0 ;
11186 PyObject * obj1 = 0 ;
11187 char *kwnames[] = {
11188 (char *) "self",(char *) "m_exitcode", NULL
11189 };
11190
11191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11193 if (SWIG_arg_fail(1)) SWIG_fail;
11194 {
11195 arg2 = (int)(SWIG_As_int(obj1));
11196 if (SWIG_arg_fail(2)) SWIG_fail;
11197 }
11198 if (arg1) (arg1)->m_exitcode = arg2;
11199
11200 Py_INCREF(Py_None); resultobj = Py_None;
11201 return resultobj;
11202 fail:
11203 return NULL;
11204 }
11205
11206
11207 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11208 PyObject *resultobj;
11209 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11210 int result;
11211 PyObject * obj0 = 0 ;
11212 char *kwnames[] = {
11213 (char *) "self", NULL
11214 };
11215
11216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11218 if (SWIG_arg_fail(1)) SWIG_fail;
11219 result = (int) ((arg1)->m_exitcode);
11220
11221 {
11222 resultobj = SWIG_From_int((int)(result));
11223 }
11224 return resultobj;
11225 fail:
11226 return NULL;
11227 }
11228
11229
11230 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11231 PyObject *obj;
11232 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11233 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11234 Py_INCREF(obj);
11235 return Py_BuildValue((char *)"");
11236 }
11237 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11238 PyObject *resultobj;
11239 wxString *arg1 = 0 ;
11240 int arg2 = (int) wxEXEC_ASYNC ;
11241 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11242 long result;
11243 bool temp1 = false ;
11244 PyObject * obj0 = 0 ;
11245 PyObject * obj1 = 0 ;
11246 PyObject * obj2 = 0 ;
11247 char *kwnames[] = {
11248 (char *) "command",(char *) "flags",(char *) "process", NULL
11249 };
11250
11251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11252 {
11253 arg1 = wxString_in_helper(obj0);
11254 if (arg1 == NULL) SWIG_fail;
11255 temp1 = true;
11256 }
11257 if (obj1) {
11258 {
11259 arg2 = (int)(SWIG_As_int(obj1));
11260 if (SWIG_arg_fail(2)) SWIG_fail;
11261 }
11262 }
11263 if (obj2) {
11264 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11265 if (SWIG_arg_fail(3)) SWIG_fail;
11266 }
11267 {
11268 if (!wxPyCheckForApp()) SWIG_fail;
11269 PyThreadState* __tstate = wxPyBeginAllowThreads();
11270 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11271
11272 wxPyEndAllowThreads(__tstate);
11273 if (PyErr_Occurred()) SWIG_fail;
11274 }
11275 {
11276 resultobj = SWIG_From_long((long)(result));
11277 }
11278 {
11279 if (temp1)
11280 delete arg1;
11281 }
11282 return resultobj;
11283 fail:
11284 {
11285 if (temp1)
11286 delete arg1;
11287 }
11288 return NULL;
11289 }
11290
11291
11292 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11293 PyObject *resultobj;
11294 long arg1 ;
11295 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11296 wxKillError *arg3 = (wxKillError *) 0 ;
11297 int arg4 = (int) wxKILL_NOCHILDREN ;
11298 int result;
11299 wxKillError temp3 ;
11300 PyObject * obj0 = 0 ;
11301 PyObject * obj1 = 0 ;
11302 PyObject * obj2 = 0 ;
11303 char *kwnames[] = {
11304 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11305 };
11306
11307 {
11308 arg3 = &temp3;
11309 }
11310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11311 {
11312 arg1 = (long)(SWIG_As_long(obj0));
11313 if (SWIG_arg_fail(1)) SWIG_fail;
11314 }
11315 if (obj1) {
11316 {
11317 arg2 = (wxSignal)(SWIG_As_int(obj1));
11318 if (SWIG_arg_fail(2)) SWIG_fail;
11319 }
11320 }
11321 if (obj2) {
11322 {
11323 arg4 = (int)(SWIG_As_int(obj2));
11324 if (SWIG_arg_fail(4)) SWIG_fail;
11325 }
11326 }
11327 {
11328 PyThreadState* __tstate = wxPyBeginAllowThreads();
11329 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11330
11331 wxPyEndAllowThreads(__tstate);
11332 if (PyErr_Occurred()) SWIG_fail;
11333 }
11334 {
11335 resultobj = SWIG_From_int((int)(result));
11336 }
11337 {
11338 PyObject* o;
11339 o = PyInt_FromLong((long) (*arg3));
11340 resultobj = t_output_helper(resultobj, o);
11341 }
11342 return resultobj;
11343 fail:
11344 return NULL;
11345 }
11346
11347
11348 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11349 PyObject *resultobj;
11350 int arg1 = (int) wxJOYSTICK1 ;
11351 wxJoystick *result;
11352 PyObject * obj0 = 0 ;
11353 char *kwnames[] = {
11354 (char *) "joystick", NULL
11355 };
11356
11357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11358 if (obj0) {
11359 {
11360 arg1 = (int)(SWIG_As_int(obj0));
11361 if (SWIG_arg_fail(1)) SWIG_fail;
11362 }
11363 }
11364 {
11365 if (!wxPyCheckForApp()) SWIG_fail;
11366 PyThreadState* __tstate = wxPyBeginAllowThreads();
11367 result = (wxJoystick *)new wxJoystick(arg1);
11368
11369 wxPyEndAllowThreads(__tstate);
11370 if (PyErr_Occurred()) SWIG_fail;
11371 }
11372 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11373 return resultobj;
11374 fail:
11375 return NULL;
11376 }
11377
11378
11379 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11380 PyObject *resultobj;
11381 wxJoystick *arg1 = (wxJoystick *) 0 ;
11382 PyObject * obj0 = 0 ;
11383 char *kwnames[] = {
11384 (char *) "self", NULL
11385 };
11386
11387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11389 if (SWIG_arg_fail(1)) SWIG_fail;
11390 {
11391 PyThreadState* __tstate = wxPyBeginAllowThreads();
11392 delete arg1;
11393
11394 wxPyEndAllowThreads(__tstate);
11395 if (PyErr_Occurred()) SWIG_fail;
11396 }
11397 Py_INCREF(Py_None); resultobj = Py_None;
11398 return resultobj;
11399 fail:
11400 return NULL;
11401 }
11402
11403
11404 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11405 PyObject *resultobj;
11406 wxJoystick *arg1 = (wxJoystick *) 0 ;
11407 wxPoint result;
11408 PyObject * obj0 = 0 ;
11409 char *kwnames[] = {
11410 (char *) "self", NULL
11411 };
11412
11413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11415 if (SWIG_arg_fail(1)) SWIG_fail;
11416 {
11417 PyThreadState* __tstate = wxPyBeginAllowThreads();
11418 result = (arg1)->GetPosition();
11419
11420 wxPyEndAllowThreads(__tstate);
11421 if (PyErr_Occurred()) SWIG_fail;
11422 }
11423 {
11424 wxPoint * resultptr;
11425 resultptr = new wxPoint((wxPoint &)(result));
11426 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11427 }
11428 return resultobj;
11429 fail:
11430 return NULL;
11431 }
11432
11433
11434 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11435 PyObject *resultobj;
11436 wxJoystick *arg1 = (wxJoystick *) 0 ;
11437 int result;
11438 PyObject * obj0 = 0 ;
11439 char *kwnames[] = {
11440 (char *) "self", NULL
11441 };
11442
11443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11445 if (SWIG_arg_fail(1)) SWIG_fail;
11446 {
11447 PyThreadState* __tstate = wxPyBeginAllowThreads();
11448 result = (int)(arg1)->GetZPosition();
11449
11450 wxPyEndAllowThreads(__tstate);
11451 if (PyErr_Occurred()) SWIG_fail;
11452 }
11453 {
11454 resultobj = SWIG_From_int((int)(result));
11455 }
11456 return resultobj;
11457 fail:
11458 return NULL;
11459 }
11460
11461
11462 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11463 PyObject *resultobj;
11464 wxJoystick *arg1 = (wxJoystick *) 0 ;
11465 int result;
11466 PyObject * obj0 = 0 ;
11467 char *kwnames[] = {
11468 (char *) "self", NULL
11469 };
11470
11471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11473 if (SWIG_arg_fail(1)) SWIG_fail;
11474 {
11475 PyThreadState* __tstate = wxPyBeginAllowThreads();
11476 result = (int)(arg1)->GetButtonState();
11477
11478 wxPyEndAllowThreads(__tstate);
11479 if (PyErr_Occurred()) SWIG_fail;
11480 }
11481 {
11482 resultobj = SWIG_From_int((int)(result));
11483 }
11484 return resultobj;
11485 fail:
11486 return NULL;
11487 }
11488
11489
11490 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11491 PyObject *resultobj;
11492 wxJoystick *arg1 = (wxJoystick *) 0 ;
11493 int result;
11494 PyObject * obj0 = 0 ;
11495 char *kwnames[] = {
11496 (char *) "self", NULL
11497 };
11498
11499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11501 if (SWIG_arg_fail(1)) SWIG_fail;
11502 {
11503 PyThreadState* __tstate = wxPyBeginAllowThreads();
11504 result = (int)(arg1)->GetPOVPosition();
11505
11506 wxPyEndAllowThreads(__tstate);
11507 if (PyErr_Occurred()) SWIG_fail;
11508 }
11509 {
11510 resultobj = SWIG_From_int((int)(result));
11511 }
11512 return resultobj;
11513 fail:
11514 return NULL;
11515 }
11516
11517
11518 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11519 PyObject *resultobj;
11520 wxJoystick *arg1 = (wxJoystick *) 0 ;
11521 int result;
11522 PyObject * obj0 = 0 ;
11523 char *kwnames[] = {
11524 (char *) "self", NULL
11525 };
11526
11527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11529 if (SWIG_arg_fail(1)) SWIG_fail;
11530 {
11531 PyThreadState* __tstate = wxPyBeginAllowThreads();
11532 result = (int)(arg1)->GetPOVCTSPosition();
11533
11534 wxPyEndAllowThreads(__tstate);
11535 if (PyErr_Occurred()) SWIG_fail;
11536 }
11537 {
11538 resultobj = SWIG_From_int((int)(result));
11539 }
11540 return resultobj;
11541 fail:
11542 return NULL;
11543 }
11544
11545
11546 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11547 PyObject *resultobj;
11548 wxJoystick *arg1 = (wxJoystick *) 0 ;
11549 int result;
11550 PyObject * obj0 = 0 ;
11551 char *kwnames[] = {
11552 (char *) "self", NULL
11553 };
11554
11555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11557 if (SWIG_arg_fail(1)) SWIG_fail;
11558 {
11559 PyThreadState* __tstate = wxPyBeginAllowThreads();
11560 result = (int)(arg1)->GetRudderPosition();
11561
11562 wxPyEndAllowThreads(__tstate);
11563 if (PyErr_Occurred()) SWIG_fail;
11564 }
11565 {
11566 resultobj = SWIG_From_int((int)(result));
11567 }
11568 return resultobj;
11569 fail:
11570 return NULL;
11571 }
11572
11573
11574 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11575 PyObject *resultobj;
11576 wxJoystick *arg1 = (wxJoystick *) 0 ;
11577 int result;
11578 PyObject * obj0 = 0 ;
11579 char *kwnames[] = {
11580 (char *) "self", NULL
11581 };
11582
11583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11585 if (SWIG_arg_fail(1)) SWIG_fail;
11586 {
11587 PyThreadState* __tstate = wxPyBeginAllowThreads();
11588 result = (int)(arg1)->GetUPosition();
11589
11590 wxPyEndAllowThreads(__tstate);
11591 if (PyErr_Occurred()) SWIG_fail;
11592 }
11593 {
11594 resultobj = SWIG_From_int((int)(result));
11595 }
11596 return resultobj;
11597 fail:
11598 return NULL;
11599 }
11600
11601
11602 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11603 PyObject *resultobj;
11604 wxJoystick *arg1 = (wxJoystick *) 0 ;
11605 int result;
11606 PyObject * obj0 = 0 ;
11607 char *kwnames[] = {
11608 (char *) "self", NULL
11609 };
11610
11611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11613 if (SWIG_arg_fail(1)) SWIG_fail;
11614 {
11615 PyThreadState* __tstate = wxPyBeginAllowThreads();
11616 result = (int)(arg1)->GetVPosition();
11617
11618 wxPyEndAllowThreads(__tstate);
11619 if (PyErr_Occurred()) SWIG_fail;
11620 }
11621 {
11622 resultobj = SWIG_From_int((int)(result));
11623 }
11624 return resultobj;
11625 fail:
11626 return NULL;
11627 }
11628
11629
11630 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11631 PyObject *resultobj;
11632 wxJoystick *arg1 = (wxJoystick *) 0 ;
11633 int result;
11634 PyObject * obj0 = 0 ;
11635 char *kwnames[] = {
11636 (char *) "self", NULL
11637 };
11638
11639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11641 if (SWIG_arg_fail(1)) SWIG_fail;
11642 {
11643 PyThreadState* __tstate = wxPyBeginAllowThreads();
11644 result = (int)(arg1)->GetMovementThreshold();
11645
11646 wxPyEndAllowThreads(__tstate);
11647 if (PyErr_Occurred()) SWIG_fail;
11648 }
11649 {
11650 resultobj = SWIG_From_int((int)(result));
11651 }
11652 return resultobj;
11653 fail:
11654 return NULL;
11655 }
11656
11657
11658 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11659 PyObject *resultobj;
11660 wxJoystick *arg1 = (wxJoystick *) 0 ;
11661 int arg2 ;
11662 PyObject * obj0 = 0 ;
11663 PyObject * obj1 = 0 ;
11664 char *kwnames[] = {
11665 (char *) "self",(char *) "threshold", NULL
11666 };
11667
11668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11670 if (SWIG_arg_fail(1)) SWIG_fail;
11671 {
11672 arg2 = (int)(SWIG_As_int(obj1));
11673 if (SWIG_arg_fail(2)) SWIG_fail;
11674 }
11675 {
11676 PyThreadState* __tstate = wxPyBeginAllowThreads();
11677 (arg1)->SetMovementThreshold(arg2);
11678
11679 wxPyEndAllowThreads(__tstate);
11680 if (PyErr_Occurred()) SWIG_fail;
11681 }
11682 Py_INCREF(Py_None); resultobj = Py_None;
11683 return resultobj;
11684 fail:
11685 return NULL;
11686 }
11687
11688
11689 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11690 PyObject *resultobj;
11691 wxJoystick *arg1 = (wxJoystick *) 0 ;
11692 bool result;
11693 PyObject * obj0 = 0 ;
11694 char *kwnames[] = {
11695 (char *) "self", NULL
11696 };
11697
11698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11700 if (SWIG_arg_fail(1)) SWIG_fail;
11701 {
11702 PyThreadState* __tstate = wxPyBeginAllowThreads();
11703 result = (bool)(arg1)->IsOk();
11704
11705 wxPyEndAllowThreads(__tstate);
11706 if (PyErr_Occurred()) SWIG_fail;
11707 }
11708 {
11709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11710 }
11711 return resultobj;
11712 fail:
11713 return NULL;
11714 }
11715
11716
11717 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11718 PyObject *resultobj;
11719 wxJoystick *arg1 = (wxJoystick *) 0 ;
11720 int result;
11721 PyObject * obj0 = 0 ;
11722 char *kwnames[] = {
11723 (char *) "self", NULL
11724 };
11725
11726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11728 if (SWIG_arg_fail(1)) SWIG_fail;
11729 {
11730 PyThreadState* __tstate = wxPyBeginAllowThreads();
11731 result = (int)(arg1)->GetNumberJoysticks();
11732
11733 wxPyEndAllowThreads(__tstate);
11734 if (PyErr_Occurred()) SWIG_fail;
11735 }
11736 {
11737 resultobj = SWIG_From_int((int)(result));
11738 }
11739 return resultobj;
11740 fail:
11741 return NULL;
11742 }
11743
11744
11745 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11746 PyObject *resultobj;
11747 wxJoystick *arg1 = (wxJoystick *) 0 ;
11748 int result;
11749 PyObject * obj0 = 0 ;
11750 char *kwnames[] = {
11751 (char *) "self", NULL
11752 };
11753
11754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11756 if (SWIG_arg_fail(1)) SWIG_fail;
11757 {
11758 PyThreadState* __tstate = wxPyBeginAllowThreads();
11759 result = (int)(arg1)->GetManufacturerId();
11760
11761 wxPyEndAllowThreads(__tstate);
11762 if (PyErr_Occurred()) SWIG_fail;
11763 }
11764 {
11765 resultobj = SWIG_From_int((int)(result));
11766 }
11767 return resultobj;
11768 fail:
11769 return NULL;
11770 }
11771
11772
11773 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11774 PyObject *resultobj;
11775 wxJoystick *arg1 = (wxJoystick *) 0 ;
11776 int result;
11777 PyObject * obj0 = 0 ;
11778 char *kwnames[] = {
11779 (char *) "self", NULL
11780 };
11781
11782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11784 if (SWIG_arg_fail(1)) SWIG_fail;
11785 {
11786 PyThreadState* __tstate = wxPyBeginAllowThreads();
11787 result = (int)(arg1)->GetProductId();
11788
11789 wxPyEndAllowThreads(__tstate);
11790 if (PyErr_Occurred()) SWIG_fail;
11791 }
11792 {
11793 resultobj = SWIG_From_int((int)(result));
11794 }
11795 return resultobj;
11796 fail:
11797 return NULL;
11798 }
11799
11800
11801 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11802 PyObject *resultobj;
11803 wxJoystick *arg1 = (wxJoystick *) 0 ;
11804 wxString result;
11805 PyObject * obj0 = 0 ;
11806 char *kwnames[] = {
11807 (char *) "self", NULL
11808 };
11809
11810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11812 if (SWIG_arg_fail(1)) SWIG_fail;
11813 {
11814 PyThreadState* __tstate = wxPyBeginAllowThreads();
11815 result = (arg1)->GetProductName();
11816
11817 wxPyEndAllowThreads(__tstate);
11818 if (PyErr_Occurred()) SWIG_fail;
11819 }
11820 {
11821 #if wxUSE_UNICODE
11822 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11823 #else
11824 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11825 #endif
11826 }
11827 return resultobj;
11828 fail:
11829 return NULL;
11830 }
11831
11832
11833 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
11834 PyObject *resultobj;
11835 wxJoystick *arg1 = (wxJoystick *) 0 ;
11836 int result;
11837 PyObject * obj0 = 0 ;
11838 char *kwnames[] = {
11839 (char *) "self", NULL
11840 };
11841
11842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
11843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11844 if (SWIG_arg_fail(1)) SWIG_fail;
11845 {
11846 PyThreadState* __tstate = wxPyBeginAllowThreads();
11847 result = (int)(arg1)->GetXMin();
11848
11849 wxPyEndAllowThreads(__tstate);
11850 if (PyErr_Occurred()) SWIG_fail;
11851 }
11852 {
11853 resultobj = SWIG_From_int((int)(result));
11854 }
11855 return resultobj;
11856 fail:
11857 return NULL;
11858 }
11859
11860
11861 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
11862 PyObject *resultobj;
11863 wxJoystick *arg1 = (wxJoystick *) 0 ;
11864 int result;
11865 PyObject * obj0 = 0 ;
11866 char *kwnames[] = {
11867 (char *) "self", NULL
11868 };
11869
11870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
11871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11872 if (SWIG_arg_fail(1)) SWIG_fail;
11873 {
11874 PyThreadState* __tstate = wxPyBeginAllowThreads();
11875 result = (int)(arg1)->GetYMin();
11876
11877 wxPyEndAllowThreads(__tstate);
11878 if (PyErr_Occurred()) SWIG_fail;
11879 }
11880 {
11881 resultobj = SWIG_From_int((int)(result));
11882 }
11883 return resultobj;
11884 fail:
11885 return NULL;
11886 }
11887
11888
11889 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
11890 PyObject *resultobj;
11891 wxJoystick *arg1 = (wxJoystick *) 0 ;
11892 int result;
11893 PyObject * obj0 = 0 ;
11894 char *kwnames[] = {
11895 (char *) "self", NULL
11896 };
11897
11898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
11899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11900 if (SWIG_arg_fail(1)) SWIG_fail;
11901 {
11902 PyThreadState* __tstate = wxPyBeginAllowThreads();
11903 result = (int)(arg1)->GetZMin();
11904
11905 wxPyEndAllowThreads(__tstate);
11906 if (PyErr_Occurred()) SWIG_fail;
11907 }
11908 {
11909 resultobj = SWIG_From_int((int)(result));
11910 }
11911 return resultobj;
11912 fail:
11913 return NULL;
11914 }
11915
11916
11917 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
11918 PyObject *resultobj;
11919 wxJoystick *arg1 = (wxJoystick *) 0 ;
11920 int result;
11921 PyObject * obj0 = 0 ;
11922 char *kwnames[] = {
11923 (char *) "self", NULL
11924 };
11925
11926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
11927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11928 if (SWIG_arg_fail(1)) SWIG_fail;
11929 {
11930 PyThreadState* __tstate = wxPyBeginAllowThreads();
11931 result = (int)(arg1)->GetXMax();
11932
11933 wxPyEndAllowThreads(__tstate);
11934 if (PyErr_Occurred()) SWIG_fail;
11935 }
11936 {
11937 resultobj = SWIG_From_int((int)(result));
11938 }
11939 return resultobj;
11940 fail:
11941 return NULL;
11942 }
11943
11944
11945 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
11946 PyObject *resultobj;
11947 wxJoystick *arg1 = (wxJoystick *) 0 ;
11948 int result;
11949 PyObject * obj0 = 0 ;
11950 char *kwnames[] = {
11951 (char *) "self", NULL
11952 };
11953
11954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
11955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11956 if (SWIG_arg_fail(1)) SWIG_fail;
11957 {
11958 PyThreadState* __tstate = wxPyBeginAllowThreads();
11959 result = (int)(arg1)->GetYMax();
11960
11961 wxPyEndAllowThreads(__tstate);
11962 if (PyErr_Occurred()) SWIG_fail;
11963 }
11964 {
11965 resultobj = SWIG_From_int((int)(result));
11966 }
11967 return resultobj;
11968 fail:
11969 return NULL;
11970 }
11971
11972
11973 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
11974 PyObject *resultobj;
11975 wxJoystick *arg1 = (wxJoystick *) 0 ;
11976 int result;
11977 PyObject * obj0 = 0 ;
11978 char *kwnames[] = {
11979 (char *) "self", NULL
11980 };
11981
11982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
11983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11984 if (SWIG_arg_fail(1)) SWIG_fail;
11985 {
11986 PyThreadState* __tstate = wxPyBeginAllowThreads();
11987 result = (int)(arg1)->GetZMax();
11988
11989 wxPyEndAllowThreads(__tstate);
11990 if (PyErr_Occurred()) SWIG_fail;
11991 }
11992 {
11993 resultobj = SWIG_From_int((int)(result));
11994 }
11995 return resultobj;
11996 fail:
11997 return NULL;
11998 }
11999
12000
12001 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12002 PyObject *resultobj;
12003 wxJoystick *arg1 = (wxJoystick *) 0 ;
12004 int result;
12005 PyObject * obj0 = 0 ;
12006 char *kwnames[] = {
12007 (char *) "self", NULL
12008 };
12009
12010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12012 if (SWIG_arg_fail(1)) SWIG_fail;
12013 {
12014 PyThreadState* __tstate = wxPyBeginAllowThreads();
12015 result = (int)(arg1)->GetNumberButtons();
12016
12017 wxPyEndAllowThreads(__tstate);
12018 if (PyErr_Occurred()) SWIG_fail;
12019 }
12020 {
12021 resultobj = SWIG_From_int((int)(result));
12022 }
12023 return resultobj;
12024 fail:
12025 return NULL;
12026 }
12027
12028
12029 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12030 PyObject *resultobj;
12031 wxJoystick *arg1 = (wxJoystick *) 0 ;
12032 int result;
12033 PyObject * obj0 = 0 ;
12034 char *kwnames[] = {
12035 (char *) "self", NULL
12036 };
12037
12038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12040 if (SWIG_arg_fail(1)) SWIG_fail;
12041 {
12042 PyThreadState* __tstate = wxPyBeginAllowThreads();
12043 result = (int)(arg1)->GetNumberAxes();
12044
12045 wxPyEndAllowThreads(__tstate);
12046 if (PyErr_Occurred()) SWIG_fail;
12047 }
12048 {
12049 resultobj = SWIG_From_int((int)(result));
12050 }
12051 return resultobj;
12052 fail:
12053 return NULL;
12054 }
12055
12056
12057 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12058 PyObject *resultobj;
12059 wxJoystick *arg1 = (wxJoystick *) 0 ;
12060 int result;
12061 PyObject * obj0 = 0 ;
12062 char *kwnames[] = {
12063 (char *) "self", NULL
12064 };
12065
12066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12068 if (SWIG_arg_fail(1)) SWIG_fail;
12069 {
12070 PyThreadState* __tstate = wxPyBeginAllowThreads();
12071 result = (int)(arg1)->GetMaxButtons();
12072
12073 wxPyEndAllowThreads(__tstate);
12074 if (PyErr_Occurred()) SWIG_fail;
12075 }
12076 {
12077 resultobj = SWIG_From_int((int)(result));
12078 }
12079 return resultobj;
12080 fail:
12081 return NULL;
12082 }
12083
12084
12085 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12086 PyObject *resultobj;
12087 wxJoystick *arg1 = (wxJoystick *) 0 ;
12088 int result;
12089 PyObject * obj0 = 0 ;
12090 char *kwnames[] = {
12091 (char *) "self", NULL
12092 };
12093
12094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12096 if (SWIG_arg_fail(1)) SWIG_fail;
12097 {
12098 PyThreadState* __tstate = wxPyBeginAllowThreads();
12099 result = (int)(arg1)->GetMaxAxes();
12100
12101 wxPyEndAllowThreads(__tstate);
12102 if (PyErr_Occurred()) SWIG_fail;
12103 }
12104 {
12105 resultobj = SWIG_From_int((int)(result));
12106 }
12107 return resultobj;
12108 fail:
12109 return NULL;
12110 }
12111
12112
12113 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12114 PyObject *resultobj;
12115 wxJoystick *arg1 = (wxJoystick *) 0 ;
12116 int result;
12117 PyObject * obj0 = 0 ;
12118 char *kwnames[] = {
12119 (char *) "self", NULL
12120 };
12121
12122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12124 if (SWIG_arg_fail(1)) SWIG_fail;
12125 {
12126 PyThreadState* __tstate = wxPyBeginAllowThreads();
12127 result = (int)(arg1)->GetPollingMin();
12128
12129 wxPyEndAllowThreads(__tstate);
12130 if (PyErr_Occurred()) SWIG_fail;
12131 }
12132 {
12133 resultobj = SWIG_From_int((int)(result));
12134 }
12135 return resultobj;
12136 fail:
12137 return NULL;
12138 }
12139
12140
12141 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12142 PyObject *resultobj;
12143 wxJoystick *arg1 = (wxJoystick *) 0 ;
12144 int result;
12145 PyObject * obj0 = 0 ;
12146 char *kwnames[] = {
12147 (char *) "self", NULL
12148 };
12149
12150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12152 if (SWIG_arg_fail(1)) SWIG_fail;
12153 {
12154 PyThreadState* __tstate = wxPyBeginAllowThreads();
12155 result = (int)(arg1)->GetPollingMax();
12156
12157 wxPyEndAllowThreads(__tstate);
12158 if (PyErr_Occurred()) SWIG_fail;
12159 }
12160 {
12161 resultobj = SWIG_From_int((int)(result));
12162 }
12163 return resultobj;
12164 fail:
12165 return NULL;
12166 }
12167
12168
12169 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12170 PyObject *resultobj;
12171 wxJoystick *arg1 = (wxJoystick *) 0 ;
12172 int result;
12173 PyObject * obj0 = 0 ;
12174 char *kwnames[] = {
12175 (char *) "self", NULL
12176 };
12177
12178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12180 if (SWIG_arg_fail(1)) SWIG_fail;
12181 {
12182 PyThreadState* __tstate = wxPyBeginAllowThreads();
12183 result = (int)(arg1)->GetRudderMin();
12184
12185 wxPyEndAllowThreads(__tstate);
12186 if (PyErr_Occurred()) SWIG_fail;
12187 }
12188 {
12189 resultobj = SWIG_From_int((int)(result));
12190 }
12191 return resultobj;
12192 fail:
12193 return NULL;
12194 }
12195
12196
12197 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12198 PyObject *resultobj;
12199 wxJoystick *arg1 = (wxJoystick *) 0 ;
12200 int result;
12201 PyObject * obj0 = 0 ;
12202 char *kwnames[] = {
12203 (char *) "self", NULL
12204 };
12205
12206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12208 if (SWIG_arg_fail(1)) SWIG_fail;
12209 {
12210 PyThreadState* __tstate = wxPyBeginAllowThreads();
12211 result = (int)(arg1)->GetRudderMax();
12212
12213 wxPyEndAllowThreads(__tstate);
12214 if (PyErr_Occurred()) SWIG_fail;
12215 }
12216 {
12217 resultobj = SWIG_From_int((int)(result));
12218 }
12219 return resultobj;
12220 fail:
12221 return NULL;
12222 }
12223
12224
12225 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12226 PyObject *resultobj;
12227 wxJoystick *arg1 = (wxJoystick *) 0 ;
12228 int result;
12229 PyObject * obj0 = 0 ;
12230 char *kwnames[] = {
12231 (char *) "self", NULL
12232 };
12233
12234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12236 if (SWIG_arg_fail(1)) SWIG_fail;
12237 {
12238 PyThreadState* __tstate = wxPyBeginAllowThreads();
12239 result = (int)(arg1)->GetUMin();
12240
12241 wxPyEndAllowThreads(__tstate);
12242 if (PyErr_Occurred()) SWIG_fail;
12243 }
12244 {
12245 resultobj = SWIG_From_int((int)(result));
12246 }
12247 return resultobj;
12248 fail:
12249 return NULL;
12250 }
12251
12252
12253 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12254 PyObject *resultobj;
12255 wxJoystick *arg1 = (wxJoystick *) 0 ;
12256 int result;
12257 PyObject * obj0 = 0 ;
12258 char *kwnames[] = {
12259 (char *) "self", NULL
12260 };
12261
12262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12264 if (SWIG_arg_fail(1)) SWIG_fail;
12265 {
12266 PyThreadState* __tstate = wxPyBeginAllowThreads();
12267 result = (int)(arg1)->GetUMax();
12268
12269 wxPyEndAllowThreads(__tstate);
12270 if (PyErr_Occurred()) SWIG_fail;
12271 }
12272 {
12273 resultobj = SWIG_From_int((int)(result));
12274 }
12275 return resultobj;
12276 fail:
12277 return NULL;
12278 }
12279
12280
12281 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12282 PyObject *resultobj;
12283 wxJoystick *arg1 = (wxJoystick *) 0 ;
12284 int result;
12285 PyObject * obj0 = 0 ;
12286 char *kwnames[] = {
12287 (char *) "self", NULL
12288 };
12289
12290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12292 if (SWIG_arg_fail(1)) SWIG_fail;
12293 {
12294 PyThreadState* __tstate = wxPyBeginAllowThreads();
12295 result = (int)(arg1)->GetVMin();
12296
12297 wxPyEndAllowThreads(__tstate);
12298 if (PyErr_Occurred()) SWIG_fail;
12299 }
12300 {
12301 resultobj = SWIG_From_int((int)(result));
12302 }
12303 return resultobj;
12304 fail:
12305 return NULL;
12306 }
12307
12308
12309 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12310 PyObject *resultobj;
12311 wxJoystick *arg1 = (wxJoystick *) 0 ;
12312 int result;
12313 PyObject * obj0 = 0 ;
12314 char *kwnames[] = {
12315 (char *) "self", NULL
12316 };
12317
12318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12320 if (SWIG_arg_fail(1)) SWIG_fail;
12321 {
12322 PyThreadState* __tstate = wxPyBeginAllowThreads();
12323 result = (int)(arg1)->GetVMax();
12324
12325 wxPyEndAllowThreads(__tstate);
12326 if (PyErr_Occurred()) SWIG_fail;
12327 }
12328 {
12329 resultobj = SWIG_From_int((int)(result));
12330 }
12331 return resultobj;
12332 fail:
12333 return NULL;
12334 }
12335
12336
12337 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12338 PyObject *resultobj;
12339 wxJoystick *arg1 = (wxJoystick *) 0 ;
12340 bool result;
12341 PyObject * obj0 = 0 ;
12342 char *kwnames[] = {
12343 (char *) "self", NULL
12344 };
12345
12346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12348 if (SWIG_arg_fail(1)) SWIG_fail;
12349 {
12350 PyThreadState* __tstate = wxPyBeginAllowThreads();
12351 result = (bool)(arg1)->HasRudder();
12352
12353 wxPyEndAllowThreads(__tstate);
12354 if (PyErr_Occurred()) SWIG_fail;
12355 }
12356 {
12357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12358 }
12359 return resultobj;
12360 fail:
12361 return NULL;
12362 }
12363
12364
12365 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12366 PyObject *resultobj;
12367 wxJoystick *arg1 = (wxJoystick *) 0 ;
12368 bool result;
12369 PyObject * obj0 = 0 ;
12370 char *kwnames[] = {
12371 (char *) "self", NULL
12372 };
12373
12374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12376 if (SWIG_arg_fail(1)) SWIG_fail;
12377 {
12378 PyThreadState* __tstate = wxPyBeginAllowThreads();
12379 result = (bool)(arg1)->HasZ();
12380
12381 wxPyEndAllowThreads(__tstate);
12382 if (PyErr_Occurred()) SWIG_fail;
12383 }
12384 {
12385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12386 }
12387 return resultobj;
12388 fail:
12389 return NULL;
12390 }
12391
12392
12393 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12394 PyObject *resultobj;
12395 wxJoystick *arg1 = (wxJoystick *) 0 ;
12396 bool result;
12397 PyObject * obj0 = 0 ;
12398 char *kwnames[] = {
12399 (char *) "self", NULL
12400 };
12401
12402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12404 if (SWIG_arg_fail(1)) SWIG_fail;
12405 {
12406 PyThreadState* __tstate = wxPyBeginAllowThreads();
12407 result = (bool)(arg1)->HasU();
12408
12409 wxPyEndAllowThreads(__tstate);
12410 if (PyErr_Occurred()) SWIG_fail;
12411 }
12412 {
12413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12414 }
12415 return resultobj;
12416 fail:
12417 return NULL;
12418 }
12419
12420
12421 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12422 PyObject *resultobj;
12423 wxJoystick *arg1 = (wxJoystick *) 0 ;
12424 bool result;
12425 PyObject * obj0 = 0 ;
12426 char *kwnames[] = {
12427 (char *) "self", NULL
12428 };
12429
12430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12432 if (SWIG_arg_fail(1)) SWIG_fail;
12433 {
12434 PyThreadState* __tstate = wxPyBeginAllowThreads();
12435 result = (bool)(arg1)->HasV();
12436
12437 wxPyEndAllowThreads(__tstate);
12438 if (PyErr_Occurred()) SWIG_fail;
12439 }
12440 {
12441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12442 }
12443 return resultobj;
12444 fail:
12445 return NULL;
12446 }
12447
12448
12449 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12450 PyObject *resultobj;
12451 wxJoystick *arg1 = (wxJoystick *) 0 ;
12452 bool result;
12453 PyObject * obj0 = 0 ;
12454 char *kwnames[] = {
12455 (char *) "self", NULL
12456 };
12457
12458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12460 if (SWIG_arg_fail(1)) SWIG_fail;
12461 {
12462 PyThreadState* __tstate = wxPyBeginAllowThreads();
12463 result = (bool)(arg1)->HasPOV();
12464
12465 wxPyEndAllowThreads(__tstate);
12466 if (PyErr_Occurred()) SWIG_fail;
12467 }
12468 {
12469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12470 }
12471 return resultobj;
12472 fail:
12473 return NULL;
12474 }
12475
12476
12477 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12478 PyObject *resultobj;
12479 wxJoystick *arg1 = (wxJoystick *) 0 ;
12480 bool result;
12481 PyObject * obj0 = 0 ;
12482 char *kwnames[] = {
12483 (char *) "self", NULL
12484 };
12485
12486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12488 if (SWIG_arg_fail(1)) SWIG_fail;
12489 {
12490 PyThreadState* __tstate = wxPyBeginAllowThreads();
12491 result = (bool)(arg1)->HasPOV4Dir();
12492
12493 wxPyEndAllowThreads(__tstate);
12494 if (PyErr_Occurred()) SWIG_fail;
12495 }
12496 {
12497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12498 }
12499 return resultobj;
12500 fail:
12501 return NULL;
12502 }
12503
12504
12505 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12506 PyObject *resultobj;
12507 wxJoystick *arg1 = (wxJoystick *) 0 ;
12508 bool result;
12509 PyObject * obj0 = 0 ;
12510 char *kwnames[] = {
12511 (char *) "self", NULL
12512 };
12513
12514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12516 if (SWIG_arg_fail(1)) SWIG_fail;
12517 {
12518 PyThreadState* __tstate = wxPyBeginAllowThreads();
12519 result = (bool)(arg1)->HasPOVCTS();
12520
12521 wxPyEndAllowThreads(__tstate);
12522 if (PyErr_Occurred()) SWIG_fail;
12523 }
12524 {
12525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12526 }
12527 return resultobj;
12528 fail:
12529 return NULL;
12530 }
12531
12532
12533 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12534 PyObject *resultobj;
12535 wxJoystick *arg1 = (wxJoystick *) 0 ;
12536 wxWindow *arg2 = (wxWindow *) 0 ;
12537 int arg3 = (int) 0 ;
12538 bool result;
12539 PyObject * obj0 = 0 ;
12540 PyObject * obj1 = 0 ;
12541 PyObject * obj2 = 0 ;
12542 char *kwnames[] = {
12543 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12544 };
12545
12546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12548 if (SWIG_arg_fail(1)) SWIG_fail;
12549 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12550 if (SWIG_arg_fail(2)) SWIG_fail;
12551 if (obj2) {
12552 {
12553 arg3 = (int)(SWIG_As_int(obj2));
12554 if (SWIG_arg_fail(3)) SWIG_fail;
12555 }
12556 }
12557 {
12558 PyThreadState* __tstate = wxPyBeginAllowThreads();
12559 result = (bool)(arg1)->SetCapture(arg2,arg3);
12560
12561 wxPyEndAllowThreads(__tstate);
12562 if (PyErr_Occurred()) SWIG_fail;
12563 }
12564 {
12565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12566 }
12567 return resultobj;
12568 fail:
12569 return NULL;
12570 }
12571
12572
12573 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12574 PyObject *resultobj;
12575 wxJoystick *arg1 = (wxJoystick *) 0 ;
12576 bool result;
12577 PyObject * obj0 = 0 ;
12578 char *kwnames[] = {
12579 (char *) "self", NULL
12580 };
12581
12582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12584 if (SWIG_arg_fail(1)) SWIG_fail;
12585 {
12586 PyThreadState* __tstate = wxPyBeginAllowThreads();
12587 result = (bool)(arg1)->ReleaseCapture();
12588
12589 wxPyEndAllowThreads(__tstate);
12590 if (PyErr_Occurred()) SWIG_fail;
12591 }
12592 {
12593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12594 }
12595 return resultobj;
12596 fail:
12597 return NULL;
12598 }
12599
12600
12601 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12602 PyObject *obj;
12603 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12604 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12605 Py_INCREF(obj);
12606 return Py_BuildValue((char *)"");
12607 }
12608 static PyObject *_wrap_JoystickEvent_m_pos_set(PyObject *, PyObject *args, PyObject *kwargs) {
12609 PyObject *resultobj;
12610 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12611 wxPoint *arg2 = (wxPoint *) 0 ;
12612 PyObject * obj0 = 0 ;
12613 PyObject * obj1 = 0 ;
12614 char *kwnames[] = {
12615 (char *) "self",(char *) "m_pos", NULL
12616 };
12617
12618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_pos_set",kwnames,&obj0,&obj1)) goto fail;
12619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12620 if (SWIG_arg_fail(1)) SWIG_fail;
12621 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12622 if (SWIG_arg_fail(2)) SWIG_fail;
12623 if (arg1) (arg1)->m_pos = *arg2;
12624
12625 Py_INCREF(Py_None); resultobj = Py_None;
12626 return resultobj;
12627 fail:
12628 return NULL;
12629 }
12630
12631
12632 static PyObject *_wrap_JoystickEvent_m_pos_get(PyObject *, PyObject *args, PyObject *kwargs) {
12633 PyObject *resultobj;
12634 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12635 wxPoint *result;
12636 PyObject * obj0 = 0 ;
12637 char *kwnames[] = {
12638 (char *) "self", NULL
12639 };
12640
12641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_pos_get",kwnames,&obj0)) goto fail;
12642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12643 if (SWIG_arg_fail(1)) SWIG_fail;
12644 result = (wxPoint *)& ((arg1)->m_pos);
12645
12646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
12647 return resultobj;
12648 fail:
12649 return NULL;
12650 }
12651
12652
12653 static PyObject *_wrap_JoystickEvent_m_zPosition_set(PyObject *, PyObject *args, PyObject *kwargs) {
12654 PyObject *resultobj;
12655 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12656 int arg2 ;
12657 PyObject * obj0 = 0 ;
12658 PyObject * obj1 = 0 ;
12659 char *kwnames[] = {
12660 (char *) "self",(char *) "m_zPosition", NULL
12661 };
12662
12663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_zPosition_set",kwnames,&obj0,&obj1)) goto fail;
12664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12665 if (SWIG_arg_fail(1)) SWIG_fail;
12666 {
12667 arg2 = (int)(SWIG_As_int(obj1));
12668 if (SWIG_arg_fail(2)) SWIG_fail;
12669 }
12670 if (arg1) (arg1)->m_zPosition = arg2;
12671
12672 Py_INCREF(Py_None); resultobj = Py_None;
12673 return resultobj;
12674 fail:
12675 return NULL;
12676 }
12677
12678
12679 static PyObject *_wrap_JoystickEvent_m_zPosition_get(PyObject *, PyObject *args, PyObject *kwargs) {
12680 PyObject *resultobj;
12681 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12682 int result;
12683 PyObject * obj0 = 0 ;
12684 char *kwnames[] = {
12685 (char *) "self", NULL
12686 };
12687
12688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_zPosition_get",kwnames,&obj0)) goto fail;
12689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12690 if (SWIG_arg_fail(1)) SWIG_fail;
12691 result = (int) ((arg1)->m_zPosition);
12692
12693 {
12694 resultobj = SWIG_From_int((int)(result));
12695 }
12696 return resultobj;
12697 fail:
12698 return NULL;
12699 }
12700
12701
12702 static PyObject *_wrap_JoystickEvent_m_buttonChange_set(PyObject *, PyObject *args, PyObject *kwargs) {
12703 PyObject *resultobj;
12704 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12705 int arg2 ;
12706 PyObject * obj0 = 0 ;
12707 PyObject * obj1 = 0 ;
12708 char *kwnames[] = {
12709 (char *) "self",(char *) "m_buttonChange", NULL
12710 };
12711
12712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_buttonChange_set",kwnames,&obj0,&obj1)) goto fail;
12713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12714 if (SWIG_arg_fail(1)) SWIG_fail;
12715 {
12716 arg2 = (int)(SWIG_As_int(obj1));
12717 if (SWIG_arg_fail(2)) SWIG_fail;
12718 }
12719 if (arg1) (arg1)->m_buttonChange = arg2;
12720
12721 Py_INCREF(Py_None); resultobj = Py_None;
12722 return resultobj;
12723 fail:
12724 return NULL;
12725 }
12726
12727
12728 static PyObject *_wrap_JoystickEvent_m_buttonChange_get(PyObject *, PyObject *args, PyObject *kwargs) {
12729 PyObject *resultobj;
12730 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12731 int result;
12732 PyObject * obj0 = 0 ;
12733 char *kwnames[] = {
12734 (char *) "self", NULL
12735 };
12736
12737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_buttonChange_get",kwnames,&obj0)) goto fail;
12738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12739 if (SWIG_arg_fail(1)) SWIG_fail;
12740 result = (int) ((arg1)->m_buttonChange);
12741
12742 {
12743 resultobj = SWIG_From_int((int)(result));
12744 }
12745 return resultobj;
12746 fail:
12747 return NULL;
12748 }
12749
12750
12751 static PyObject *_wrap_JoystickEvent_m_buttonState_set(PyObject *, PyObject *args, PyObject *kwargs) {
12752 PyObject *resultobj;
12753 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12754 int arg2 ;
12755 PyObject * obj0 = 0 ;
12756 PyObject * obj1 = 0 ;
12757 char *kwnames[] = {
12758 (char *) "self",(char *) "m_buttonState", NULL
12759 };
12760
12761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_buttonState_set",kwnames,&obj0,&obj1)) goto fail;
12762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12763 if (SWIG_arg_fail(1)) SWIG_fail;
12764 {
12765 arg2 = (int)(SWIG_As_int(obj1));
12766 if (SWIG_arg_fail(2)) SWIG_fail;
12767 }
12768 if (arg1) (arg1)->m_buttonState = arg2;
12769
12770 Py_INCREF(Py_None); resultobj = Py_None;
12771 return resultobj;
12772 fail:
12773 return NULL;
12774 }
12775
12776
12777 static PyObject *_wrap_JoystickEvent_m_buttonState_get(PyObject *, PyObject *args, PyObject *kwargs) {
12778 PyObject *resultobj;
12779 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12780 int result;
12781 PyObject * obj0 = 0 ;
12782 char *kwnames[] = {
12783 (char *) "self", NULL
12784 };
12785
12786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_buttonState_get",kwnames,&obj0)) goto fail;
12787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12788 if (SWIG_arg_fail(1)) SWIG_fail;
12789 result = (int) ((arg1)->m_buttonState);
12790
12791 {
12792 resultobj = SWIG_From_int((int)(result));
12793 }
12794 return resultobj;
12795 fail:
12796 return NULL;
12797 }
12798
12799
12800 static PyObject *_wrap_JoystickEvent_m_joyStick_set(PyObject *, PyObject *args, PyObject *kwargs) {
12801 PyObject *resultobj;
12802 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12803 int arg2 ;
12804 PyObject * obj0 = 0 ;
12805 PyObject * obj1 = 0 ;
12806 char *kwnames[] = {
12807 (char *) "self",(char *) "m_joyStick", NULL
12808 };
12809
12810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_joyStick_set",kwnames,&obj0,&obj1)) goto fail;
12811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12812 if (SWIG_arg_fail(1)) SWIG_fail;
12813 {
12814 arg2 = (int)(SWIG_As_int(obj1));
12815 if (SWIG_arg_fail(2)) SWIG_fail;
12816 }
12817 if (arg1) (arg1)->m_joyStick = arg2;
12818
12819 Py_INCREF(Py_None); resultobj = Py_None;
12820 return resultobj;
12821 fail:
12822 return NULL;
12823 }
12824
12825
12826 static PyObject *_wrap_JoystickEvent_m_joyStick_get(PyObject *, PyObject *args, PyObject *kwargs) {
12827 PyObject *resultobj;
12828 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12829 int result;
12830 PyObject * obj0 = 0 ;
12831 char *kwnames[] = {
12832 (char *) "self", NULL
12833 };
12834
12835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_joyStick_get",kwnames,&obj0)) goto fail;
12836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12837 if (SWIG_arg_fail(1)) SWIG_fail;
12838 result = (int) ((arg1)->m_joyStick);
12839
12840 {
12841 resultobj = SWIG_From_int((int)(result));
12842 }
12843 return resultobj;
12844 fail:
12845 return NULL;
12846 }
12847
12848
12849 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12850 PyObject *resultobj;
12851 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12852 int arg2 = (int) 0 ;
12853 int arg3 = (int) wxJOYSTICK1 ;
12854 int arg4 = (int) 0 ;
12855 wxJoystickEvent *result;
12856 PyObject * obj0 = 0 ;
12857 PyObject * obj1 = 0 ;
12858 PyObject * obj2 = 0 ;
12859 PyObject * obj3 = 0 ;
12860 char *kwnames[] = {
12861 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12862 };
12863
12864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12865 if (obj0) {
12866 {
12867 arg1 = (wxEventType)(SWIG_As_int(obj0));
12868 if (SWIG_arg_fail(1)) SWIG_fail;
12869 }
12870 }
12871 if (obj1) {
12872 {
12873 arg2 = (int)(SWIG_As_int(obj1));
12874 if (SWIG_arg_fail(2)) SWIG_fail;
12875 }
12876 }
12877 if (obj2) {
12878 {
12879 arg3 = (int)(SWIG_As_int(obj2));
12880 if (SWIG_arg_fail(3)) SWIG_fail;
12881 }
12882 }
12883 if (obj3) {
12884 {
12885 arg4 = (int)(SWIG_As_int(obj3));
12886 if (SWIG_arg_fail(4)) SWIG_fail;
12887 }
12888 }
12889 {
12890 PyThreadState* __tstate = wxPyBeginAllowThreads();
12891 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12892
12893 wxPyEndAllowThreads(__tstate);
12894 if (PyErr_Occurred()) SWIG_fail;
12895 }
12896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12897 return resultobj;
12898 fail:
12899 return NULL;
12900 }
12901
12902
12903 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12904 PyObject *resultobj;
12905 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12906 wxPoint result;
12907 PyObject * obj0 = 0 ;
12908 char *kwnames[] = {
12909 (char *) "self", NULL
12910 };
12911
12912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12914 if (SWIG_arg_fail(1)) SWIG_fail;
12915 {
12916 PyThreadState* __tstate = wxPyBeginAllowThreads();
12917 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12918
12919 wxPyEndAllowThreads(__tstate);
12920 if (PyErr_Occurred()) SWIG_fail;
12921 }
12922 {
12923 wxPoint * resultptr;
12924 resultptr = new wxPoint((wxPoint &)(result));
12925 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12926 }
12927 return resultobj;
12928 fail:
12929 return NULL;
12930 }
12931
12932
12933 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12934 PyObject *resultobj;
12935 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12936 int result;
12937 PyObject * obj0 = 0 ;
12938 char *kwnames[] = {
12939 (char *) "self", NULL
12940 };
12941
12942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12944 if (SWIG_arg_fail(1)) SWIG_fail;
12945 {
12946 PyThreadState* __tstate = wxPyBeginAllowThreads();
12947 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12948
12949 wxPyEndAllowThreads(__tstate);
12950 if (PyErr_Occurred()) SWIG_fail;
12951 }
12952 {
12953 resultobj = SWIG_From_int((int)(result));
12954 }
12955 return resultobj;
12956 fail:
12957 return NULL;
12958 }
12959
12960
12961 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12962 PyObject *resultobj;
12963 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12964 int result;
12965 PyObject * obj0 = 0 ;
12966 char *kwnames[] = {
12967 (char *) "self", NULL
12968 };
12969
12970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12972 if (SWIG_arg_fail(1)) SWIG_fail;
12973 {
12974 PyThreadState* __tstate = wxPyBeginAllowThreads();
12975 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12976
12977 wxPyEndAllowThreads(__tstate);
12978 if (PyErr_Occurred()) SWIG_fail;
12979 }
12980 {
12981 resultobj = SWIG_From_int((int)(result));
12982 }
12983 return resultobj;
12984 fail:
12985 return NULL;
12986 }
12987
12988
12989 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12990 PyObject *resultobj;
12991 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12992 int result;
12993 PyObject * obj0 = 0 ;
12994 char *kwnames[] = {
12995 (char *) "self", NULL
12996 };
12997
12998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13000 if (SWIG_arg_fail(1)) SWIG_fail;
13001 {
13002 PyThreadState* __tstate = wxPyBeginAllowThreads();
13003 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13004
13005 wxPyEndAllowThreads(__tstate);
13006 if (PyErr_Occurred()) SWIG_fail;
13007 }
13008 {
13009 resultobj = SWIG_From_int((int)(result));
13010 }
13011 return resultobj;
13012 fail:
13013 return NULL;
13014 }
13015
13016
13017 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13018 PyObject *resultobj;
13019 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13020 int result;
13021 PyObject * obj0 = 0 ;
13022 char *kwnames[] = {
13023 (char *) "self", NULL
13024 };
13025
13026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13028 if (SWIG_arg_fail(1)) SWIG_fail;
13029 {
13030 PyThreadState* __tstate = wxPyBeginAllowThreads();
13031 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13032
13033 wxPyEndAllowThreads(__tstate);
13034 if (PyErr_Occurred()) SWIG_fail;
13035 }
13036 {
13037 resultobj = SWIG_From_int((int)(result));
13038 }
13039 return resultobj;
13040 fail:
13041 return NULL;
13042 }
13043
13044
13045 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13046 PyObject *resultobj;
13047 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13048 int arg2 ;
13049 PyObject * obj0 = 0 ;
13050 PyObject * obj1 = 0 ;
13051 char *kwnames[] = {
13052 (char *) "self",(char *) "stick", NULL
13053 };
13054
13055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13057 if (SWIG_arg_fail(1)) SWIG_fail;
13058 {
13059 arg2 = (int)(SWIG_As_int(obj1));
13060 if (SWIG_arg_fail(2)) SWIG_fail;
13061 }
13062 {
13063 PyThreadState* __tstate = wxPyBeginAllowThreads();
13064 (arg1)->SetJoystick(arg2);
13065
13066 wxPyEndAllowThreads(__tstate);
13067 if (PyErr_Occurred()) SWIG_fail;
13068 }
13069 Py_INCREF(Py_None); resultobj = Py_None;
13070 return resultobj;
13071 fail:
13072 return NULL;
13073 }
13074
13075
13076 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13077 PyObject *resultobj;
13078 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13079 int arg2 ;
13080 PyObject * obj0 = 0 ;
13081 PyObject * obj1 = 0 ;
13082 char *kwnames[] = {
13083 (char *) "self",(char *) "state", NULL
13084 };
13085
13086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13088 if (SWIG_arg_fail(1)) SWIG_fail;
13089 {
13090 arg2 = (int)(SWIG_As_int(obj1));
13091 if (SWIG_arg_fail(2)) SWIG_fail;
13092 }
13093 {
13094 PyThreadState* __tstate = wxPyBeginAllowThreads();
13095 (arg1)->SetButtonState(arg2);
13096
13097 wxPyEndAllowThreads(__tstate);
13098 if (PyErr_Occurred()) SWIG_fail;
13099 }
13100 Py_INCREF(Py_None); resultobj = Py_None;
13101 return resultobj;
13102 fail:
13103 return NULL;
13104 }
13105
13106
13107 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13108 PyObject *resultobj;
13109 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13110 int arg2 ;
13111 PyObject * obj0 = 0 ;
13112 PyObject * obj1 = 0 ;
13113 char *kwnames[] = {
13114 (char *) "self",(char *) "change", NULL
13115 };
13116
13117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13119 if (SWIG_arg_fail(1)) SWIG_fail;
13120 {
13121 arg2 = (int)(SWIG_As_int(obj1));
13122 if (SWIG_arg_fail(2)) SWIG_fail;
13123 }
13124 {
13125 PyThreadState* __tstate = wxPyBeginAllowThreads();
13126 (arg1)->SetButtonChange(arg2);
13127
13128 wxPyEndAllowThreads(__tstate);
13129 if (PyErr_Occurred()) SWIG_fail;
13130 }
13131 Py_INCREF(Py_None); resultobj = Py_None;
13132 return resultobj;
13133 fail:
13134 return NULL;
13135 }
13136
13137
13138 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13139 PyObject *resultobj;
13140 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13141 wxPoint *arg2 = 0 ;
13142 wxPoint temp2 ;
13143 PyObject * obj0 = 0 ;
13144 PyObject * obj1 = 0 ;
13145 char *kwnames[] = {
13146 (char *) "self",(char *) "pos", NULL
13147 };
13148
13149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13151 if (SWIG_arg_fail(1)) SWIG_fail;
13152 {
13153 arg2 = &temp2;
13154 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13155 }
13156 {
13157 PyThreadState* __tstate = wxPyBeginAllowThreads();
13158 (arg1)->SetPosition((wxPoint const &)*arg2);
13159
13160 wxPyEndAllowThreads(__tstate);
13161 if (PyErr_Occurred()) SWIG_fail;
13162 }
13163 Py_INCREF(Py_None); resultobj = Py_None;
13164 return resultobj;
13165 fail:
13166 return NULL;
13167 }
13168
13169
13170 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13171 PyObject *resultobj;
13172 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13173 int arg2 ;
13174 PyObject * obj0 = 0 ;
13175 PyObject * obj1 = 0 ;
13176 char *kwnames[] = {
13177 (char *) "self",(char *) "zPos", NULL
13178 };
13179
13180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13182 if (SWIG_arg_fail(1)) SWIG_fail;
13183 {
13184 arg2 = (int)(SWIG_As_int(obj1));
13185 if (SWIG_arg_fail(2)) SWIG_fail;
13186 }
13187 {
13188 PyThreadState* __tstate = wxPyBeginAllowThreads();
13189 (arg1)->SetZPosition(arg2);
13190
13191 wxPyEndAllowThreads(__tstate);
13192 if (PyErr_Occurred()) SWIG_fail;
13193 }
13194 Py_INCREF(Py_None); resultobj = Py_None;
13195 return resultobj;
13196 fail:
13197 return NULL;
13198 }
13199
13200
13201 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13202 PyObject *resultobj;
13203 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13204 bool result;
13205 PyObject * obj0 = 0 ;
13206 char *kwnames[] = {
13207 (char *) "self", NULL
13208 };
13209
13210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13212 if (SWIG_arg_fail(1)) SWIG_fail;
13213 {
13214 PyThreadState* __tstate = wxPyBeginAllowThreads();
13215 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13216
13217 wxPyEndAllowThreads(__tstate);
13218 if (PyErr_Occurred()) SWIG_fail;
13219 }
13220 {
13221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13222 }
13223 return resultobj;
13224 fail:
13225 return NULL;
13226 }
13227
13228
13229 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13230 PyObject *resultobj;
13231 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13232 bool result;
13233 PyObject * obj0 = 0 ;
13234 char *kwnames[] = {
13235 (char *) "self", NULL
13236 };
13237
13238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13240 if (SWIG_arg_fail(1)) SWIG_fail;
13241 {
13242 PyThreadState* __tstate = wxPyBeginAllowThreads();
13243 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13244
13245 wxPyEndAllowThreads(__tstate);
13246 if (PyErr_Occurred()) SWIG_fail;
13247 }
13248 {
13249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13250 }
13251 return resultobj;
13252 fail:
13253 return NULL;
13254 }
13255
13256
13257 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13258 PyObject *resultobj;
13259 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13260 bool result;
13261 PyObject * obj0 = 0 ;
13262 char *kwnames[] = {
13263 (char *) "self", NULL
13264 };
13265
13266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13268 if (SWIG_arg_fail(1)) SWIG_fail;
13269 {
13270 PyThreadState* __tstate = wxPyBeginAllowThreads();
13271 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13272
13273 wxPyEndAllowThreads(__tstate);
13274 if (PyErr_Occurred()) SWIG_fail;
13275 }
13276 {
13277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13278 }
13279 return resultobj;
13280 fail:
13281 return NULL;
13282 }
13283
13284
13285 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13286 PyObject *resultobj;
13287 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13288 int arg2 = (int) wxJOY_BUTTON_ANY ;
13289 bool result;
13290 PyObject * obj0 = 0 ;
13291 PyObject * obj1 = 0 ;
13292 char *kwnames[] = {
13293 (char *) "self",(char *) "but", NULL
13294 };
13295
13296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13298 if (SWIG_arg_fail(1)) SWIG_fail;
13299 if (obj1) {
13300 {
13301 arg2 = (int)(SWIG_As_int(obj1));
13302 if (SWIG_arg_fail(2)) SWIG_fail;
13303 }
13304 }
13305 {
13306 PyThreadState* __tstate = wxPyBeginAllowThreads();
13307 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13308
13309 wxPyEndAllowThreads(__tstate);
13310 if (PyErr_Occurred()) SWIG_fail;
13311 }
13312 {
13313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13314 }
13315 return resultobj;
13316 fail:
13317 return NULL;
13318 }
13319
13320
13321 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13322 PyObject *resultobj;
13323 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13324 int arg2 = (int) wxJOY_BUTTON_ANY ;
13325 bool result;
13326 PyObject * obj0 = 0 ;
13327 PyObject * obj1 = 0 ;
13328 char *kwnames[] = {
13329 (char *) "self",(char *) "but", NULL
13330 };
13331
13332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13334 if (SWIG_arg_fail(1)) SWIG_fail;
13335 if (obj1) {
13336 {
13337 arg2 = (int)(SWIG_As_int(obj1));
13338 if (SWIG_arg_fail(2)) SWIG_fail;
13339 }
13340 }
13341 {
13342 PyThreadState* __tstate = wxPyBeginAllowThreads();
13343 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13344
13345 wxPyEndAllowThreads(__tstate);
13346 if (PyErr_Occurred()) SWIG_fail;
13347 }
13348 {
13349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13350 }
13351 return resultobj;
13352 fail:
13353 return NULL;
13354 }
13355
13356
13357 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13358 PyObject *resultobj;
13359 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13360 int arg2 = (int) wxJOY_BUTTON_ANY ;
13361 bool result;
13362 PyObject * obj0 = 0 ;
13363 PyObject * obj1 = 0 ;
13364 char *kwnames[] = {
13365 (char *) "self",(char *) "but", NULL
13366 };
13367
13368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13370 if (SWIG_arg_fail(1)) SWIG_fail;
13371 if (obj1) {
13372 {
13373 arg2 = (int)(SWIG_As_int(obj1));
13374 if (SWIG_arg_fail(2)) SWIG_fail;
13375 }
13376 }
13377 {
13378 PyThreadState* __tstate = wxPyBeginAllowThreads();
13379 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13380
13381 wxPyEndAllowThreads(__tstate);
13382 if (PyErr_Occurred()) SWIG_fail;
13383 }
13384 {
13385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13386 }
13387 return resultobj;
13388 fail:
13389 return NULL;
13390 }
13391
13392
13393 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13394 PyObject *obj;
13395 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13396 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13397 Py_INCREF(obj);
13398 return Py_BuildValue((char *)"");
13399 }
13400 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13401 PyObject *resultobj;
13402 wxString const &arg1_defvalue = wxPyEmptyString ;
13403 wxString *arg1 = (wxString *) &arg1_defvalue ;
13404 wxSound *result;
13405 bool temp1 = false ;
13406 PyObject * obj0 = 0 ;
13407 char *kwnames[] = {
13408 (char *) "fileName", NULL
13409 };
13410
13411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13412 if (obj0) {
13413 {
13414 arg1 = wxString_in_helper(obj0);
13415 if (arg1 == NULL) SWIG_fail;
13416 temp1 = true;
13417 }
13418 }
13419 {
13420 if (!wxPyCheckForApp()) SWIG_fail;
13421 PyThreadState* __tstate = wxPyBeginAllowThreads();
13422 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13423
13424 wxPyEndAllowThreads(__tstate);
13425 if (PyErr_Occurred()) SWIG_fail;
13426 }
13427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13428 {
13429 if (temp1)
13430 delete arg1;
13431 }
13432 return resultobj;
13433 fail:
13434 {
13435 if (temp1)
13436 delete arg1;
13437 }
13438 return NULL;
13439 }
13440
13441
13442 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13443 PyObject *resultobj;
13444 PyObject *arg1 = (PyObject *) 0 ;
13445 wxSound *result;
13446 PyObject * obj0 = 0 ;
13447 char *kwnames[] = {
13448 (char *) "data", NULL
13449 };
13450
13451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13452 arg1 = obj0;
13453 {
13454 if (!wxPyCheckForApp()) SWIG_fail;
13455 PyThreadState* __tstate = wxPyBeginAllowThreads();
13456 result = (wxSound *)new_wxSound(arg1);
13457
13458 wxPyEndAllowThreads(__tstate);
13459 if (PyErr_Occurred()) SWIG_fail;
13460 }
13461 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13462 return resultobj;
13463 fail:
13464 return NULL;
13465 }
13466
13467
13468 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13469 PyObject *resultobj;
13470 wxSound *arg1 = (wxSound *) 0 ;
13471 PyObject * obj0 = 0 ;
13472 char *kwnames[] = {
13473 (char *) "self", NULL
13474 };
13475
13476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13478 if (SWIG_arg_fail(1)) SWIG_fail;
13479 {
13480 PyThreadState* __tstate = wxPyBeginAllowThreads();
13481 delete arg1;
13482
13483 wxPyEndAllowThreads(__tstate);
13484 if (PyErr_Occurred()) SWIG_fail;
13485 }
13486 Py_INCREF(Py_None); resultobj = Py_None;
13487 return resultobj;
13488 fail:
13489 return NULL;
13490 }
13491
13492
13493 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13494 PyObject *resultobj;
13495 wxSound *arg1 = (wxSound *) 0 ;
13496 wxString *arg2 = 0 ;
13497 bool result;
13498 bool temp2 = false ;
13499 PyObject * obj0 = 0 ;
13500 PyObject * obj1 = 0 ;
13501 char *kwnames[] = {
13502 (char *) "self",(char *) "fileName", NULL
13503 };
13504
13505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13507 if (SWIG_arg_fail(1)) SWIG_fail;
13508 {
13509 arg2 = wxString_in_helper(obj1);
13510 if (arg2 == NULL) SWIG_fail;
13511 temp2 = true;
13512 }
13513 {
13514 PyThreadState* __tstate = wxPyBeginAllowThreads();
13515 result = (bool)(arg1)->Create((wxString const &)*arg2);
13516
13517 wxPyEndAllowThreads(__tstate);
13518 if (PyErr_Occurred()) SWIG_fail;
13519 }
13520 {
13521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13522 }
13523 {
13524 if (temp2)
13525 delete arg2;
13526 }
13527 return resultobj;
13528 fail:
13529 {
13530 if (temp2)
13531 delete arg2;
13532 }
13533 return NULL;
13534 }
13535
13536
13537 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13538 PyObject *resultobj;
13539 wxSound *arg1 = (wxSound *) 0 ;
13540 PyObject *arg2 = (PyObject *) 0 ;
13541 bool result;
13542 PyObject * obj0 = 0 ;
13543 PyObject * obj1 = 0 ;
13544 char *kwnames[] = {
13545 (char *) "self",(char *) "data", NULL
13546 };
13547
13548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13550 if (SWIG_arg_fail(1)) SWIG_fail;
13551 arg2 = obj1;
13552 {
13553 PyThreadState* __tstate = wxPyBeginAllowThreads();
13554 result = (bool)wxSound_CreateFromData(arg1,arg2);
13555
13556 wxPyEndAllowThreads(__tstate);
13557 if (PyErr_Occurred()) SWIG_fail;
13558 }
13559 {
13560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13561 }
13562 return resultobj;
13563 fail:
13564 return NULL;
13565 }
13566
13567
13568 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13569 PyObject *resultobj;
13570 wxSound *arg1 = (wxSound *) 0 ;
13571 bool result;
13572 PyObject * obj0 = 0 ;
13573 char *kwnames[] = {
13574 (char *) "self", NULL
13575 };
13576
13577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13579 if (SWIG_arg_fail(1)) SWIG_fail;
13580 {
13581 PyThreadState* __tstate = wxPyBeginAllowThreads();
13582 result = (bool)(arg1)->IsOk();
13583
13584 wxPyEndAllowThreads(__tstate);
13585 if (PyErr_Occurred()) SWIG_fail;
13586 }
13587 {
13588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13589 }
13590 return resultobj;
13591 fail:
13592 return NULL;
13593 }
13594
13595
13596 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13597 PyObject *resultobj;
13598 wxSound *arg1 = (wxSound *) 0 ;
13599 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13600 bool result;
13601 PyObject * obj0 = 0 ;
13602 PyObject * obj1 = 0 ;
13603 char *kwnames[] = {
13604 (char *) "self",(char *) "flags", NULL
13605 };
13606
13607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13609 if (SWIG_arg_fail(1)) SWIG_fail;
13610 if (obj1) {
13611 {
13612 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13613 if (SWIG_arg_fail(2)) SWIG_fail;
13614 }
13615 }
13616 {
13617 if (!wxPyCheckForApp()) SWIG_fail;
13618 PyThreadState* __tstate = wxPyBeginAllowThreads();
13619 result = (bool)((wxSound const *)arg1)->Play(arg2);
13620
13621 wxPyEndAllowThreads(__tstate);
13622 if (PyErr_Occurred()) SWIG_fail;
13623 }
13624 {
13625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13626 }
13627 return resultobj;
13628 fail:
13629 return NULL;
13630 }
13631
13632
13633 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13634 PyObject *resultobj;
13635 wxString *arg1 = 0 ;
13636 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13637 bool result;
13638 bool temp1 = false ;
13639 PyObject * obj0 = 0 ;
13640 PyObject * obj1 = 0 ;
13641 char *kwnames[] = {
13642 (char *) "filename",(char *) "flags", NULL
13643 };
13644
13645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13646 {
13647 arg1 = wxString_in_helper(obj0);
13648 if (arg1 == NULL) SWIG_fail;
13649 temp1 = true;
13650 }
13651 if (obj1) {
13652 {
13653 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13654 if (SWIG_arg_fail(2)) SWIG_fail;
13655 }
13656 }
13657 {
13658 if (!wxPyCheckForApp()) SWIG_fail;
13659 PyThreadState* __tstate = wxPyBeginAllowThreads();
13660 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13661
13662 wxPyEndAllowThreads(__tstate);
13663 if (PyErr_Occurred()) SWIG_fail;
13664 }
13665 {
13666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13667 }
13668 {
13669 if (temp1)
13670 delete arg1;
13671 }
13672 return resultobj;
13673 fail:
13674 {
13675 if (temp1)
13676 delete arg1;
13677 }
13678 return NULL;
13679 }
13680
13681
13682 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13683 PyObject *resultobj;
13684 char *kwnames[] = {
13685 NULL
13686 };
13687
13688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13689 {
13690 if (!wxPyCheckForApp()) SWIG_fail;
13691 PyThreadState* __tstate = wxPyBeginAllowThreads();
13692 wxSound::Stop();
13693
13694 wxPyEndAllowThreads(__tstate);
13695 if (PyErr_Occurred()) SWIG_fail;
13696 }
13697 Py_INCREF(Py_None); resultobj = Py_None;
13698 return resultobj;
13699 fail:
13700 return NULL;
13701 }
13702
13703
13704 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13705 PyObject *obj;
13706 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13707 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13708 Py_INCREF(obj);
13709 return Py_BuildValue((char *)"");
13710 }
13711 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13712 PyObject *resultobj;
13713 wxString *arg1 = 0 ;
13714 wxString *arg2 = 0 ;
13715 wxString *arg3 = 0 ;
13716 wxString *arg4 = 0 ;
13717 wxFileTypeInfo *result;
13718 bool temp1 = false ;
13719 bool temp2 = false ;
13720 bool temp3 = false ;
13721 bool temp4 = false ;
13722 PyObject * obj0 = 0 ;
13723 PyObject * obj1 = 0 ;
13724 PyObject * obj2 = 0 ;
13725 PyObject * obj3 = 0 ;
13726 char *kwnames[] = {
13727 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13728 };
13729
13730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13731 {
13732 arg1 = wxString_in_helper(obj0);
13733 if (arg1 == NULL) SWIG_fail;
13734 temp1 = true;
13735 }
13736 {
13737 arg2 = wxString_in_helper(obj1);
13738 if (arg2 == NULL) SWIG_fail;
13739 temp2 = true;
13740 }
13741 {
13742 arg3 = wxString_in_helper(obj2);
13743 if (arg3 == NULL) SWIG_fail;
13744 temp3 = true;
13745 }
13746 {
13747 arg4 = wxString_in_helper(obj3);
13748 if (arg4 == NULL) SWIG_fail;
13749 temp4 = true;
13750 }
13751 {
13752 PyThreadState* __tstate = wxPyBeginAllowThreads();
13753 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13754
13755 wxPyEndAllowThreads(__tstate);
13756 if (PyErr_Occurred()) SWIG_fail;
13757 }
13758 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13759 {
13760 if (temp1)
13761 delete arg1;
13762 }
13763 {
13764 if (temp2)
13765 delete arg2;
13766 }
13767 {
13768 if (temp3)
13769 delete arg3;
13770 }
13771 {
13772 if (temp4)
13773 delete arg4;
13774 }
13775 return resultobj;
13776 fail:
13777 {
13778 if (temp1)
13779 delete arg1;
13780 }
13781 {
13782 if (temp2)
13783 delete arg2;
13784 }
13785 {
13786 if (temp3)
13787 delete arg3;
13788 }
13789 {
13790 if (temp4)
13791 delete arg4;
13792 }
13793 return NULL;
13794 }
13795
13796
13797 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13798 PyObject *resultobj;
13799 wxArrayString *arg1 = 0 ;
13800 wxFileTypeInfo *result;
13801 bool temp1 = false ;
13802 PyObject * obj0 = 0 ;
13803 char *kwnames[] = {
13804 (char *) "sArray", NULL
13805 };
13806
13807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13808 {
13809 if (! PySequence_Check(obj0)) {
13810 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13811 SWIG_fail;
13812 }
13813 arg1 = new wxArrayString;
13814 temp1 = true;
13815 int i, len=PySequence_Length(obj0);
13816 for (i=0; i<len; i++) {
13817 PyObject* item = PySequence_GetItem(obj0, i);
13818 #if wxUSE_UNICODE
13819 PyObject* str = PyObject_Unicode(item);
13820 #else
13821 PyObject* str = PyObject_Str(item);
13822 #endif
13823 if (PyErr_Occurred()) SWIG_fail;
13824 arg1->Add(Py2wxString(str));
13825 Py_DECREF(item);
13826 Py_DECREF(str);
13827 }
13828 }
13829 {
13830 PyThreadState* __tstate = wxPyBeginAllowThreads();
13831 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13832
13833 wxPyEndAllowThreads(__tstate);
13834 if (PyErr_Occurred()) SWIG_fail;
13835 }
13836 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13837 {
13838 if (temp1) delete arg1;
13839 }
13840 return resultobj;
13841 fail:
13842 {
13843 if (temp1) delete arg1;
13844 }
13845 return NULL;
13846 }
13847
13848
13849 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13850 PyObject *resultobj;
13851 wxFileTypeInfo *result;
13852 char *kwnames[] = {
13853 NULL
13854 };
13855
13856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13857 {
13858 PyThreadState* __tstate = wxPyBeginAllowThreads();
13859 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13860
13861 wxPyEndAllowThreads(__tstate);
13862 if (PyErr_Occurred()) SWIG_fail;
13863 }
13864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13865 return resultobj;
13866 fail:
13867 return NULL;
13868 }
13869
13870
13871 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13872 PyObject *resultobj;
13873 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13874 bool result;
13875 PyObject * obj0 = 0 ;
13876 char *kwnames[] = {
13877 (char *) "self", NULL
13878 };
13879
13880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13882 if (SWIG_arg_fail(1)) SWIG_fail;
13883 {
13884 PyThreadState* __tstate = wxPyBeginAllowThreads();
13885 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13886
13887 wxPyEndAllowThreads(__tstate);
13888 if (PyErr_Occurred()) SWIG_fail;
13889 }
13890 {
13891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13892 }
13893 return resultobj;
13894 fail:
13895 return NULL;
13896 }
13897
13898
13899 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13900 PyObject *resultobj;
13901 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13902 wxString *arg2 = 0 ;
13903 int arg3 = (int) 0 ;
13904 bool temp2 = false ;
13905 PyObject * obj0 = 0 ;
13906 PyObject * obj1 = 0 ;
13907 PyObject * obj2 = 0 ;
13908 char *kwnames[] = {
13909 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13910 };
13911
13912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13914 if (SWIG_arg_fail(1)) SWIG_fail;
13915 {
13916 arg2 = wxString_in_helper(obj1);
13917 if (arg2 == NULL) SWIG_fail;
13918 temp2 = true;
13919 }
13920 if (obj2) {
13921 {
13922 arg3 = (int)(SWIG_As_int(obj2));
13923 if (SWIG_arg_fail(3)) SWIG_fail;
13924 }
13925 }
13926 {
13927 PyThreadState* __tstate = wxPyBeginAllowThreads();
13928 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13929
13930 wxPyEndAllowThreads(__tstate);
13931 if (PyErr_Occurred()) SWIG_fail;
13932 }
13933 Py_INCREF(Py_None); resultobj = Py_None;
13934 {
13935 if (temp2)
13936 delete arg2;
13937 }
13938 return resultobj;
13939 fail:
13940 {
13941 if (temp2)
13942 delete arg2;
13943 }
13944 return NULL;
13945 }
13946
13947
13948 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13949 PyObject *resultobj;
13950 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13951 wxString *arg2 = 0 ;
13952 bool temp2 = false ;
13953 PyObject * obj0 = 0 ;
13954 PyObject * obj1 = 0 ;
13955 char *kwnames[] = {
13956 (char *) "self",(char *) "shortDesc", NULL
13957 };
13958
13959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13961 if (SWIG_arg_fail(1)) SWIG_fail;
13962 {
13963 arg2 = wxString_in_helper(obj1);
13964 if (arg2 == NULL) SWIG_fail;
13965 temp2 = true;
13966 }
13967 {
13968 PyThreadState* __tstate = wxPyBeginAllowThreads();
13969 (arg1)->SetShortDesc((wxString const &)*arg2);
13970
13971 wxPyEndAllowThreads(__tstate);
13972 if (PyErr_Occurred()) SWIG_fail;
13973 }
13974 Py_INCREF(Py_None); resultobj = Py_None;
13975 {
13976 if (temp2)
13977 delete arg2;
13978 }
13979 return resultobj;
13980 fail:
13981 {
13982 if (temp2)
13983 delete arg2;
13984 }
13985 return NULL;
13986 }
13987
13988
13989 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13990 PyObject *resultobj;
13991 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13992 wxString *result;
13993 PyObject * obj0 = 0 ;
13994 char *kwnames[] = {
13995 (char *) "self", NULL
13996 };
13997
13998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14000 if (SWIG_arg_fail(1)) SWIG_fail;
14001 {
14002 PyThreadState* __tstate = wxPyBeginAllowThreads();
14003 {
14004 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14005 result = (wxString *) &_result_ref;
14006 }
14007
14008 wxPyEndAllowThreads(__tstate);
14009 if (PyErr_Occurred()) SWIG_fail;
14010 }
14011 {
14012 #if wxUSE_UNICODE
14013 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14014 #else
14015 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14016 #endif
14017 }
14018 return resultobj;
14019 fail:
14020 return NULL;
14021 }
14022
14023
14024 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14025 PyObject *resultobj;
14026 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14027 wxString *result;
14028 PyObject * obj0 = 0 ;
14029 char *kwnames[] = {
14030 (char *) "self", NULL
14031 };
14032
14033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14035 if (SWIG_arg_fail(1)) SWIG_fail;
14036 {
14037 PyThreadState* __tstate = wxPyBeginAllowThreads();
14038 {
14039 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14040 result = (wxString *) &_result_ref;
14041 }
14042
14043 wxPyEndAllowThreads(__tstate);
14044 if (PyErr_Occurred()) SWIG_fail;
14045 }
14046 {
14047 #if wxUSE_UNICODE
14048 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14049 #else
14050 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14051 #endif
14052 }
14053 return resultobj;
14054 fail:
14055 return NULL;
14056 }
14057
14058
14059 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14060 PyObject *resultobj;
14061 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14062 wxString *result;
14063 PyObject * obj0 = 0 ;
14064 char *kwnames[] = {
14065 (char *) "self", NULL
14066 };
14067
14068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14070 if (SWIG_arg_fail(1)) SWIG_fail;
14071 {
14072 PyThreadState* __tstate = wxPyBeginAllowThreads();
14073 {
14074 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14075 result = (wxString *) &_result_ref;
14076 }
14077
14078 wxPyEndAllowThreads(__tstate);
14079 if (PyErr_Occurred()) SWIG_fail;
14080 }
14081 {
14082 #if wxUSE_UNICODE
14083 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14084 #else
14085 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14086 #endif
14087 }
14088 return resultobj;
14089 fail:
14090 return NULL;
14091 }
14092
14093
14094 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14095 PyObject *resultobj;
14096 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14097 wxString *result;
14098 PyObject * obj0 = 0 ;
14099 char *kwnames[] = {
14100 (char *) "self", NULL
14101 };
14102
14103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14105 if (SWIG_arg_fail(1)) SWIG_fail;
14106 {
14107 PyThreadState* __tstate = wxPyBeginAllowThreads();
14108 {
14109 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14110 result = (wxString *) &_result_ref;
14111 }
14112
14113 wxPyEndAllowThreads(__tstate);
14114 if (PyErr_Occurred()) SWIG_fail;
14115 }
14116 {
14117 #if wxUSE_UNICODE
14118 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14119 #else
14120 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14121 #endif
14122 }
14123 return resultobj;
14124 fail:
14125 return NULL;
14126 }
14127
14128
14129 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14130 PyObject *resultobj;
14131 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14132 wxString *result;
14133 PyObject * obj0 = 0 ;
14134 char *kwnames[] = {
14135 (char *) "self", NULL
14136 };
14137
14138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14140 if (SWIG_arg_fail(1)) SWIG_fail;
14141 {
14142 PyThreadState* __tstate = wxPyBeginAllowThreads();
14143 {
14144 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14145 result = (wxString *) &_result_ref;
14146 }
14147
14148 wxPyEndAllowThreads(__tstate);
14149 if (PyErr_Occurred()) SWIG_fail;
14150 }
14151 {
14152 #if wxUSE_UNICODE
14153 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14154 #else
14155 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14156 #endif
14157 }
14158 return resultobj;
14159 fail:
14160 return NULL;
14161 }
14162
14163
14164 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14165 PyObject *resultobj;
14166 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14167 wxArrayString *result;
14168 PyObject * obj0 = 0 ;
14169 char *kwnames[] = {
14170 (char *) "self", NULL
14171 };
14172
14173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14175 if (SWIG_arg_fail(1)) SWIG_fail;
14176 {
14177 PyThreadState* __tstate = wxPyBeginAllowThreads();
14178 {
14179 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14180 result = (wxArrayString *) &_result_ref;
14181 }
14182
14183 wxPyEndAllowThreads(__tstate);
14184 if (PyErr_Occurred()) SWIG_fail;
14185 }
14186 {
14187 resultobj = wxArrayString2PyList_helper(*result);
14188 }
14189 return resultobj;
14190 fail:
14191 return NULL;
14192 }
14193
14194
14195 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14196 PyObject *resultobj;
14197 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14198 int result;
14199 PyObject * obj0 = 0 ;
14200 char *kwnames[] = {
14201 (char *) "self", NULL
14202 };
14203
14204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14206 if (SWIG_arg_fail(1)) SWIG_fail;
14207 {
14208 PyThreadState* __tstate = wxPyBeginAllowThreads();
14209 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14210
14211 wxPyEndAllowThreads(__tstate);
14212 if (PyErr_Occurred()) SWIG_fail;
14213 }
14214 {
14215 resultobj = SWIG_From_int((int)(result));
14216 }
14217 return resultobj;
14218 fail:
14219 return NULL;
14220 }
14221
14222
14223 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14224 PyObject *resultobj;
14225 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14226 wxString *result;
14227 PyObject * obj0 = 0 ;
14228 char *kwnames[] = {
14229 (char *) "self", NULL
14230 };
14231
14232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14234 if (SWIG_arg_fail(1)) SWIG_fail;
14235 {
14236 PyThreadState* __tstate = wxPyBeginAllowThreads();
14237 {
14238 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14239 result = (wxString *) &_result_ref;
14240 }
14241
14242 wxPyEndAllowThreads(__tstate);
14243 if (PyErr_Occurred()) SWIG_fail;
14244 }
14245 {
14246 #if wxUSE_UNICODE
14247 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14248 #else
14249 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14250 #endif
14251 }
14252 return resultobj;
14253 fail:
14254 return NULL;
14255 }
14256
14257
14258 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14259 PyObject *resultobj;
14260 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14261 int result;
14262 PyObject * obj0 = 0 ;
14263 char *kwnames[] = {
14264 (char *) "self", NULL
14265 };
14266
14267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14269 if (SWIG_arg_fail(1)) SWIG_fail;
14270 {
14271 PyThreadState* __tstate = wxPyBeginAllowThreads();
14272 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14273
14274 wxPyEndAllowThreads(__tstate);
14275 if (PyErr_Occurred()) SWIG_fail;
14276 }
14277 {
14278 resultobj = SWIG_From_int((int)(result));
14279 }
14280 return resultobj;
14281 fail:
14282 return NULL;
14283 }
14284
14285
14286 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14287 PyObject *obj;
14288 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14289 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14290 Py_INCREF(obj);
14291 return Py_BuildValue((char *)"");
14292 }
14293 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14294 PyObject *resultobj;
14295 wxFileTypeInfo *arg1 = 0 ;
14296 wxFileType *result;
14297 PyObject * obj0 = 0 ;
14298 char *kwnames[] = {
14299 (char *) "ftInfo", NULL
14300 };
14301
14302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14303 {
14304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14305 if (SWIG_arg_fail(1)) SWIG_fail;
14306 if (arg1 == NULL) {
14307 SWIG_null_ref("wxFileTypeInfo");
14308 }
14309 if (SWIG_arg_fail(1)) SWIG_fail;
14310 }
14311 {
14312 PyThreadState* __tstate = wxPyBeginAllowThreads();
14313 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14314
14315 wxPyEndAllowThreads(__tstate);
14316 if (PyErr_Occurred()) SWIG_fail;
14317 }
14318 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14319 return resultobj;
14320 fail:
14321 return NULL;
14322 }
14323
14324
14325 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14326 PyObject *resultobj;
14327 wxFileType *arg1 = (wxFileType *) 0 ;
14328 PyObject * obj0 = 0 ;
14329 char *kwnames[] = {
14330 (char *) "self", NULL
14331 };
14332
14333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14335 if (SWIG_arg_fail(1)) SWIG_fail;
14336 {
14337 PyThreadState* __tstate = wxPyBeginAllowThreads();
14338 delete arg1;
14339
14340 wxPyEndAllowThreads(__tstate);
14341 if (PyErr_Occurred()) SWIG_fail;
14342 }
14343 Py_INCREF(Py_None); resultobj = Py_None;
14344 return resultobj;
14345 fail:
14346 return NULL;
14347 }
14348
14349
14350 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14351 PyObject *resultobj;
14352 wxFileType *arg1 = (wxFileType *) 0 ;
14353 PyObject *result;
14354 PyObject * obj0 = 0 ;
14355 char *kwnames[] = {
14356 (char *) "self", NULL
14357 };
14358
14359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14361 if (SWIG_arg_fail(1)) SWIG_fail;
14362 {
14363 PyThreadState* __tstate = wxPyBeginAllowThreads();
14364 result = (PyObject *)wxFileType_GetMimeType(arg1);
14365
14366 wxPyEndAllowThreads(__tstate);
14367 if (PyErr_Occurred()) SWIG_fail;
14368 }
14369 resultobj = result;
14370 return resultobj;
14371 fail:
14372 return NULL;
14373 }
14374
14375
14376 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14377 PyObject *resultobj;
14378 wxFileType *arg1 = (wxFileType *) 0 ;
14379 PyObject *result;
14380 PyObject * obj0 = 0 ;
14381 char *kwnames[] = {
14382 (char *) "self", NULL
14383 };
14384
14385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14387 if (SWIG_arg_fail(1)) SWIG_fail;
14388 {
14389 PyThreadState* __tstate = wxPyBeginAllowThreads();
14390 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14391
14392 wxPyEndAllowThreads(__tstate);
14393 if (PyErr_Occurred()) SWIG_fail;
14394 }
14395 resultobj = result;
14396 return resultobj;
14397 fail:
14398 return NULL;
14399 }
14400
14401
14402 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14403 PyObject *resultobj;
14404 wxFileType *arg1 = (wxFileType *) 0 ;
14405 PyObject *result;
14406 PyObject * obj0 = 0 ;
14407 char *kwnames[] = {
14408 (char *) "self", NULL
14409 };
14410
14411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14413 if (SWIG_arg_fail(1)) SWIG_fail;
14414 {
14415 PyThreadState* __tstate = wxPyBeginAllowThreads();
14416 result = (PyObject *)wxFileType_GetExtensions(arg1);
14417
14418 wxPyEndAllowThreads(__tstate);
14419 if (PyErr_Occurred()) SWIG_fail;
14420 }
14421 resultobj = result;
14422 return resultobj;
14423 fail:
14424 return NULL;
14425 }
14426
14427
14428 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14429 PyObject *resultobj;
14430 wxFileType *arg1 = (wxFileType *) 0 ;
14431 wxIcon *result;
14432 PyObject * obj0 = 0 ;
14433 char *kwnames[] = {
14434 (char *) "self", NULL
14435 };
14436
14437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14439 if (SWIG_arg_fail(1)) SWIG_fail;
14440 {
14441 PyThreadState* __tstate = wxPyBeginAllowThreads();
14442 result = (wxIcon *)wxFileType_GetIcon(arg1);
14443
14444 wxPyEndAllowThreads(__tstate);
14445 if (PyErr_Occurred()) SWIG_fail;
14446 }
14447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14448 return resultobj;
14449 fail:
14450 return NULL;
14451 }
14452
14453
14454 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14455 PyObject *resultobj;
14456 wxFileType *arg1 = (wxFileType *) 0 ;
14457 PyObject *result;
14458 PyObject * obj0 = 0 ;
14459 char *kwnames[] = {
14460 (char *) "self", NULL
14461 };
14462
14463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14465 if (SWIG_arg_fail(1)) SWIG_fail;
14466 {
14467 PyThreadState* __tstate = wxPyBeginAllowThreads();
14468 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14469
14470 wxPyEndAllowThreads(__tstate);
14471 if (PyErr_Occurred()) SWIG_fail;
14472 }
14473 resultobj = result;
14474 return resultobj;
14475 fail:
14476 return NULL;
14477 }
14478
14479
14480 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14481 PyObject *resultobj;
14482 wxFileType *arg1 = (wxFileType *) 0 ;
14483 PyObject *result;
14484 PyObject * obj0 = 0 ;
14485 char *kwnames[] = {
14486 (char *) "self", NULL
14487 };
14488
14489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14491 if (SWIG_arg_fail(1)) SWIG_fail;
14492 {
14493 PyThreadState* __tstate = wxPyBeginAllowThreads();
14494 result = (PyObject *)wxFileType_GetDescription(arg1);
14495
14496 wxPyEndAllowThreads(__tstate);
14497 if (PyErr_Occurred()) SWIG_fail;
14498 }
14499 resultobj = result;
14500 return resultobj;
14501 fail:
14502 return NULL;
14503 }
14504
14505
14506 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14507 PyObject *resultobj;
14508 wxFileType *arg1 = (wxFileType *) 0 ;
14509 wxString *arg2 = 0 ;
14510 wxString const &arg3_defvalue = wxPyEmptyString ;
14511 wxString *arg3 = (wxString *) &arg3_defvalue ;
14512 PyObject *result;
14513 bool temp2 = false ;
14514 bool temp3 = false ;
14515 PyObject * obj0 = 0 ;
14516 PyObject * obj1 = 0 ;
14517 PyObject * obj2 = 0 ;
14518 char *kwnames[] = {
14519 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14520 };
14521
14522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14524 if (SWIG_arg_fail(1)) SWIG_fail;
14525 {
14526 arg2 = wxString_in_helper(obj1);
14527 if (arg2 == NULL) SWIG_fail;
14528 temp2 = true;
14529 }
14530 if (obj2) {
14531 {
14532 arg3 = wxString_in_helper(obj2);
14533 if (arg3 == NULL) SWIG_fail;
14534 temp3 = true;
14535 }
14536 }
14537 {
14538 PyThreadState* __tstate = wxPyBeginAllowThreads();
14539 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14540
14541 wxPyEndAllowThreads(__tstate);
14542 if (PyErr_Occurred()) SWIG_fail;
14543 }
14544 resultobj = result;
14545 {
14546 if (temp2)
14547 delete arg2;
14548 }
14549 {
14550 if (temp3)
14551 delete arg3;
14552 }
14553 return resultobj;
14554 fail:
14555 {
14556 if (temp2)
14557 delete arg2;
14558 }
14559 {
14560 if (temp3)
14561 delete arg3;
14562 }
14563 return NULL;
14564 }
14565
14566
14567 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14568 PyObject *resultobj;
14569 wxFileType *arg1 = (wxFileType *) 0 ;
14570 wxString *arg2 = 0 ;
14571 wxString const &arg3_defvalue = wxPyEmptyString ;
14572 wxString *arg3 = (wxString *) &arg3_defvalue ;
14573 PyObject *result;
14574 bool temp2 = false ;
14575 bool temp3 = false ;
14576 PyObject * obj0 = 0 ;
14577 PyObject * obj1 = 0 ;
14578 PyObject * obj2 = 0 ;
14579 char *kwnames[] = {
14580 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14581 };
14582
14583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14585 if (SWIG_arg_fail(1)) SWIG_fail;
14586 {
14587 arg2 = wxString_in_helper(obj1);
14588 if (arg2 == NULL) SWIG_fail;
14589 temp2 = true;
14590 }
14591 if (obj2) {
14592 {
14593 arg3 = wxString_in_helper(obj2);
14594 if (arg3 == NULL) SWIG_fail;
14595 temp3 = true;
14596 }
14597 }
14598 {
14599 PyThreadState* __tstate = wxPyBeginAllowThreads();
14600 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14601
14602 wxPyEndAllowThreads(__tstate);
14603 if (PyErr_Occurred()) SWIG_fail;
14604 }
14605 resultobj = result;
14606 {
14607 if (temp2)
14608 delete arg2;
14609 }
14610 {
14611 if (temp3)
14612 delete arg3;
14613 }
14614 return resultobj;
14615 fail:
14616 {
14617 if (temp2)
14618 delete arg2;
14619 }
14620 {
14621 if (temp3)
14622 delete arg3;
14623 }
14624 return NULL;
14625 }
14626
14627
14628 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14629 PyObject *resultobj;
14630 wxFileType *arg1 = (wxFileType *) 0 ;
14631 wxString *arg2 = 0 ;
14632 wxString const &arg3_defvalue = wxPyEmptyString ;
14633 wxString *arg3 = (wxString *) &arg3_defvalue ;
14634 PyObject *result;
14635 bool temp2 = false ;
14636 bool temp3 = false ;
14637 PyObject * obj0 = 0 ;
14638 PyObject * obj1 = 0 ;
14639 PyObject * obj2 = 0 ;
14640 char *kwnames[] = {
14641 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14642 };
14643
14644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14646 if (SWIG_arg_fail(1)) SWIG_fail;
14647 {
14648 arg2 = wxString_in_helper(obj1);
14649 if (arg2 == NULL) SWIG_fail;
14650 temp2 = true;
14651 }
14652 if (obj2) {
14653 {
14654 arg3 = wxString_in_helper(obj2);
14655 if (arg3 == NULL) SWIG_fail;
14656 temp3 = true;
14657 }
14658 }
14659 {
14660 PyThreadState* __tstate = wxPyBeginAllowThreads();
14661 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14662
14663 wxPyEndAllowThreads(__tstate);
14664 if (PyErr_Occurred()) SWIG_fail;
14665 }
14666 resultobj = result;
14667 {
14668 if (temp2)
14669 delete arg2;
14670 }
14671 {
14672 if (temp3)
14673 delete arg3;
14674 }
14675 return resultobj;
14676 fail:
14677 {
14678 if (temp2)
14679 delete arg2;
14680 }
14681 {
14682 if (temp3)
14683 delete arg3;
14684 }
14685 return NULL;
14686 }
14687
14688
14689 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14690 PyObject *resultobj;
14691 wxFileType *arg1 = (wxFileType *) 0 ;
14692 wxString *arg2 = 0 ;
14693 wxString *arg3 = 0 ;
14694 bool arg4 = (bool) true ;
14695 bool result;
14696 bool temp2 = false ;
14697 bool temp3 = false ;
14698 PyObject * obj0 = 0 ;
14699 PyObject * obj1 = 0 ;
14700 PyObject * obj2 = 0 ;
14701 PyObject * obj3 = 0 ;
14702 char *kwnames[] = {
14703 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14704 };
14705
14706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14708 if (SWIG_arg_fail(1)) SWIG_fail;
14709 {
14710 arg2 = wxString_in_helper(obj1);
14711 if (arg2 == NULL) SWIG_fail;
14712 temp2 = true;
14713 }
14714 {
14715 arg3 = wxString_in_helper(obj2);
14716 if (arg3 == NULL) SWIG_fail;
14717 temp3 = true;
14718 }
14719 if (obj3) {
14720 {
14721 arg4 = (bool)(SWIG_As_bool(obj3));
14722 if (SWIG_arg_fail(4)) SWIG_fail;
14723 }
14724 }
14725 {
14726 PyThreadState* __tstate = wxPyBeginAllowThreads();
14727 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14728
14729 wxPyEndAllowThreads(__tstate);
14730 if (PyErr_Occurred()) SWIG_fail;
14731 }
14732 {
14733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14734 }
14735 {
14736 if (temp2)
14737 delete arg2;
14738 }
14739 {
14740 if (temp3)
14741 delete arg3;
14742 }
14743 return resultobj;
14744 fail:
14745 {
14746 if (temp2)
14747 delete arg2;
14748 }
14749 {
14750 if (temp3)
14751 delete arg3;
14752 }
14753 return NULL;
14754 }
14755
14756
14757 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14758 PyObject *resultobj;
14759 wxFileType *arg1 = (wxFileType *) 0 ;
14760 wxString const &arg2_defvalue = wxPyEmptyString ;
14761 wxString *arg2 = (wxString *) &arg2_defvalue ;
14762 int arg3 = (int) 0 ;
14763 bool result;
14764 bool temp2 = false ;
14765 PyObject * obj0 = 0 ;
14766 PyObject * obj1 = 0 ;
14767 PyObject * obj2 = 0 ;
14768 char *kwnames[] = {
14769 (char *) "self",(char *) "cmd",(char *) "index", NULL
14770 };
14771
14772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14774 if (SWIG_arg_fail(1)) SWIG_fail;
14775 if (obj1) {
14776 {
14777 arg2 = wxString_in_helper(obj1);
14778 if (arg2 == NULL) SWIG_fail;
14779 temp2 = true;
14780 }
14781 }
14782 if (obj2) {
14783 {
14784 arg3 = (int)(SWIG_As_int(obj2));
14785 if (SWIG_arg_fail(3)) SWIG_fail;
14786 }
14787 }
14788 {
14789 PyThreadState* __tstate = wxPyBeginAllowThreads();
14790 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14791
14792 wxPyEndAllowThreads(__tstate);
14793 if (PyErr_Occurred()) SWIG_fail;
14794 }
14795 {
14796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14797 }
14798 {
14799 if (temp2)
14800 delete arg2;
14801 }
14802 return resultobj;
14803 fail:
14804 {
14805 if (temp2)
14806 delete arg2;
14807 }
14808 return NULL;
14809 }
14810
14811
14812 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14813 PyObject *resultobj;
14814 wxFileType *arg1 = (wxFileType *) 0 ;
14815 bool result;
14816 PyObject * obj0 = 0 ;
14817 char *kwnames[] = {
14818 (char *) "self", NULL
14819 };
14820
14821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14823 if (SWIG_arg_fail(1)) SWIG_fail;
14824 {
14825 PyThreadState* __tstate = wxPyBeginAllowThreads();
14826 result = (bool)(arg1)->Unassociate();
14827
14828 wxPyEndAllowThreads(__tstate);
14829 if (PyErr_Occurred()) SWIG_fail;
14830 }
14831 {
14832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14833 }
14834 return resultobj;
14835 fail:
14836 return NULL;
14837 }
14838
14839
14840 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14841 PyObject *resultobj;
14842 wxString *arg1 = 0 ;
14843 wxString *arg2 = 0 ;
14844 wxString const &arg3_defvalue = wxPyEmptyString ;
14845 wxString *arg3 = (wxString *) &arg3_defvalue ;
14846 wxString result;
14847 bool temp1 = false ;
14848 bool temp2 = false ;
14849 bool temp3 = false ;
14850 PyObject * obj0 = 0 ;
14851 PyObject * obj1 = 0 ;
14852 PyObject * obj2 = 0 ;
14853 char *kwnames[] = {
14854 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14855 };
14856
14857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14858 {
14859 arg1 = wxString_in_helper(obj0);
14860 if (arg1 == NULL) SWIG_fail;
14861 temp1 = true;
14862 }
14863 {
14864 arg2 = wxString_in_helper(obj1);
14865 if (arg2 == NULL) SWIG_fail;
14866 temp2 = true;
14867 }
14868 if (obj2) {
14869 {
14870 arg3 = wxString_in_helper(obj2);
14871 if (arg3 == NULL) SWIG_fail;
14872 temp3 = true;
14873 }
14874 }
14875 {
14876 PyThreadState* __tstate = wxPyBeginAllowThreads();
14877 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14878
14879 wxPyEndAllowThreads(__tstate);
14880 if (PyErr_Occurred()) SWIG_fail;
14881 }
14882 {
14883 #if wxUSE_UNICODE
14884 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14885 #else
14886 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14887 #endif
14888 }
14889 {
14890 if (temp1)
14891 delete arg1;
14892 }
14893 {
14894 if (temp2)
14895 delete arg2;
14896 }
14897 {
14898 if (temp3)
14899 delete arg3;
14900 }
14901 return resultobj;
14902 fail:
14903 {
14904 if (temp1)
14905 delete arg1;
14906 }
14907 {
14908 if (temp2)
14909 delete arg2;
14910 }
14911 {
14912 if (temp3)
14913 delete arg3;
14914 }
14915 return NULL;
14916 }
14917
14918
14919 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14920 PyObject *obj;
14921 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14922 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14923 Py_INCREF(obj);
14924 return Py_BuildValue((char *)"");
14925 }
14926 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14927 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14928 return 1;
14929 }
14930
14931
14932 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14933 PyObject *pyobj;
14934
14935 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14936 return pyobj;
14937 }
14938
14939
14940 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14941 PyObject *resultobj;
14942 wxString *arg1 = 0 ;
14943 wxString *arg2 = 0 ;
14944 bool result;
14945 bool temp1 = false ;
14946 bool temp2 = false ;
14947 PyObject * obj0 = 0 ;
14948 PyObject * obj1 = 0 ;
14949 char *kwnames[] = {
14950 (char *) "mimeType",(char *) "wildcard", NULL
14951 };
14952
14953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14954 {
14955 arg1 = wxString_in_helper(obj0);
14956 if (arg1 == NULL) SWIG_fail;
14957 temp1 = true;
14958 }
14959 {
14960 arg2 = wxString_in_helper(obj1);
14961 if (arg2 == NULL) SWIG_fail;
14962 temp2 = true;
14963 }
14964 {
14965 PyThreadState* __tstate = wxPyBeginAllowThreads();
14966 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14967
14968 wxPyEndAllowThreads(__tstate);
14969 if (PyErr_Occurred()) SWIG_fail;
14970 }
14971 {
14972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14973 }
14974 {
14975 if (temp1)
14976 delete arg1;
14977 }
14978 {
14979 if (temp2)
14980 delete arg2;
14981 }
14982 return resultobj;
14983 fail:
14984 {
14985 if (temp1)
14986 delete arg1;
14987 }
14988 {
14989 if (temp2)
14990 delete arg2;
14991 }
14992 return NULL;
14993 }
14994
14995
14996 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14997 PyObject *resultobj;
14998 wxMimeTypesManager *result;
14999 char *kwnames[] = {
15000 NULL
15001 };
15002
15003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15004 {
15005 PyThreadState* __tstate = wxPyBeginAllowThreads();
15006 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15007
15008 wxPyEndAllowThreads(__tstate);
15009 if (PyErr_Occurred()) SWIG_fail;
15010 }
15011 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15012 return resultobj;
15013 fail:
15014 return NULL;
15015 }
15016
15017
15018 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15019 PyObject *resultobj;
15020 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15021 int arg2 = (int) wxMAILCAP_ALL ;
15022 wxString const &arg3_defvalue = wxPyEmptyString ;
15023 wxString *arg3 = (wxString *) &arg3_defvalue ;
15024 bool temp3 = false ;
15025 PyObject * obj0 = 0 ;
15026 PyObject * obj1 = 0 ;
15027 PyObject * obj2 = 0 ;
15028 char *kwnames[] = {
15029 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15030 };
15031
15032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15034 if (SWIG_arg_fail(1)) SWIG_fail;
15035 if (obj1) {
15036 {
15037 arg2 = (int)(SWIG_As_int(obj1));
15038 if (SWIG_arg_fail(2)) SWIG_fail;
15039 }
15040 }
15041 if (obj2) {
15042 {
15043 arg3 = wxString_in_helper(obj2);
15044 if (arg3 == NULL) SWIG_fail;
15045 temp3 = true;
15046 }
15047 }
15048 {
15049 PyThreadState* __tstate = wxPyBeginAllowThreads();
15050 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15051
15052 wxPyEndAllowThreads(__tstate);
15053 if (PyErr_Occurred()) SWIG_fail;
15054 }
15055 Py_INCREF(Py_None); resultobj = Py_None;
15056 {
15057 if (temp3)
15058 delete arg3;
15059 }
15060 return resultobj;
15061 fail:
15062 {
15063 if (temp3)
15064 delete arg3;
15065 }
15066 return NULL;
15067 }
15068
15069
15070 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15071 PyObject *resultobj;
15072 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15073 PyObject * obj0 = 0 ;
15074 char *kwnames[] = {
15075 (char *) "self", NULL
15076 };
15077
15078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15080 if (SWIG_arg_fail(1)) SWIG_fail;
15081 {
15082 PyThreadState* __tstate = wxPyBeginAllowThreads();
15083 (arg1)->ClearData();
15084
15085 wxPyEndAllowThreads(__tstate);
15086 if (PyErr_Occurred()) SWIG_fail;
15087 }
15088 Py_INCREF(Py_None); resultobj = Py_None;
15089 return resultobj;
15090 fail:
15091 return NULL;
15092 }
15093
15094
15095 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15096 PyObject *resultobj;
15097 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15098 wxString *arg2 = 0 ;
15099 wxFileType *result;
15100 bool temp2 = false ;
15101 PyObject * obj0 = 0 ;
15102 PyObject * obj1 = 0 ;
15103 char *kwnames[] = {
15104 (char *) "self",(char *) "ext", NULL
15105 };
15106
15107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15109 if (SWIG_arg_fail(1)) SWIG_fail;
15110 {
15111 arg2 = wxString_in_helper(obj1);
15112 if (arg2 == NULL) SWIG_fail;
15113 temp2 = true;
15114 }
15115 {
15116 PyThreadState* __tstate = wxPyBeginAllowThreads();
15117 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15118
15119 wxPyEndAllowThreads(__tstate);
15120 if (PyErr_Occurred()) SWIG_fail;
15121 }
15122 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15123 {
15124 if (temp2)
15125 delete arg2;
15126 }
15127 return resultobj;
15128 fail:
15129 {
15130 if (temp2)
15131 delete arg2;
15132 }
15133 return NULL;
15134 }
15135
15136
15137 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15138 PyObject *resultobj;
15139 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15140 wxString *arg2 = 0 ;
15141 wxFileType *result;
15142 bool temp2 = false ;
15143 PyObject * obj0 = 0 ;
15144 PyObject * obj1 = 0 ;
15145 char *kwnames[] = {
15146 (char *) "self",(char *) "mimeType", NULL
15147 };
15148
15149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15151 if (SWIG_arg_fail(1)) SWIG_fail;
15152 {
15153 arg2 = wxString_in_helper(obj1);
15154 if (arg2 == NULL) SWIG_fail;
15155 temp2 = true;
15156 }
15157 {
15158 PyThreadState* __tstate = wxPyBeginAllowThreads();
15159 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15160
15161 wxPyEndAllowThreads(__tstate);
15162 if (PyErr_Occurred()) SWIG_fail;
15163 }
15164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15165 {
15166 if (temp2)
15167 delete arg2;
15168 }
15169 return resultobj;
15170 fail:
15171 {
15172 if (temp2)
15173 delete arg2;
15174 }
15175 return NULL;
15176 }
15177
15178
15179 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15180 PyObject *resultobj;
15181 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15182 wxString *arg2 = 0 ;
15183 bool arg3 = (bool) false ;
15184 bool result;
15185 bool temp2 = false ;
15186 PyObject * obj0 = 0 ;
15187 PyObject * obj1 = 0 ;
15188 PyObject * obj2 = 0 ;
15189 char *kwnames[] = {
15190 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15191 };
15192
15193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15195 if (SWIG_arg_fail(1)) SWIG_fail;
15196 {
15197 arg2 = wxString_in_helper(obj1);
15198 if (arg2 == NULL) SWIG_fail;
15199 temp2 = true;
15200 }
15201 if (obj2) {
15202 {
15203 arg3 = (bool)(SWIG_As_bool(obj2));
15204 if (SWIG_arg_fail(3)) SWIG_fail;
15205 }
15206 }
15207 {
15208 PyThreadState* __tstate = wxPyBeginAllowThreads();
15209 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15210
15211 wxPyEndAllowThreads(__tstate);
15212 if (PyErr_Occurred()) SWIG_fail;
15213 }
15214 {
15215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15216 }
15217 {
15218 if (temp2)
15219 delete arg2;
15220 }
15221 return resultobj;
15222 fail:
15223 {
15224 if (temp2)
15225 delete arg2;
15226 }
15227 return NULL;
15228 }
15229
15230
15231 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15232 PyObject *resultobj;
15233 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15234 wxString *arg2 = 0 ;
15235 bool result;
15236 bool temp2 = false ;
15237 PyObject * obj0 = 0 ;
15238 PyObject * obj1 = 0 ;
15239 char *kwnames[] = {
15240 (char *) "self",(char *) "filename", NULL
15241 };
15242
15243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15245 if (SWIG_arg_fail(1)) SWIG_fail;
15246 {
15247 arg2 = wxString_in_helper(obj1);
15248 if (arg2 == NULL) SWIG_fail;
15249 temp2 = true;
15250 }
15251 {
15252 PyThreadState* __tstate = wxPyBeginAllowThreads();
15253 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15254
15255 wxPyEndAllowThreads(__tstate);
15256 if (PyErr_Occurred()) SWIG_fail;
15257 }
15258 {
15259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15260 }
15261 {
15262 if (temp2)
15263 delete arg2;
15264 }
15265 return resultobj;
15266 fail:
15267 {
15268 if (temp2)
15269 delete arg2;
15270 }
15271 return NULL;
15272 }
15273
15274
15275 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15276 PyObject *resultobj;
15277 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15278 PyObject *result;
15279 PyObject * obj0 = 0 ;
15280 char *kwnames[] = {
15281 (char *) "self", NULL
15282 };
15283
15284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15286 if (SWIG_arg_fail(1)) SWIG_fail;
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15290
15291 wxPyEndAllowThreads(__tstate);
15292 if (PyErr_Occurred()) SWIG_fail;
15293 }
15294 resultobj = result;
15295 return resultobj;
15296 fail:
15297 return NULL;
15298 }
15299
15300
15301 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15302 PyObject *resultobj;
15303 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15304 wxFileTypeInfo *arg2 = 0 ;
15305 PyObject * obj0 = 0 ;
15306 PyObject * obj1 = 0 ;
15307 char *kwnames[] = {
15308 (char *) "self",(char *) "ft", NULL
15309 };
15310
15311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15313 if (SWIG_arg_fail(1)) SWIG_fail;
15314 {
15315 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15316 if (SWIG_arg_fail(2)) SWIG_fail;
15317 if (arg2 == NULL) {
15318 SWIG_null_ref("wxFileTypeInfo");
15319 }
15320 if (SWIG_arg_fail(2)) SWIG_fail;
15321 }
15322 {
15323 PyThreadState* __tstate = wxPyBeginAllowThreads();
15324 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15325
15326 wxPyEndAllowThreads(__tstate);
15327 if (PyErr_Occurred()) SWIG_fail;
15328 }
15329 Py_INCREF(Py_None); resultobj = Py_None;
15330 return resultobj;
15331 fail:
15332 return NULL;
15333 }
15334
15335
15336 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15337 PyObject *resultobj;
15338 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15339 wxFileTypeInfo *arg2 = 0 ;
15340 wxFileType *result;
15341 PyObject * obj0 = 0 ;
15342 PyObject * obj1 = 0 ;
15343 char *kwnames[] = {
15344 (char *) "self",(char *) "ftInfo", NULL
15345 };
15346
15347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15349 if (SWIG_arg_fail(1)) SWIG_fail;
15350 {
15351 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15352 if (SWIG_arg_fail(2)) SWIG_fail;
15353 if (arg2 == NULL) {
15354 SWIG_null_ref("wxFileTypeInfo");
15355 }
15356 if (SWIG_arg_fail(2)) SWIG_fail;
15357 }
15358 {
15359 PyThreadState* __tstate = wxPyBeginAllowThreads();
15360 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15361
15362 wxPyEndAllowThreads(__tstate);
15363 if (PyErr_Occurred()) SWIG_fail;
15364 }
15365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15366 return resultobj;
15367 fail:
15368 return NULL;
15369 }
15370
15371
15372 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15373 PyObject *resultobj;
15374 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15375 wxFileType *arg2 = (wxFileType *) 0 ;
15376 bool result;
15377 PyObject * obj0 = 0 ;
15378 PyObject * obj1 = 0 ;
15379 char *kwnames[] = {
15380 (char *) "self",(char *) "ft", NULL
15381 };
15382
15383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15385 if (SWIG_arg_fail(1)) SWIG_fail;
15386 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15387 if (SWIG_arg_fail(2)) SWIG_fail;
15388 {
15389 PyThreadState* __tstate = wxPyBeginAllowThreads();
15390 result = (bool)(arg1)->Unassociate(arg2);
15391
15392 wxPyEndAllowThreads(__tstate);
15393 if (PyErr_Occurred()) SWIG_fail;
15394 }
15395 {
15396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15397 }
15398 return resultobj;
15399 fail:
15400 return NULL;
15401 }
15402
15403
15404 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15405 PyObject *resultobj;
15406 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15407 PyObject * obj0 = 0 ;
15408 char *kwnames[] = {
15409 (char *) "self", NULL
15410 };
15411
15412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15414 if (SWIG_arg_fail(1)) SWIG_fail;
15415 {
15416 PyThreadState* __tstate = wxPyBeginAllowThreads();
15417 delete arg1;
15418
15419 wxPyEndAllowThreads(__tstate);
15420 if (PyErr_Occurred()) SWIG_fail;
15421 }
15422 Py_INCREF(Py_None); resultobj = Py_None;
15423 return resultobj;
15424 fail:
15425 return NULL;
15426 }
15427
15428
15429 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15430 PyObject *obj;
15431 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15432 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15433 Py_INCREF(obj);
15434 return Py_BuildValue((char *)"");
15435 }
15436 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15437 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15438 return 1;
15439 }
15440
15441
15442 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15443 PyObject *pyobj;
15444
15445 {
15446 #if wxUSE_UNICODE
15447 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15448 #else
15449 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15450 #endif
15451 }
15452 return pyobj;
15453 }
15454
15455
15456 static int _wrap_ART_MENU_set(PyObject *) {
15457 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15458 return 1;
15459 }
15460
15461
15462 static PyObject *_wrap_ART_MENU_get(void) {
15463 PyObject *pyobj;
15464
15465 {
15466 #if wxUSE_UNICODE
15467 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15468 #else
15469 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15470 #endif
15471 }
15472 return pyobj;
15473 }
15474
15475
15476 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15477 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15478 return 1;
15479 }
15480
15481
15482 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15483 PyObject *pyobj;
15484
15485 {
15486 #if wxUSE_UNICODE
15487 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15488 #else
15489 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15490 #endif
15491 }
15492 return pyobj;
15493 }
15494
15495
15496 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15497 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15498 return 1;
15499 }
15500
15501
15502 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15503 PyObject *pyobj;
15504
15505 {
15506 #if wxUSE_UNICODE
15507 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15508 #else
15509 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15510 #endif
15511 }
15512 return pyobj;
15513 }
15514
15515
15516 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15517 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15518 return 1;
15519 }
15520
15521
15522 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15523 PyObject *pyobj;
15524
15525 {
15526 #if wxUSE_UNICODE
15527 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15528 #else
15529 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15530 #endif
15531 }
15532 return pyobj;
15533 }
15534
15535
15536 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15537 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15538 return 1;
15539 }
15540
15541
15542 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15543 PyObject *pyobj;
15544
15545 {
15546 #if wxUSE_UNICODE
15547 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15548 #else
15549 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15550 #endif
15551 }
15552 return pyobj;
15553 }
15554
15555
15556 static int _wrap_ART_BUTTON_set(PyObject *) {
15557 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15558 return 1;
15559 }
15560
15561
15562 static PyObject *_wrap_ART_BUTTON_get(void) {
15563 PyObject *pyobj;
15564
15565 {
15566 #if wxUSE_UNICODE
15567 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15568 #else
15569 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15570 #endif
15571 }
15572 return pyobj;
15573 }
15574
15575
15576 static int _wrap_ART_OTHER_set(PyObject *) {
15577 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15578 return 1;
15579 }
15580
15581
15582 static PyObject *_wrap_ART_OTHER_get(void) {
15583 PyObject *pyobj;
15584
15585 {
15586 #if wxUSE_UNICODE
15587 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15588 #else
15589 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15590 #endif
15591 }
15592 return pyobj;
15593 }
15594
15595
15596 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15597 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15598 return 1;
15599 }
15600
15601
15602 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15603 PyObject *pyobj;
15604
15605 {
15606 #if wxUSE_UNICODE
15607 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15608 #else
15609 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15610 #endif
15611 }
15612 return pyobj;
15613 }
15614
15615
15616 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15617 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15618 return 1;
15619 }
15620
15621
15622 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15623 PyObject *pyobj;
15624
15625 {
15626 #if wxUSE_UNICODE
15627 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15628 #else
15629 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15630 #endif
15631 }
15632 return pyobj;
15633 }
15634
15635
15636 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15637 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15638 return 1;
15639 }
15640
15641
15642 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15643 PyObject *pyobj;
15644
15645 {
15646 #if wxUSE_UNICODE
15647 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15648 #else
15649 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15650 #endif
15651 }
15652 return pyobj;
15653 }
15654
15655
15656 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15657 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15658 return 1;
15659 }
15660
15661
15662 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15663 PyObject *pyobj;
15664
15665 {
15666 #if wxUSE_UNICODE
15667 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15668 #else
15669 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15670 #endif
15671 }
15672 return pyobj;
15673 }
15674
15675
15676 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15677 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15678 return 1;
15679 }
15680
15681
15682 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15683 PyObject *pyobj;
15684
15685 {
15686 #if wxUSE_UNICODE
15687 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15688 #else
15689 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15690 #endif
15691 }
15692 return pyobj;
15693 }
15694
15695
15696 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15697 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15698 return 1;
15699 }
15700
15701
15702 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15703 PyObject *pyobj;
15704
15705 {
15706 #if wxUSE_UNICODE
15707 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15708 #else
15709 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15710 #endif
15711 }
15712 return pyobj;
15713 }
15714
15715
15716 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15717 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15718 return 1;
15719 }
15720
15721
15722 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15723 PyObject *pyobj;
15724
15725 {
15726 #if wxUSE_UNICODE
15727 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15728 #else
15729 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15730 #endif
15731 }
15732 return pyobj;
15733 }
15734
15735
15736 static int _wrap_ART_GO_BACK_set(PyObject *) {
15737 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15738 return 1;
15739 }
15740
15741
15742 static PyObject *_wrap_ART_GO_BACK_get(void) {
15743 PyObject *pyobj;
15744
15745 {
15746 #if wxUSE_UNICODE
15747 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15748 #else
15749 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15750 #endif
15751 }
15752 return pyobj;
15753 }
15754
15755
15756 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15757 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15758 return 1;
15759 }
15760
15761
15762 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15763 PyObject *pyobj;
15764
15765 {
15766 #if wxUSE_UNICODE
15767 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15768 #else
15769 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15770 #endif
15771 }
15772 return pyobj;
15773 }
15774
15775
15776 static int _wrap_ART_GO_UP_set(PyObject *) {
15777 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15778 return 1;
15779 }
15780
15781
15782 static PyObject *_wrap_ART_GO_UP_get(void) {
15783 PyObject *pyobj;
15784
15785 {
15786 #if wxUSE_UNICODE
15787 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15788 #else
15789 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15790 #endif
15791 }
15792 return pyobj;
15793 }
15794
15795
15796 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15797 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15798 return 1;
15799 }
15800
15801
15802 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15803 PyObject *pyobj;
15804
15805 {
15806 #if wxUSE_UNICODE
15807 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15808 #else
15809 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15810 #endif
15811 }
15812 return pyobj;
15813 }
15814
15815
15816 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15817 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15818 return 1;
15819 }
15820
15821
15822 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15823 PyObject *pyobj;
15824
15825 {
15826 #if wxUSE_UNICODE
15827 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15828 #else
15829 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15830 #endif
15831 }
15832 return pyobj;
15833 }
15834
15835
15836 static int _wrap_ART_GO_HOME_set(PyObject *) {
15837 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15838 return 1;
15839 }
15840
15841
15842 static PyObject *_wrap_ART_GO_HOME_get(void) {
15843 PyObject *pyobj;
15844
15845 {
15846 #if wxUSE_UNICODE
15847 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15848 #else
15849 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15850 #endif
15851 }
15852 return pyobj;
15853 }
15854
15855
15856 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15857 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15858 return 1;
15859 }
15860
15861
15862 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15863 PyObject *pyobj;
15864
15865 {
15866 #if wxUSE_UNICODE
15867 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15868 #else
15869 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15870 #endif
15871 }
15872 return pyobj;
15873 }
15874
15875
15876 static int _wrap_ART_PRINT_set(PyObject *) {
15877 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15878 return 1;
15879 }
15880
15881
15882 static PyObject *_wrap_ART_PRINT_get(void) {
15883 PyObject *pyobj;
15884
15885 {
15886 #if wxUSE_UNICODE
15887 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15888 #else
15889 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15890 #endif
15891 }
15892 return pyobj;
15893 }
15894
15895
15896 static int _wrap_ART_HELP_set(PyObject *) {
15897 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15898 return 1;
15899 }
15900
15901
15902 static PyObject *_wrap_ART_HELP_get(void) {
15903 PyObject *pyobj;
15904
15905 {
15906 #if wxUSE_UNICODE
15907 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15908 #else
15909 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15910 #endif
15911 }
15912 return pyobj;
15913 }
15914
15915
15916 static int _wrap_ART_TIP_set(PyObject *) {
15917 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15918 return 1;
15919 }
15920
15921
15922 static PyObject *_wrap_ART_TIP_get(void) {
15923 PyObject *pyobj;
15924
15925 {
15926 #if wxUSE_UNICODE
15927 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15928 #else
15929 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15930 #endif
15931 }
15932 return pyobj;
15933 }
15934
15935
15936 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15937 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15938 return 1;
15939 }
15940
15941
15942 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15943 PyObject *pyobj;
15944
15945 {
15946 #if wxUSE_UNICODE
15947 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15948 #else
15949 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15950 #endif
15951 }
15952 return pyobj;
15953 }
15954
15955
15956 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15957 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15958 return 1;
15959 }
15960
15961
15962 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15963 PyObject *pyobj;
15964
15965 {
15966 #if wxUSE_UNICODE
15967 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15968 #else
15969 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15970 #endif
15971 }
15972 return pyobj;
15973 }
15974
15975
15976 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15977 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15978 return 1;
15979 }
15980
15981
15982 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15983 PyObject *pyobj;
15984
15985 {
15986 #if wxUSE_UNICODE
15987 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15988 #else
15989 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15990 #endif
15991 }
15992 return pyobj;
15993 }
15994
15995
15996 static int _wrap_ART_HARDDISK_set(PyObject *) {
15997 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15998 return 1;
15999 }
16000
16001
16002 static PyObject *_wrap_ART_HARDDISK_get(void) {
16003 PyObject *pyobj;
16004
16005 {
16006 #if wxUSE_UNICODE
16007 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16008 #else
16009 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16010 #endif
16011 }
16012 return pyobj;
16013 }
16014
16015
16016 static int _wrap_ART_FLOPPY_set(PyObject *) {
16017 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16018 return 1;
16019 }
16020
16021
16022 static PyObject *_wrap_ART_FLOPPY_get(void) {
16023 PyObject *pyobj;
16024
16025 {
16026 #if wxUSE_UNICODE
16027 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16028 #else
16029 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16030 #endif
16031 }
16032 return pyobj;
16033 }
16034
16035
16036 static int _wrap_ART_CDROM_set(PyObject *) {
16037 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16038 return 1;
16039 }
16040
16041
16042 static PyObject *_wrap_ART_CDROM_get(void) {
16043 PyObject *pyobj;
16044
16045 {
16046 #if wxUSE_UNICODE
16047 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16048 #else
16049 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16050 #endif
16051 }
16052 return pyobj;
16053 }
16054
16055
16056 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16057 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16058 return 1;
16059 }
16060
16061
16062 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16063 PyObject *pyobj;
16064
16065 {
16066 #if wxUSE_UNICODE
16067 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16068 #else
16069 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16070 #endif
16071 }
16072 return pyobj;
16073 }
16074
16075
16076 static int _wrap_ART_FOLDER_set(PyObject *) {
16077 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16078 return 1;
16079 }
16080
16081
16082 static PyObject *_wrap_ART_FOLDER_get(void) {
16083 PyObject *pyobj;
16084
16085 {
16086 #if wxUSE_UNICODE
16087 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16088 #else
16089 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16090 #endif
16091 }
16092 return pyobj;
16093 }
16094
16095
16096 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16097 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16098 return 1;
16099 }
16100
16101
16102 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16103 PyObject *pyobj;
16104
16105 {
16106 #if wxUSE_UNICODE
16107 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16108 #else
16109 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16110 #endif
16111 }
16112 return pyobj;
16113 }
16114
16115
16116 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16117 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16118 return 1;
16119 }
16120
16121
16122 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16123 PyObject *pyobj;
16124
16125 {
16126 #if wxUSE_UNICODE
16127 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16128 #else
16129 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16130 #endif
16131 }
16132 return pyobj;
16133 }
16134
16135
16136 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16137 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16138 return 1;
16139 }
16140
16141
16142 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16143 PyObject *pyobj;
16144
16145 {
16146 #if wxUSE_UNICODE
16147 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16148 #else
16149 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16150 #endif
16151 }
16152 return pyobj;
16153 }
16154
16155
16156 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16157 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16158 return 1;
16159 }
16160
16161
16162 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16163 PyObject *pyobj;
16164
16165 {
16166 #if wxUSE_UNICODE
16167 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16168 #else
16169 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16170 #endif
16171 }
16172 return pyobj;
16173 }
16174
16175
16176 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16177 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16178 return 1;
16179 }
16180
16181
16182 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16183 PyObject *pyobj;
16184
16185 {
16186 #if wxUSE_UNICODE
16187 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16188 #else
16189 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16190 #endif
16191 }
16192 return pyobj;
16193 }
16194
16195
16196 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16197 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16198 return 1;
16199 }
16200
16201
16202 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16203 PyObject *pyobj;
16204
16205 {
16206 #if wxUSE_UNICODE
16207 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16208 #else
16209 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16210 #endif
16211 }
16212 return pyobj;
16213 }
16214
16215
16216 static int _wrap_ART_ERROR_set(PyObject *) {
16217 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16218 return 1;
16219 }
16220
16221
16222 static PyObject *_wrap_ART_ERROR_get(void) {
16223 PyObject *pyobj;
16224
16225 {
16226 #if wxUSE_UNICODE
16227 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16228 #else
16229 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16230 #endif
16231 }
16232 return pyobj;
16233 }
16234
16235
16236 static int _wrap_ART_QUESTION_set(PyObject *) {
16237 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16238 return 1;
16239 }
16240
16241
16242 static PyObject *_wrap_ART_QUESTION_get(void) {
16243 PyObject *pyobj;
16244
16245 {
16246 #if wxUSE_UNICODE
16247 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16248 #else
16249 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16250 #endif
16251 }
16252 return pyobj;
16253 }
16254
16255
16256 static int _wrap_ART_WARNING_set(PyObject *) {
16257 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16258 return 1;
16259 }
16260
16261
16262 static PyObject *_wrap_ART_WARNING_get(void) {
16263 PyObject *pyobj;
16264
16265 {
16266 #if wxUSE_UNICODE
16267 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16268 #else
16269 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16270 #endif
16271 }
16272 return pyobj;
16273 }
16274
16275
16276 static int _wrap_ART_INFORMATION_set(PyObject *) {
16277 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16278 return 1;
16279 }
16280
16281
16282 static PyObject *_wrap_ART_INFORMATION_get(void) {
16283 PyObject *pyobj;
16284
16285 {
16286 #if wxUSE_UNICODE
16287 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16288 #else
16289 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16290 #endif
16291 }
16292 return pyobj;
16293 }
16294
16295
16296 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16297 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16298 return 1;
16299 }
16300
16301
16302 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16303 PyObject *pyobj;
16304
16305 {
16306 #if wxUSE_UNICODE
16307 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16308 #else
16309 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16310 #endif
16311 }
16312 return pyobj;
16313 }
16314
16315
16316 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16317 PyObject *resultobj;
16318 wxPyArtProvider *result;
16319 char *kwnames[] = {
16320 NULL
16321 };
16322
16323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16324 {
16325 if (!wxPyCheckForApp()) SWIG_fail;
16326 PyThreadState* __tstate = wxPyBeginAllowThreads();
16327 result = (wxPyArtProvider *)new wxPyArtProvider();
16328
16329 wxPyEndAllowThreads(__tstate);
16330 if (PyErr_Occurred()) SWIG_fail;
16331 }
16332 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16333 return resultobj;
16334 fail:
16335 return NULL;
16336 }
16337
16338
16339 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16340 PyObject *resultobj;
16341 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16342 PyObject *arg2 = (PyObject *) 0 ;
16343 PyObject *arg3 = (PyObject *) 0 ;
16344 PyObject * obj0 = 0 ;
16345 PyObject * obj1 = 0 ;
16346 PyObject * obj2 = 0 ;
16347 char *kwnames[] = {
16348 (char *) "self",(char *) "self",(char *) "_class", NULL
16349 };
16350
16351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16353 if (SWIG_arg_fail(1)) SWIG_fail;
16354 arg2 = obj1;
16355 arg3 = obj2;
16356 {
16357 PyThreadState* __tstate = wxPyBeginAllowThreads();
16358 (arg1)->_setCallbackInfo(arg2,arg3);
16359
16360 wxPyEndAllowThreads(__tstate);
16361 if (PyErr_Occurred()) SWIG_fail;
16362 }
16363 Py_INCREF(Py_None); resultobj = Py_None;
16364 return resultobj;
16365 fail:
16366 return NULL;
16367 }
16368
16369
16370 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16371 PyObject *resultobj;
16372 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16373 PyObject * obj0 = 0 ;
16374 char *kwnames[] = {
16375 (char *) "provider", NULL
16376 };
16377
16378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16380 if (SWIG_arg_fail(1)) SWIG_fail;
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 wxPyArtProvider::PushProvider(arg1);
16384
16385 wxPyEndAllowThreads(__tstate);
16386 if (PyErr_Occurred()) SWIG_fail;
16387 }
16388 Py_INCREF(Py_None); resultobj = Py_None;
16389 return resultobj;
16390 fail:
16391 return NULL;
16392 }
16393
16394
16395 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16396 PyObject *resultobj;
16397 bool result;
16398 char *kwnames[] = {
16399 NULL
16400 };
16401
16402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16403 {
16404 PyThreadState* __tstate = wxPyBeginAllowThreads();
16405 result = (bool)wxPyArtProvider::PopProvider();
16406
16407 wxPyEndAllowThreads(__tstate);
16408 if (PyErr_Occurred()) SWIG_fail;
16409 }
16410 {
16411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16412 }
16413 return resultobj;
16414 fail:
16415 return NULL;
16416 }
16417
16418
16419 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16420 PyObject *resultobj;
16421 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16422 bool result;
16423 PyObject * obj0 = 0 ;
16424 char *kwnames[] = {
16425 (char *) "provider", NULL
16426 };
16427
16428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16430 if (SWIG_arg_fail(1)) SWIG_fail;
16431 {
16432 PyThreadState* __tstate = wxPyBeginAllowThreads();
16433 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16434
16435 wxPyEndAllowThreads(__tstate);
16436 if (PyErr_Occurred()) SWIG_fail;
16437 }
16438 {
16439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16440 }
16441 return resultobj;
16442 fail:
16443 return NULL;
16444 }
16445
16446
16447 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16448 PyObject *resultobj;
16449 wxString *arg1 = 0 ;
16450 wxString const &arg2_defvalue = wxPyART_OTHER ;
16451 wxString *arg2 = (wxString *) &arg2_defvalue ;
16452 wxSize const &arg3_defvalue = wxDefaultSize ;
16453 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16454 wxBitmap result;
16455 bool temp1 = false ;
16456 bool temp2 = false ;
16457 wxSize temp3 ;
16458 PyObject * obj0 = 0 ;
16459 PyObject * obj1 = 0 ;
16460 PyObject * obj2 = 0 ;
16461 char *kwnames[] = {
16462 (char *) "id",(char *) "client",(char *) "size", NULL
16463 };
16464
16465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16466 {
16467 arg1 = wxString_in_helper(obj0);
16468 if (arg1 == NULL) SWIG_fail;
16469 temp1 = true;
16470 }
16471 if (obj1) {
16472 {
16473 arg2 = wxString_in_helper(obj1);
16474 if (arg2 == NULL) SWIG_fail;
16475 temp2 = true;
16476 }
16477 }
16478 if (obj2) {
16479 {
16480 arg3 = &temp3;
16481 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16482 }
16483 }
16484 {
16485 if (!wxPyCheckForApp()) SWIG_fail;
16486 PyThreadState* __tstate = wxPyBeginAllowThreads();
16487 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16488
16489 wxPyEndAllowThreads(__tstate);
16490 if (PyErr_Occurred()) SWIG_fail;
16491 }
16492 {
16493 wxBitmap * resultptr;
16494 resultptr = new wxBitmap((wxBitmap &)(result));
16495 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16496 }
16497 {
16498 if (temp1)
16499 delete arg1;
16500 }
16501 {
16502 if (temp2)
16503 delete arg2;
16504 }
16505 return resultobj;
16506 fail:
16507 {
16508 if (temp1)
16509 delete arg1;
16510 }
16511 {
16512 if (temp2)
16513 delete arg2;
16514 }
16515 return NULL;
16516 }
16517
16518
16519 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16520 PyObject *resultobj;
16521 wxString *arg1 = 0 ;
16522 wxString const &arg2_defvalue = wxPyART_OTHER ;
16523 wxString *arg2 = (wxString *) &arg2_defvalue ;
16524 wxSize const &arg3_defvalue = wxDefaultSize ;
16525 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16526 wxIcon result;
16527 bool temp1 = false ;
16528 bool temp2 = false ;
16529 wxSize temp3 ;
16530 PyObject * obj0 = 0 ;
16531 PyObject * obj1 = 0 ;
16532 PyObject * obj2 = 0 ;
16533 char *kwnames[] = {
16534 (char *) "id",(char *) "client",(char *) "size", NULL
16535 };
16536
16537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16538 {
16539 arg1 = wxString_in_helper(obj0);
16540 if (arg1 == NULL) SWIG_fail;
16541 temp1 = true;
16542 }
16543 if (obj1) {
16544 {
16545 arg2 = wxString_in_helper(obj1);
16546 if (arg2 == NULL) SWIG_fail;
16547 temp2 = true;
16548 }
16549 }
16550 if (obj2) {
16551 {
16552 arg3 = &temp3;
16553 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16554 }
16555 }
16556 {
16557 if (!wxPyCheckForApp()) SWIG_fail;
16558 PyThreadState* __tstate = wxPyBeginAllowThreads();
16559 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16560
16561 wxPyEndAllowThreads(__tstate);
16562 if (PyErr_Occurred()) SWIG_fail;
16563 }
16564 {
16565 wxIcon * resultptr;
16566 resultptr = new wxIcon((wxIcon &)(result));
16567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16568 }
16569 {
16570 if (temp1)
16571 delete arg1;
16572 }
16573 {
16574 if (temp2)
16575 delete arg2;
16576 }
16577 return resultobj;
16578 fail:
16579 {
16580 if (temp1)
16581 delete arg1;
16582 }
16583 {
16584 if (temp2)
16585 delete arg2;
16586 }
16587 return NULL;
16588 }
16589
16590
16591 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16592 PyObject *resultobj;
16593 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16594 PyObject * obj0 = 0 ;
16595 char *kwnames[] = {
16596 (char *) "self", NULL
16597 };
16598
16599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16601 if (SWIG_arg_fail(1)) SWIG_fail;
16602 {
16603 PyThreadState* __tstate = wxPyBeginAllowThreads();
16604 wxPyArtProvider_Destroy(arg1);
16605
16606 wxPyEndAllowThreads(__tstate);
16607 if (PyErr_Occurred()) SWIG_fail;
16608 }
16609 Py_INCREF(Py_None); resultobj = Py_None;
16610 return resultobj;
16611 fail:
16612 return NULL;
16613 }
16614
16615
16616 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16617 PyObject *obj;
16618 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16619 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16620 Py_INCREF(obj);
16621 return Py_BuildValue((char *)"");
16622 }
16623 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16624 PyObject *resultobj;
16625 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16626 PyObject * obj0 = 0 ;
16627 char *kwnames[] = {
16628 (char *) "self", NULL
16629 };
16630
16631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16633 if (SWIG_arg_fail(1)) SWIG_fail;
16634 {
16635 PyThreadState* __tstate = wxPyBeginAllowThreads();
16636 delete arg1;
16637
16638 wxPyEndAllowThreads(__tstate);
16639 if (PyErr_Occurred()) SWIG_fail;
16640 }
16641 Py_INCREF(Py_None); resultobj = Py_None;
16642 return resultobj;
16643 fail:
16644 return NULL;
16645 }
16646
16647
16648 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16649 PyObject *resultobj;
16650 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16651 wxConfigBase *result;
16652 PyObject * obj0 = 0 ;
16653 char *kwnames[] = {
16654 (char *) "config", NULL
16655 };
16656
16657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16659 if (SWIG_arg_fail(1)) SWIG_fail;
16660 {
16661 PyThreadState* __tstate = wxPyBeginAllowThreads();
16662 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16663
16664 wxPyEndAllowThreads(__tstate);
16665 if (PyErr_Occurred()) SWIG_fail;
16666 }
16667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16668 return resultobj;
16669 fail:
16670 return NULL;
16671 }
16672
16673
16674 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16675 PyObject *resultobj;
16676 bool arg1 = (bool) true ;
16677 wxConfigBase *result;
16678 PyObject * obj0 = 0 ;
16679 char *kwnames[] = {
16680 (char *) "createOnDemand", NULL
16681 };
16682
16683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16684 if (obj0) {
16685 {
16686 arg1 = (bool)(SWIG_As_bool(obj0));
16687 if (SWIG_arg_fail(1)) SWIG_fail;
16688 }
16689 }
16690 {
16691 PyThreadState* __tstate = wxPyBeginAllowThreads();
16692 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16693
16694 wxPyEndAllowThreads(__tstate);
16695 if (PyErr_Occurred()) SWIG_fail;
16696 }
16697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16698 return resultobj;
16699 fail:
16700 return NULL;
16701 }
16702
16703
16704 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16705 PyObject *resultobj;
16706 wxConfigBase *result;
16707 char *kwnames[] = {
16708 NULL
16709 };
16710
16711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16712 {
16713 PyThreadState* __tstate = wxPyBeginAllowThreads();
16714 result = (wxConfigBase *)wxConfigBase::Create();
16715
16716 wxPyEndAllowThreads(__tstate);
16717 if (PyErr_Occurred()) SWIG_fail;
16718 }
16719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16720 return resultobj;
16721 fail:
16722 return NULL;
16723 }
16724
16725
16726 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16727 PyObject *resultobj;
16728 char *kwnames[] = {
16729 NULL
16730 };
16731
16732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16733 {
16734 PyThreadState* __tstate = wxPyBeginAllowThreads();
16735 wxConfigBase::DontCreateOnDemand();
16736
16737 wxPyEndAllowThreads(__tstate);
16738 if (PyErr_Occurred()) SWIG_fail;
16739 }
16740 Py_INCREF(Py_None); resultobj = Py_None;
16741 return resultobj;
16742 fail:
16743 return NULL;
16744 }
16745
16746
16747 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16748 PyObject *resultobj;
16749 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16750 wxString *arg2 = 0 ;
16751 bool temp2 = false ;
16752 PyObject * obj0 = 0 ;
16753 PyObject * obj1 = 0 ;
16754 char *kwnames[] = {
16755 (char *) "self",(char *) "path", NULL
16756 };
16757
16758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16760 if (SWIG_arg_fail(1)) SWIG_fail;
16761 {
16762 arg2 = wxString_in_helper(obj1);
16763 if (arg2 == NULL) SWIG_fail;
16764 temp2 = true;
16765 }
16766 {
16767 PyThreadState* __tstate = wxPyBeginAllowThreads();
16768 (arg1)->SetPath((wxString const &)*arg2);
16769
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 Py_INCREF(Py_None); resultobj = Py_None;
16774 {
16775 if (temp2)
16776 delete arg2;
16777 }
16778 return resultobj;
16779 fail:
16780 {
16781 if (temp2)
16782 delete arg2;
16783 }
16784 return NULL;
16785 }
16786
16787
16788 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16789 PyObject *resultobj;
16790 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16791 wxString *result;
16792 PyObject * obj0 = 0 ;
16793 char *kwnames[] = {
16794 (char *) "self", NULL
16795 };
16796
16797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16799 if (SWIG_arg_fail(1)) SWIG_fail;
16800 {
16801 PyThreadState* __tstate = wxPyBeginAllowThreads();
16802 {
16803 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16804 result = (wxString *) &_result_ref;
16805 }
16806
16807 wxPyEndAllowThreads(__tstate);
16808 if (PyErr_Occurred()) SWIG_fail;
16809 }
16810 {
16811 #if wxUSE_UNICODE
16812 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16813 #else
16814 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16815 #endif
16816 }
16817 return resultobj;
16818 fail:
16819 return NULL;
16820 }
16821
16822
16823 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16824 PyObject *resultobj;
16825 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16826 PyObject *result;
16827 PyObject * obj0 = 0 ;
16828 char *kwnames[] = {
16829 (char *) "self", NULL
16830 };
16831
16832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16834 if (SWIG_arg_fail(1)) SWIG_fail;
16835 {
16836 PyThreadState* __tstate = wxPyBeginAllowThreads();
16837 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16838
16839 wxPyEndAllowThreads(__tstate);
16840 if (PyErr_Occurred()) SWIG_fail;
16841 }
16842 resultobj = result;
16843 return resultobj;
16844 fail:
16845 return NULL;
16846 }
16847
16848
16849 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16850 PyObject *resultobj;
16851 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16852 long arg2 ;
16853 PyObject *result;
16854 PyObject * obj0 = 0 ;
16855 PyObject * obj1 = 0 ;
16856 char *kwnames[] = {
16857 (char *) "self",(char *) "index", NULL
16858 };
16859
16860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
16861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16862 if (SWIG_arg_fail(1)) SWIG_fail;
16863 {
16864 arg2 = (long)(SWIG_As_long(obj1));
16865 if (SWIG_arg_fail(2)) SWIG_fail;
16866 }
16867 {
16868 PyThreadState* __tstate = wxPyBeginAllowThreads();
16869 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
16870
16871 wxPyEndAllowThreads(__tstate);
16872 if (PyErr_Occurred()) SWIG_fail;
16873 }
16874 resultobj = result;
16875 return resultobj;
16876 fail:
16877 return NULL;
16878 }
16879
16880
16881 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16882 PyObject *resultobj;
16883 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16884 PyObject *result;
16885 PyObject * obj0 = 0 ;
16886 char *kwnames[] = {
16887 (char *) "self", NULL
16888 };
16889
16890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
16891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16892 if (SWIG_arg_fail(1)) SWIG_fail;
16893 {
16894 PyThreadState* __tstate = wxPyBeginAllowThreads();
16895 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
16896
16897 wxPyEndAllowThreads(__tstate);
16898 if (PyErr_Occurred()) SWIG_fail;
16899 }
16900 resultobj = result;
16901 return resultobj;
16902 fail:
16903 return NULL;
16904 }
16905
16906
16907 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16908 PyObject *resultobj;
16909 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16910 long arg2 ;
16911 PyObject *result;
16912 PyObject * obj0 = 0 ;
16913 PyObject * obj1 = 0 ;
16914 char *kwnames[] = {
16915 (char *) "self",(char *) "index", NULL
16916 };
16917
16918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
16919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16920 if (SWIG_arg_fail(1)) SWIG_fail;
16921 {
16922 arg2 = (long)(SWIG_As_long(obj1));
16923 if (SWIG_arg_fail(2)) SWIG_fail;
16924 }
16925 {
16926 PyThreadState* __tstate = wxPyBeginAllowThreads();
16927 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
16928
16929 wxPyEndAllowThreads(__tstate);
16930 if (PyErr_Occurred()) SWIG_fail;
16931 }
16932 resultobj = result;
16933 return resultobj;
16934 fail:
16935 return NULL;
16936 }
16937
16938
16939 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
16940 PyObject *resultobj;
16941 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16942 bool arg2 = (bool) false ;
16943 size_t result;
16944 PyObject * obj0 = 0 ;
16945 PyObject * obj1 = 0 ;
16946 char *kwnames[] = {
16947 (char *) "self",(char *) "recursive", NULL
16948 };
16949
16950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
16951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16952 if (SWIG_arg_fail(1)) SWIG_fail;
16953 if (obj1) {
16954 {
16955 arg2 = (bool)(SWIG_As_bool(obj1));
16956 if (SWIG_arg_fail(2)) SWIG_fail;
16957 }
16958 }
16959 {
16960 PyThreadState* __tstate = wxPyBeginAllowThreads();
16961 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
16962
16963 wxPyEndAllowThreads(__tstate);
16964 if (PyErr_Occurred()) SWIG_fail;
16965 }
16966 {
16967 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16968 }
16969 return resultobj;
16970 fail:
16971 return NULL;
16972 }
16973
16974
16975 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
16976 PyObject *resultobj;
16977 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16978 bool arg2 = (bool) false ;
16979 size_t result;
16980 PyObject * obj0 = 0 ;
16981 PyObject * obj1 = 0 ;
16982 char *kwnames[] = {
16983 (char *) "self",(char *) "recursive", NULL
16984 };
16985
16986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
16987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16988 if (SWIG_arg_fail(1)) SWIG_fail;
16989 if (obj1) {
16990 {
16991 arg2 = (bool)(SWIG_As_bool(obj1));
16992 if (SWIG_arg_fail(2)) SWIG_fail;
16993 }
16994 }
16995 {
16996 PyThreadState* __tstate = wxPyBeginAllowThreads();
16997 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
16998
16999 wxPyEndAllowThreads(__tstate);
17000 if (PyErr_Occurred()) SWIG_fail;
17001 }
17002 {
17003 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17004 }
17005 return resultobj;
17006 fail:
17007 return NULL;
17008 }
17009
17010
17011 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17012 PyObject *resultobj;
17013 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17014 wxString *arg2 = 0 ;
17015 bool result;
17016 bool temp2 = false ;
17017 PyObject * obj0 = 0 ;
17018 PyObject * obj1 = 0 ;
17019 char *kwnames[] = {
17020 (char *) "self",(char *) "name", NULL
17021 };
17022
17023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17025 if (SWIG_arg_fail(1)) SWIG_fail;
17026 {
17027 arg2 = wxString_in_helper(obj1);
17028 if (arg2 == NULL) SWIG_fail;
17029 temp2 = true;
17030 }
17031 {
17032 PyThreadState* __tstate = wxPyBeginAllowThreads();
17033 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17034
17035 wxPyEndAllowThreads(__tstate);
17036 if (PyErr_Occurred()) SWIG_fail;
17037 }
17038 {
17039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17040 }
17041 {
17042 if (temp2)
17043 delete arg2;
17044 }
17045 return resultobj;
17046 fail:
17047 {
17048 if (temp2)
17049 delete arg2;
17050 }
17051 return NULL;
17052 }
17053
17054
17055 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17056 PyObject *resultobj;
17057 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17058 wxString *arg2 = 0 ;
17059 bool result;
17060 bool temp2 = false ;
17061 PyObject * obj0 = 0 ;
17062 PyObject * obj1 = 0 ;
17063 char *kwnames[] = {
17064 (char *) "self",(char *) "name", NULL
17065 };
17066
17067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17069 if (SWIG_arg_fail(1)) SWIG_fail;
17070 {
17071 arg2 = wxString_in_helper(obj1);
17072 if (arg2 == NULL) SWIG_fail;
17073 temp2 = true;
17074 }
17075 {
17076 PyThreadState* __tstate = wxPyBeginAllowThreads();
17077 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17078
17079 wxPyEndAllowThreads(__tstate);
17080 if (PyErr_Occurred()) SWIG_fail;
17081 }
17082 {
17083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17084 }
17085 {
17086 if (temp2)
17087 delete arg2;
17088 }
17089 return resultobj;
17090 fail:
17091 {
17092 if (temp2)
17093 delete arg2;
17094 }
17095 return NULL;
17096 }
17097
17098
17099 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17100 PyObject *resultobj;
17101 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17102 wxString *arg2 = 0 ;
17103 bool result;
17104 bool temp2 = false ;
17105 PyObject * obj0 = 0 ;
17106 PyObject * obj1 = 0 ;
17107 char *kwnames[] = {
17108 (char *) "self",(char *) "name", NULL
17109 };
17110
17111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17113 if (SWIG_arg_fail(1)) SWIG_fail;
17114 {
17115 arg2 = wxString_in_helper(obj1);
17116 if (arg2 == NULL) SWIG_fail;
17117 temp2 = true;
17118 }
17119 {
17120 PyThreadState* __tstate = wxPyBeginAllowThreads();
17121 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17122
17123 wxPyEndAllowThreads(__tstate);
17124 if (PyErr_Occurred()) SWIG_fail;
17125 }
17126 {
17127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17128 }
17129 {
17130 if (temp2)
17131 delete arg2;
17132 }
17133 return resultobj;
17134 fail:
17135 {
17136 if (temp2)
17137 delete arg2;
17138 }
17139 return NULL;
17140 }
17141
17142
17143 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17144 PyObject *resultobj;
17145 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17146 wxString *arg2 = 0 ;
17147 wxConfigBase::EntryType result;
17148 bool temp2 = false ;
17149 PyObject * obj0 = 0 ;
17150 PyObject * obj1 = 0 ;
17151 char *kwnames[] = {
17152 (char *) "self",(char *) "name", NULL
17153 };
17154
17155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17157 if (SWIG_arg_fail(1)) SWIG_fail;
17158 {
17159 arg2 = wxString_in_helper(obj1);
17160 if (arg2 == NULL) SWIG_fail;
17161 temp2 = true;
17162 }
17163 {
17164 PyThreadState* __tstate = wxPyBeginAllowThreads();
17165 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17166
17167 wxPyEndAllowThreads(__tstate);
17168 if (PyErr_Occurred()) SWIG_fail;
17169 }
17170 resultobj = SWIG_From_int((result));
17171 {
17172 if (temp2)
17173 delete arg2;
17174 }
17175 return resultobj;
17176 fail:
17177 {
17178 if (temp2)
17179 delete arg2;
17180 }
17181 return NULL;
17182 }
17183
17184
17185 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17186 PyObject *resultobj;
17187 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17188 wxString *arg2 = 0 ;
17189 wxString const &arg3_defvalue = wxPyEmptyString ;
17190 wxString *arg3 = (wxString *) &arg3_defvalue ;
17191 wxString result;
17192 bool temp2 = false ;
17193 bool temp3 = false ;
17194 PyObject * obj0 = 0 ;
17195 PyObject * obj1 = 0 ;
17196 PyObject * obj2 = 0 ;
17197 char *kwnames[] = {
17198 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17199 };
17200
17201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17203 if (SWIG_arg_fail(1)) SWIG_fail;
17204 {
17205 arg2 = wxString_in_helper(obj1);
17206 if (arg2 == NULL) SWIG_fail;
17207 temp2 = true;
17208 }
17209 if (obj2) {
17210 {
17211 arg3 = wxString_in_helper(obj2);
17212 if (arg3 == NULL) SWIG_fail;
17213 temp3 = true;
17214 }
17215 }
17216 {
17217 PyThreadState* __tstate = wxPyBeginAllowThreads();
17218 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17219
17220 wxPyEndAllowThreads(__tstate);
17221 if (PyErr_Occurred()) SWIG_fail;
17222 }
17223 {
17224 #if wxUSE_UNICODE
17225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17226 #else
17227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17228 #endif
17229 }
17230 {
17231 if (temp2)
17232 delete arg2;
17233 }
17234 {
17235 if (temp3)
17236 delete arg3;
17237 }
17238 return resultobj;
17239 fail:
17240 {
17241 if (temp2)
17242 delete arg2;
17243 }
17244 {
17245 if (temp3)
17246 delete arg3;
17247 }
17248 return NULL;
17249 }
17250
17251
17252 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17253 PyObject *resultobj;
17254 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17255 wxString *arg2 = 0 ;
17256 long arg3 = (long) 0 ;
17257 long result;
17258 bool temp2 = false ;
17259 PyObject * obj0 = 0 ;
17260 PyObject * obj1 = 0 ;
17261 PyObject * obj2 = 0 ;
17262 char *kwnames[] = {
17263 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17264 };
17265
17266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17268 if (SWIG_arg_fail(1)) SWIG_fail;
17269 {
17270 arg2 = wxString_in_helper(obj1);
17271 if (arg2 == NULL) SWIG_fail;
17272 temp2 = true;
17273 }
17274 if (obj2) {
17275 {
17276 arg3 = (long)(SWIG_As_long(obj2));
17277 if (SWIG_arg_fail(3)) SWIG_fail;
17278 }
17279 }
17280 {
17281 PyThreadState* __tstate = wxPyBeginAllowThreads();
17282 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17283
17284 wxPyEndAllowThreads(__tstate);
17285 if (PyErr_Occurred()) SWIG_fail;
17286 }
17287 {
17288 resultobj = SWIG_From_long((long)(result));
17289 }
17290 {
17291 if (temp2)
17292 delete arg2;
17293 }
17294 return resultobj;
17295 fail:
17296 {
17297 if (temp2)
17298 delete arg2;
17299 }
17300 return NULL;
17301 }
17302
17303
17304 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17305 PyObject *resultobj;
17306 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17307 wxString *arg2 = 0 ;
17308 double arg3 = (double) 0.0 ;
17309 double result;
17310 bool temp2 = false ;
17311 PyObject * obj0 = 0 ;
17312 PyObject * obj1 = 0 ;
17313 PyObject * obj2 = 0 ;
17314 char *kwnames[] = {
17315 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17316 };
17317
17318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17320 if (SWIG_arg_fail(1)) SWIG_fail;
17321 {
17322 arg2 = wxString_in_helper(obj1);
17323 if (arg2 == NULL) SWIG_fail;
17324 temp2 = true;
17325 }
17326 if (obj2) {
17327 {
17328 arg3 = (double)(SWIG_As_double(obj2));
17329 if (SWIG_arg_fail(3)) SWIG_fail;
17330 }
17331 }
17332 {
17333 PyThreadState* __tstate = wxPyBeginAllowThreads();
17334 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17335
17336 wxPyEndAllowThreads(__tstate);
17337 if (PyErr_Occurred()) SWIG_fail;
17338 }
17339 {
17340 resultobj = SWIG_From_double((double)(result));
17341 }
17342 {
17343 if (temp2)
17344 delete arg2;
17345 }
17346 return resultobj;
17347 fail:
17348 {
17349 if (temp2)
17350 delete arg2;
17351 }
17352 return NULL;
17353 }
17354
17355
17356 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17357 PyObject *resultobj;
17358 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17359 wxString *arg2 = 0 ;
17360 bool arg3 = (bool) false ;
17361 bool result;
17362 bool temp2 = false ;
17363 PyObject * obj0 = 0 ;
17364 PyObject * obj1 = 0 ;
17365 PyObject * obj2 = 0 ;
17366 char *kwnames[] = {
17367 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17368 };
17369
17370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17372 if (SWIG_arg_fail(1)) SWIG_fail;
17373 {
17374 arg2 = wxString_in_helper(obj1);
17375 if (arg2 == NULL) SWIG_fail;
17376 temp2 = true;
17377 }
17378 if (obj2) {
17379 {
17380 arg3 = (bool)(SWIG_As_bool(obj2));
17381 if (SWIG_arg_fail(3)) SWIG_fail;
17382 }
17383 }
17384 {
17385 PyThreadState* __tstate = wxPyBeginAllowThreads();
17386 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17387
17388 wxPyEndAllowThreads(__tstate);
17389 if (PyErr_Occurred()) SWIG_fail;
17390 }
17391 {
17392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17393 }
17394 {
17395 if (temp2)
17396 delete arg2;
17397 }
17398 return resultobj;
17399 fail:
17400 {
17401 if (temp2)
17402 delete arg2;
17403 }
17404 return NULL;
17405 }
17406
17407
17408 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17409 PyObject *resultobj;
17410 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17411 wxString *arg2 = 0 ;
17412 wxString *arg3 = 0 ;
17413 bool result;
17414 bool temp2 = false ;
17415 bool temp3 = false ;
17416 PyObject * obj0 = 0 ;
17417 PyObject * obj1 = 0 ;
17418 PyObject * obj2 = 0 ;
17419 char *kwnames[] = {
17420 (char *) "self",(char *) "key",(char *) "value", NULL
17421 };
17422
17423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17425 if (SWIG_arg_fail(1)) SWIG_fail;
17426 {
17427 arg2 = wxString_in_helper(obj1);
17428 if (arg2 == NULL) SWIG_fail;
17429 temp2 = true;
17430 }
17431 {
17432 arg3 = wxString_in_helper(obj2);
17433 if (arg3 == NULL) SWIG_fail;
17434 temp3 = true;
17435 }
17436 {
17437 PyThreadState* __tstate = wxPyBeginAllowThreads();
17438 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17439
17440 wxPyEndAllowThreads(__tstate);
17441 if (PyErr_Occurred()) SWIG_fail;
17442 }
17443 {
17444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17445 }
17446 {
17447 if (temp2)
17448 delete arg2;
17449 }
17450 {
17451 if (temp3)
17452 delete arg3;
17453 }
17454 return resultobj;
17455 fail:
17456 {
17457 if (temp2)
17458 delete arg2;
17459 }
17460 {
17461 if (temp3)
17462 delete arg3;
17463 }
17464 return NULL;
17465 }
17466
17467
17468 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17469 PyObject *resultobj;
17470 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17471 wxString *arg2 = 0 ;
17472 long arg3 ;
17473 bool result;
17474 bool temp2 = false ;
17475 PyObject * obj0 = 0 ;
17476 PyObject * obj1 = 0 ;
17477 PyObject * obj2 = 0 ;
17478 char *kwnames[] = {
17479 (char *) "self",(char *) "key",(char *) "value", NULL
17480 };
17481
17482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17484 if (SWIG_arg_fail(1)) SWIG_fail;
17485 {
17486 arg2 = wxString_in_helper(obj1);
17487 if (arg2 == NULL) SWIG_fail;
17488 temp2 = true;
17489 }
17490 {
17491 arg3 = (long)(SWIG_As_long(obj2));
17492 if (SWIG_arg_fail(3)) SWIG_fail;
17493 }
17494 {
17495 PyThreadState* __tstate = wxPyBeginAllowThreads();
17496 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17497
17498 wxPyEndAllowThreads(__tstate);
17499 if (PyErr_Occurred()) SWIG_fail;
17500 }
17501 {
17502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17503 }
17504 {
17505 if (temp2)
17506 delete arg2;
17507 }
17508 return resultobj;
17509 fail:
17510 {
17511 if (temp2)
17512 delete arg2;
17513 }
17514 return NULL;
17515 }
17516
17517
17518 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17519 PyObject *resultobj;
17520 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17521 wxString *arg2 = 0 ;
17522 double arg3 ;
17523 bool result;
17524 bool temp2 = false ;
17525 PyObject * obj0 = 0 ;
17526 PyObject * obj1 = 0 ;
17527 PyObject * obj2 = 0 ;
17528 char *kwnames[] = {
17529 (char *) "self",(char *) "key",(char *) "value", NULL
17530 };
17531
17532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17534 if (SWIG_arg_fail(1)) SWIG_fail;
17535 {
17536 arg2 = wxString_in_helper(obj1);
17537 if (arg2 == NULL) SWIG_fail;
17538 temp2 = true;
17539 }
17540 {
17541 arg3 = (double)(SWIG_As_double(obj2));
17542 if (SWIG_arg_fail(3)) SWIG_fail;
17543 }
17544 {
17545 PyThreadState* __tstate = wxPyBeginAllowThreads();
17546 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17547
17548 wxPyEndAllowThreads(__tstate);
17549 if (PyErr_Occurred()) SWIG_fail;
17550 }
17551 {
17552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17553 }
17554 {
17555 if (temp2)
17556 delete arg2;
17557 }
17558 return resultobj;
17559 fail:
17560 {
17561 if (temp2)
17562 delete arg2;
17563 }
17564 return NULL;
17565 }
17566
17567
17568 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17569 PyObject *resultobj;
17570 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17571 wxString *arg2 = 0 ;
17572 bool arg3 ;
17573 bool result;
17574 bool temp2 = false ;
17575 PyObject * obj0 = 0 ;
17576 PyObject * obj1 = 0 ;
17577 PyObject * obj2 = 0 ;
17578 char *kwnames[] = {
17579 (char *) "self",(char *) "key",(char *) "value", NULL
17580 };
17581
17582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17584 if (SWIG_arg_fail(1)) SWIG_fail;
17585 {
17586 arg2 = wxString_in_helper(obj1);
17587 if (arg2 == NULL) SWIG_fail;
17588 temp2 = true;
17589 }
17590 {
17591 arg3 = (bool)(SWIG_As_bool(obj2));
17592 if (SWIG_arg_fail(3)) SWIG_fail;
17593 }
17594 {
17595 PyThreadState* __tstate = wxPyBeginAllowThreads();
17596 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17597
17598 wxPyEndAllowThreads(__tstate);
17599 if (PyErr_Occurred()) SWIG_fail;
17600 }
17601 {
17602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17603 }
17604 {
17605 if (temp2)
17606 delete arg2;
17607 }
17608 return resultobj;
17609 fail:
17610 {
17611 if (temp2)
17612 delete arg2;
17613 }
17614 return NULL;
17615 }
17616
17617
17618 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17619 PyObject *resultobj;
17620 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17621 bool arg2 = (bool) false ;
17622 bool result;
17623 PyObject * obj0 = 0 ;
17624 PyObject * obj1 = 0 ;
17625 char *kwnames[] = {
17626 (char *) "self",(char *) "currentOnly", NULL
17627 };
17628
17629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17631 if (SWIG_arg_fail(1)) SWIG_fail;
17632 if (obj1) {
17633 {
17634 arg2 = (bool)(SWIG_As_bool(obj1));
17635 if (SWIG_arg_fail(2)) SWIG_fail;
17636 }
17637 }
17638 {
17639 PyThreadState* __tstate = wxPyBeginAllowThreads();
17640 result = (bool)(arg1)->Flush(arg2);
17641
17642 wxPyEndAllowThreads(__tstate);
17643 if (PyErr_Occurred()) SWIG_fail;
17644 }
17645 {
17646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17647 }
17648 return resultobj;
17649 fail:
17650 return NULL;
17651 }
17652
17653
17654 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17655 PyObject *resultobj;
17656 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17657 wxString *arg2 = 0 ;
17658 wxString *arg3 = 0 ;
17659 bool result;
17660 bool temp2 = false ;
17661 bool temp3 = false ;
17662 PyObject * obj0 = 0 ;
17663 PyObject * obj1 = 0 ;
17664 PyObject * obj2 = 0 ;
17665 char *kwnames[] = {
17666 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17667 };
17668
17669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17671 if (SWIG_arg_fail(1)) SWIG_fail;
17672 {
17673 arg2 = wxString_in_helper(obj1);
17674 if (arg2 == NULL) SWIG_fail;
17675 temp2 = true;
17676 }
17677 {
17678 arg3 = wxString_in_helper(obj2);
17679 if (arg3 == NULL) SWIG_fail;
17680 temp3 = true;
17681 }
17682 {
17683 PyThreadState* __tstate = wxPyBeginAllowThreads();
17684 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17685
17686 wxPyEndAllowThreads(__tstate);
17687 if (PyErr_Occurred()) SWIG_fail;
17688 }
17689 {
17690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17691 }
17692 {
17693 if (temp2)
17694 delete arg2;
17695 }
17696 {
17697 if (temp3)
17698 delete arg3;
17699 }
17700 return resultobj;
17701 fail:
17702 {
17703 if (temp2)
17704 delete arg2;
17705 }
17706 {
17707 if (temp3)
17708 delete arg3;
17709 }
17710 return NULL;
17711 }
17712
17713
17714 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17715 PyObject *resultobj;
17716 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17717 wxString *arg2 = 0 ;
17718 wxString *arg3 = 0 ;
17719 bool result;
17720 bool temp2 = false ;
17721 bool temp3 = false ;
17722 PyObject * obj0 = 0 ;
17723 PyObject * obj1 = 0 ;
17724 PyObject * obj2 = 0 ;
17725 char *kwnames[] = {
17726 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17727 };
17728
17729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17731 if (SWIG_arg_fail(1)) SWIG_fail;
17732 {
17733 arg2 = wxString_in_helper(obj1);
17734 if (arg2 == NULL) SWIG_fail;
17735 temp2 = true;
17736 }
17737 {
17738 arg3 = wxString_in_helper(obj2);
17739 if (arg3 == NULL) SWIG_fail;
17740 temp3 = true;
17741 }
17742 {
17743 PyThreadState* __tstate = wxPyBeginAllowThreads();
17744 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17745
17746 wxPyEndAllowThreads(__tstate);
17747 if (PyErr_Occurred()) SWIG_fail;
17748 }
17749 {
17750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17751 }
17752 {
17753 if (temp2)
17754 delete arg2;
17755 }
17756 {
17757 if (temp3)
17758 delete arg3;
17759 }
17760 return resultobj;
17761 fail:
17762 {
17763 if (temp2)
17764 delete arg2;
17765 }
17766 {
17767 if (temp3)
17768 delete arg3;
17769 }
17770 return NULL;
17771 }
17772
17773
17774 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17775 PyObject *resultobj;
17776 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17777 wxString *arg2 = 0 ;
17778 bool arg3 = (bool) true ;
17779 bool result;
17780 bool temp2 = false ;
17781 PyObject * obj0 = 0 ;
17782 PyObject * obj1 = 0 ;
17783 PyObject * obj2 = 0 ;
17784 char *kwnames[] = {
17785 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17786 };
17787
17788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17790 if (SWIG_arg_fail(1)) SWIG_fail;
17791 {
17792 arg2 = wxString_in_helper(obj1);
17793 if (arg2 == NULL) SWIG_fail;
17794 temp2 = true;
17795 }
17796 if (obj2) {
17797 {
17798 arg3 = (bool)(SWIG_As_bool(obj2));
17799 if (SWIG_arg_fail(3)) SWIG_fail;
17800 }
17801 }
17802 {
17803 PyThreadState* __tstate = wxPyBeginAllowThreads();
17804 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17805
17806 wxPyEndAllowThreads(__tstate);
17807 if (PyErr_Occurred()) SWIG_fail;
17808 }
17809 {
17810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17811 }
17812 {
17813 if (temp2)
17814 delete arg2;
17815 }
17816 return resultobj;
17817 fail:
17818 {
17819 if (temp2)
17820 delete arg2;
17821 }
17822 return NULL;
17823 }
17824
17825
17826 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17827 PyObject *resultobj;
17828 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17829 wxString *arg2 = 0 ;
17830 bool result;
17831 bool temp2 = false ;
17832 PyObject * obj0 = 0 ;
17833 PyObject * obj1 = 0 ;
17834 char *kwnames[] = {
17835 (char *) "self",(char *) "key", NULL
17836 };
17837
17838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17840 if (SWIG_arg_fail(1)) SWIG_fail;
17841 {
17842 arg2 = wxString_in_helper(obj1);
17843 if (arg2 == NULL) SWIG_fail;
17844 temp2 = true;
17845 }
17846 {
17847 PyThreadState* __tstate = wxPyBeginAllowThreads();
17848 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17849
17850 wxPyEndAllowThreads(__tstate);
17851 if (PyErr_Occurred()) SWIG_fail;
17852 }
17853 {
17854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17855 }
17856 {
17857 if (temp2)
17858 delete arg2;
17859 }
17860 return resultobj;
17861 fail:
17862 {
17863 if (temp2)
17864 delete arg2;
17865 }
17866 return NULL;
17867 }
17868
17869
17870 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
17871 PyObject *resultobj;
17872 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17873 bool result;
17874 PyObject * obj0 = 0 ;
17875 char *kwnames[] = {
17876 (char *) "self", NULL
17877 };
17878
17879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
17880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17881 if (SWIG_arg_fail(1)) SWIG_fail;
17882 {
17883 PyThreadState* __tstate = wxPyBeginAllowThreads();
17884 result = (bool)(arg1)->DeleteAll();
17885
17886 wxPyEndAllowThreads(__tstate);
17887 if (PyErr_Occurred()) SWIG_fail;
17888 }
17889 {
17890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17891 }
17892 return resultobj;
17893 fail:
17894 return NULL;
17895 }
17896
17897
17898 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17899 PyObject *resultobj;
17900 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17901 bool arg2 = (bool) true ;
17902 PyObject * obj0 = 0 ;
17903 PyObject * obj1 = 0 ;
17904 char *kwnames[] = {
17905 (char *) "self",(char *) "doIt", NULL
17906 };
17907
17908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
17909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17910 if (SWIG_arg_fail(1)) SWIG_fail;
17911 if (obj1) {
17912 {
17913 arg2 = (bool)(SWIG_As_bool(obj1));
17914 if (SWIG_arg_fail(2)) SWIG_fail;
17915 }
17916 }
17917 {
17918 PyThreadState* __tstate = wxPyBeginAllowThreads();
17919 (arg1)->SetExpandEnvVars(arg2);
17920
17921 wxPyEndAllowThreads(__tstate);
17922 if (PyErr_Occurred()) SWIG_fail;
17923 }
17924 Py_INCREF(Py_None); resultobj = Py_None;
17925 return resultobj;
17926 fail:
17927 return NULL;
17928 }
17929
17930
17931 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17932 PyObject *resultobj;
17933 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17934 bool result;
17935 PyObject * obj0 = 0 ;
17936 char *kwnames[] = {
17937 (char *) "self", NULL
17938 };
17939
17940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
17941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17942 if (SWIG_arg_fail(1)) SWIG_fail;
17943 {
17944 PyThreadState* __tstate = wxPyBeginAllowThreads();
17945 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
17946
17947 wxPyEndAllowThreads(__tstate);
17948 if (PyErr_Occurred()) SWIG_fail;
17949 }
17950 {
17951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17952 }
17953 return resultobj;
17954 fail:
17955 return NULL;
17956 }
17957
17958
17959 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17960 PyObject *resultobj;
17961 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17962 bool arg2 = (bool) true ;
17963 PyObject * obj0 = 0 ;
17964 PyObject * obj1 = 0 ;
17965 char *kwnames[] = {
17966 (char *) "self",(char *) "doIt", NULL
17967 };
17968
17969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
17970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17971 if (SWIG_arg_fail(1)) SWIG_fail;
17972 if (obj1) {
17973 {
17974 arg2 = (bool)(SWIG_As_bool(obj1));
17975 if (SWIG_arg_fail(2)) SWIG_fail;
17976 }
17977 }
17978 {
17979 PyThreadState* __tstate = wxPyBeginAllowThreads();
17980 (arg1)->SetRecordDefaults(arg2);
17981
17982 wxPyEndAllowThreads(__tstate);
17983 if (PyErr_Occurred()) SWIG_fail;
17984 }
17985 Py_INCREF(Py_None); resultobj = Py_None;
17986 return resultobj;
17987 fail:
17988 return NULL;
17989 }
17990
17991
17992 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17993 PyObject *resultobj;
17994 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17995 bool result;
17996 PyObject * obj0 = 0 ;
17997 char *kwnames[] = {
17998 (char *) "self", NULL
17999 };
18000
18001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18003 if (SWIG_arg_fail(1)) SWIG_fail;
18004 {
18005 PyThreadState* __tstate = wxPyBeginAllowThreads();
18006 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18007
18008 wxPyEndAllowThreads(__tstate);
18009 if (PyErr_Occurred()) SWIG_fail;
18010 }
18011 {
18012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18013 }
18014 return resultobj;
18015 fail:
18016 return NULL;
18017 }
18018
18019
18020 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18021 PyObject *resultobj;
18022 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18023 wxString *arg2 = 0 ;
18024 wxString result;
18025 bool temp2 = false ;
18026 PyObject * obj0 = 0 ;
18027 PyObject * obj1 = 0 ;
18028 char *kwnames[] = {
18029 (char *) "self",(char *) "str", NULL
18030 };
18031
18032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18034 if (SWIG_arg_fail(1)) SWIG_fail;
18035 {
18036 arg2 = wxString_in_helper(obj1);
18037 if (arg2 == NULL) SWIG_fail;
18038 temp2 = true;
18039 }
18040 {
18041 PyThreadState* __tstate = wxPyBeginAllowThreads();
18042 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18043
18044 wxPyEndAllowThreads(__tstate);
18045 if (PyErr_Occurred()) SWIG_fail;
18046 }
18047 {
18048 #if wxUSE_UNICODE
18049 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18050 #else
18051 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18052 #endif
18053 }
18054 {
18055 if (temp2)
18056 delete arg2;
18057 }
18058 return resultobj;
18059 fail:
18060 {
18061 if (temp2)
18062 delete arg2;
18063 }
18064 return NULL;
18065 }
18066
18067
18068 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18069 PyObject *resultobj;
18070 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18071 wxString result;
18072 PyObject * obj0 = 0 ;
18073 char *kwnames[] = {
18074 (char *) "self", NULL
18075 };
18076
18077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18079 if (SWIG_arg_fail(1)) SWIG_fail;
18080 {
18081 PyThreadState* __tstate = wxPyBeginAllowThreads();
18082 result = ((wxConfigBase const *)arg1)->GetAppName();
18083
18084 wxPyEndAllowThreads(__tstate);
18085 if (PyErr_Occurred()) SWIG_fail;
18086 }
18087 {
18088 #if wxUSE_UNICODE
18089 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18090 #else
18091 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18092 #endif
18093 }
18094 return resultobj;
18095 fail:
18096 return NULL;
18097 }
18098
18099
18100 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18101 PyObject *resultobj;
18102 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18103 wxString result;
18104 PyObject * obj0 = 0 ;
18105 char *kwnames[] = {
18106 (char *) "self", NULL
18107 };
18108
18109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18111 if (SWIG_arg_fail(1)) SWIG_fail;
18112 {
18113 PyThreadState* __tstate = wxPyBeginAllowThreads();
18114 result = ((wxConfigBase const *)arg1)->GetVendorName();
18115
18116 wxPyEndAllowThreads(__tstate);
18117 if (PyErr_Occurred()) SWIG_fail;
18118 }
18119 {
18120 #if wxUSE_UNICODE
18121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18122 #else
18123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18124 #endif
18125 }
18126 return resultobj;
18127 fail:
18128 return NULL;
18129 }
18130
18131
18132 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18133 PyObject *resultobj;
18134 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18135 wxString *arg2 = 0 ;
18136 bool temp2 = false ;
18137 PyObject * obj0 = 0 ;
18138 PyObject * obj1 = 0 ;
18139 char *kwnames[] = {
18140 (char *) "self",(char *) "appName", NULL
18141 };
18142
18143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18145 if (SWIG_arg_fail(1)) SWIG_fail;
18146 {
18147 arg2 = wxString_in_helper(obj1);
18148 if (arg2 == NULL) SWIG_fail;
18149 temp2 = true;
18150 }
18151 {
18152 PyThreadState* __tstate = wxPyBeginAllowThreads();
18153 (arg1)->SetAppName((wxString const &)*arg2);
18154
18155 wxPyEndAllowThreads(__tstate);
18156 if (PyErr_Occurred()) SWIG_fail;
18157 }
18158 Py_INCREF(Py_None); resultobj = Py_None;
18159 {
18160 if (temp2)
18161 delete arg2;
18162 }
18163 return resultobj;
18164 fail:
18165 {
18166 if (temp2)
18167 delete arg2;
18168 }
18169 return NULL;
18170 }
18171
18172
18173 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18174 PyObject *resultobj;
18175 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18176 wxString *arg2 = 0 ;
18177 bool temp2 = false ;
18178 PyObject * obj0 = 0 ;
18179 PyObject * obj1 = 0 ;
18180 char *kwnames[] = {
18181 (char *) "self",(char *) "vendorName", NULL
18182 };
18183
18184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18186 if (SWIG_arg_fail(1)) SWIG_fail;
18187 {
18188 arg2 = wxString_in_helper(obj1);
18189 if (arg2 == NULL) SWIG_fail;
18190 temp2 = true;
18191 }
18192 {
18193 PyThreadState* __tstate = wxPyBeginAllowThreads();
18194 (arg1)->SetVendorName((wxString const &)*arg2);
18195
18196 wxPyEndAllowThreads(__tstate);
18197 if (PyErr_Occurred()) SWIG_fail;
18198 }
18199 Py_INCREF(Py_None); resultobj = Py_None;
18200 {
18201 if (temp2)
18202 delete arg2;
18203 }
18204 return resultobj;
18205 fail:
18206 {
18207 if (temp2)
18208 delete arg2;
18209 }
18210 return NULL;
18211 }
18212
18213
18214 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18215 PyObject *resultobj;
18216 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18217 long arg2 ;
18218 PyObject * obj0 = 0 ;
18219 PyObject * obj1 = 0 ;
18220 char *kwnames[] = {
18221 (char *) "self",(char *) "style", NULL
18222 };
18223
18224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18226 if (SWIG_arg_fail(1)) SWIG_fail;
18227 {
18228 arg2 = (long)(SWIG_As_long(obj1));
18229 if (SWIG_arg_fail(2)) SWIG_fail;
18230 }
18231 {
18232 PyThreadState* __tstate = wxPyBeginAllowThreads();
18233 (arg1)->SetStyle(arg2);
18234
18235 wxPyEndAllowThreads(__tstate);
18236 if (PyErr_Occurred()) SWIG_fail;
18237 }
18238 Py_INCREF(Py_None); resultobj = Py_None;
18239 return resultobj;
18240 fail:
18241 return NULL;
18242 }
18243
18244
18245 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18246 PyObject *resultobj;
18247 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18248 long result;
18249 PyObject * obj0 = 0 ;
18250 char *kwnames[] = {
18251 (char *) "self", NULL
18252 };
18253
18254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18256 if (SWIG_arg_fail(1)) SWIG_fail;
18257 {
18258 PyThreadState* __tstate = wxPyBeginAllowThreads();
18259 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18260
18261 wxPyEndAllowThreads(__tstate);
18262 if (PyErr_Occurred()) SWIG_fail;
18263 }
18264 {
18265 resultobj = SWIG_From_long((long)(result));
18266 }
18267 return resultobj;
18268 fail:
18269 return NULL;
18270 }
18271
18272
18273 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18274 PyObject *obj;
18275 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18276 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18277 Py_INCREF(obj);
18278 return Py_BuildValue((char *)"");
18279 }
18280 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18281 PyObject *resultobj;
18282 wxString const &arg1_defvalue = wxPyEmptyString ;
18283 wxString *arg1 = (wxString *) &arg1_defvalue ;
18284 wxString const &arg2_defvalue = wxPyEmptyString ;
18285 wxString *arg2 = (wxString *) &arg2_defvalue ;
18286 wxString const &arg3_defvalue = wxPyEmptyString ;
18287 wxString *arg3 = (wxString *) &arg3_defvalue ;
18288 wxString const &arg4_defvalue = wxPyEmptyString ;
18289 wxString *arg4 = (wxString *) &arg4_defvalue ;
18290 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18291 wxConfig *result;
18292 bool temp1 = false ;
18293 bool temp2 = false ;
18294 bool temp3 = false ;
18295 bool temp4 = false ;
18296 PyObject * obj0 = 0 ;
18297 PyObject * obj1 = 0 ;
18298 PyObject * obj2 = 0 ;
18299 PyObject * obj3 = 0 ;
18300 PyObject * obj4 = 0 ;
18301 char *kwnames[] = {
18302 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18303 };
18304
18305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18306 if (obj0) {
18307 {
18308 arg1 = wxString_in_helper(obj0);
18309 if (arg1 == NULL) SWIG_fail;
18310 temp1 = true;
18311 }
18312 }
18313 if (obj1) {
18314 {
18315 arg2 = wxString_in_helper(obj1);
18316 if (arg2 == NULL) SWIG_fail;
18317 temp2 = true;
18318 }
18319 }
18320 if (obj2) {
18321 {
18322 arg3 = wxString_in_helper(obj2);
18323 if (arg3 == NULL) SWIG_fail;
18324 temp3 = true;
18325 }
18326 }
18327 if (obj3) {
18328 {
18329 arg4 = wxString_in_helper(obj3);
18330 if (arg4 == NULL) SWIG_fail;
18331 temp4 = true;
18332 }
18333 }
18334 if (obj4) {
18335 {
18336 arg5 = (long)(SWIG_As_long(obj4));
18337 if (SWIG_arg_fail(5)) SWIG_fail;
18338 }
18339 }
18340 {
18341 PyThreadState* __tstate = wxPyBeginAllowThreads();
18342 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18343
18344 wxPyEndAllowThreads(__tstate);
18345 if (PyErr_Occurred()) SWIG_fail;
18346 }
18347 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18348 {
18349 if (temp1)
18350 delete arg1;
18351 }
18352 {
18353 if (temp2)
18354 delete arg2;
18355 }
18356 {
18357 if (temp3)
18358 delete arg3;
18359 }
18360 {
18361 if (temp4)
18362 delete arg4;
18363 }
18364 return resultobj;
18365 fail:
18366 {
18367 if (temp1)
18368 delete arg1;
18369 }
18370 {
18371 if (temp2)
18372 delete arg2;
18373 }
18374 {
18375 if (temp3)
18376 delete arg3;
18377 }
18378 {
18379 if (temp4)
18380 delete arg4;
18381 }
18382 return NULL;
18383 }
18384
18385
18386 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18387 PyObject *resultobj;
18388 wxConfig *arg1 = (wxConfig *) 0 ;
18389 PyObject * obj0 = 0 ;
18390 char *kwnames[] = {
18391 (char *) "self", NULL
18392 };
18393
18394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18396 if (SWIG_arg_fail(1)) SWIG_fail;
18397 {
18398 PyThreadState* __tstate = wxPyBeginAllowThreads();
18399 delete arg1;
18400
18401 wxPyEndAllowThreads(__tstate);
18402 if (PyErr_Occurred()) SWIG_fail;
18403 }
18404 Py_INCREF(Py_None); resultobj = Py_None;
18405 return resultobj;
18406 fail:
18407 return NULL;
18408 }
18409
18410
18411 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18412 PyObject *obj;
18413 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18414 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18415 Py_INCREF(obj);
18416 return Py_BuildValue((char *)"");
18417 }
18418 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18419 PyObject *resultobj;
18420 wxString const &arg1_defvalue = wxPyEmptyString ;
18421 wxString *arg1 = (wxString *) &arg1_defvalue ;
18422 wxString const &arg2_defvalue = wxPyEmptyString ;
18423 wxString *arg2 = (wxString *) &arg2_defvalue ;
18424 wxString const &arg3_defvalue = wxPyEmptyString ;
18425 wxString *arg3 = (wxString *) &arg3_defvalue ;
18426 wxString const &arg4_defvalue = wxPyEmptyString ;
18427 wxString *arg4 = (wxString *) &arg4_defvalue ;
18428 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18429 wxFileConfig *result;
18430 bool temp1 = false ;
18431 bool temp2 = false ;
18432 bool temp3 = false ;
18433 bool temp4 = false ;
18434 PyObject * obj0 = 0 ;
18435 PyObject * obj1 = 0 ;
18436 PyObject * obj2 = 0 ;
18437 PyObject * obj3 = 0 ;
18438 PyObject * obj4 = 0 ;
18439 char *kwnames[] = {
18440 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18441 };
18442
18443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18444 if (obj0) {
18445 {
18446 arg1 = wxString_in_helper(obj0);
18447 if (arg1 == NULL) SWIG_fail;
18448 temp1 = true;
18449 }
18450 }
18451 if (obj1) {
18452 {
18453 arg2 = wxString_in_helper(obj1);
18454 if (arg2 == NULL) SWIG_fail;
18455 temp2 = true;
18456 }
18457 }
18458 if (obj2) {
18459 {
18460 arg3 = wxString_in_helper(obj2);
18461 if (arg3 == NULL) SWIG_fail;
18462 temp3 = true;
18463 }
18464 }
18465 if (obj3) {
18466 {
18467 arg4 = wxString_in_helper(obj3);
18468 if (arg4 == NULL) SWIG_fail;
18469 temp4 = true;
18470 }
18471 }
18472 if (obj4) {
18473 {
18474 arg5 = (long)(SWIG_As_long(obj4));
18475 if (SWIG_arg_fail(5)) SWIG_fail;
18476 }
18477 }
18478 {
18479 PyThreadState* __tstate = wxPyBeginAllowThreads();
18480 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18481
18482 wxPyEndAllowThreads(__tstate);
18483 if (PyErr_Occurred()) SWIG_fail;
18484 }
18485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18486 {
18487 if (temp1)
18488 delete arg1;
18489 }
18490 {
18491 if (temp2)
18492 delete arg2;
18493 }
18494 {
18495 if (temp3)
18496 delete arg3;
18497 }
18498 {
18499 if (temp4)
18500 delete arg4;
18501 }
18502 return resultobj;
18503 fail:
18504 {
18505 if (temp1)
18506 delete arg1;
18507 }
18508 {
18509 if (temp2)
18510 delete arg2;
18511 }
18512 {
18513 if (temp3)
18514 delete arg3;
18515 }
18516 {
18517 if (temp4)
18518 delete arg4;
18519 }
18520 return NULL;
18521 }
18522
18523
18524 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18525 PyObject *resultobj;
18526 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18527 PyObject * obj0 = 0 ;
18528 char *kwnames[] = {
18529 (char *) "self", NULL
18530 };
18531
18532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18534 if (SWIG_arg_fail(1)) SWIG_fail;
18535 {
18536 PyThreadState* __tstate = wxPyBeginAllowThreads();
18537 delete arg1;
18538
18539 wxPyEndAllowThreads(__tstate);
18540 if (PyErr_Occurred()) SWIG_fail;
18541 }
18542 Py_INCREF(Py_None); resultobj = Py_None;
18543 return resultobj;
18544 fail:
18545 return NULL;
18546 }
18547
18548
18549 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18550 PyObject *obj;
18551 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18552 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18553 Py_INCREF(obj);
18554 return Py_BuildValue((char *)"");
18555 }
18556 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18557 PyObject *resultobj;
18558 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18559 wxString *arg2 = 0 ;
18560 wxConfigPathChanger *result;
18561 bool temp2 = false ;
18562 PyObject * obj0 = 0 ;
18563 PyObject * obj1 = 0 ;
18564 char *kwnames[] = {
18565 (char *) "config",(char *) "entry", NULL
18566 };
18567
18568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18570 if (SWIG_arg_fail(1)) SWIG_fail;
18571 {
18572 arg2 = wxString_in_helper(obj1);
18573 if (arg2 == NULL) SWIG_fail;
18574 temp2 = true;
18575 }
18576 {
18577 PyThreadState* __tstate = wxPyBeginAllowThreads();
18578 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18579
18580 wxPyEndAllowThreads(__tstate);
18581 if (PyErr_Occurred()) SWIG_fail;
18582 }
18583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18584 {
18585 if (temp2)
18586 delete arg2;
18587 }
18588 return resultobj;
18589 fail:
18590 {
18591 if (temp2)
18592 delete arg2;
18593 }
18594 return NULL;
18595 }
18596
18597
18598 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18599 PyObject *resultobj;
18600 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18601 PyObject * obj0 = 0 ;
18602 char *kwnames[] = {
18603 (char *) "self", NULL
18604 };
18605
18606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18608 if (SWIG_arg_fail(1)) SWIG_fail;
18609 {
18610 PyThreadState* __tstate = wxPyBeginAllowThreads();
18611 delete arg1;
18612
18613 wxPyEndAllowThreads(__tstate);
18614 if (PyErr_Occurred()) SWIG_fail;
18615 }
18616 Py_INCREF(Py_None); resultobj = Py_None;
18617 return resultobj;
18618 fail:
18619 return NULL;
18620 }
18621
18622
18623 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18624 PyObject *resultobj;
18625 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18626 wxString *result;
18627 PyObject * obj0 = 0 ;
18628 char *kwnames[] = {
18629 (char *) "self", NULL
18630 };
18631
18632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18634 if (SWIG_arg_fail(1)) SWIG_fail;
18635 {
18636 PyThreadState* __tstate = wxPyBeginAllowThreads();
18637 {
18638 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18639 result = (wxString *) &_result_ref;
18640 }
18641
18642 wxPyEndAllowThreads(__tstate);
18643 if (PyErr_Occurred()) SWIG_fail;
18644 }
18645 {
18646 #if wxUSE_UNICODE
18647 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18648 #else
18649 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18650 #endif
18651 }
18652 return resultobj;
18653 fail:
18654 return NULL;
18655 }
18656
18657
18658 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18659 PyObject *obj;
18660 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18661 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18662 Py_INCREF(obj);
18663 return Py_BuildValue((char *)"");
18664 }
18665 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18666 PyObject *resultobj;
18667 wxString *arg1 = 0 ;
18668 wxString result;
18669 bool temp1 = false ;
18670 PyObject * obj0 = 0 ;
18671 char *kwnames[] = {
18672 (char *) "sz", NULL
18673 };
18674
18675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18676 {
18677 arg1 = wxString_in_helper(obj0);
18678 if (arg1 == NULL) SWIG_fail;
18679 temp1 = true;
18680 }
18681 {
18682 PyThreadState* __tstate = wxPyBeginAllowThreads();
18683 result = wxExpandEnvVars((wxString const &)*arg1);
18684
18685 wxPyEndAllowThreads(__tstate);
18686 if (PyErr_Occurred()) SWIG_fail;
18687 }
18688 {
18689 #if wxUSE_UNICODE
18690 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18691 #else
18692 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18693 #endif
18694 }
18695 {
18696 if (temp1)
18697 delete arg1;
18698 }
18699 return resultobj;
18700 fail:
18701 {
18702 if (temp1)
18703 delete arg1;
18704 }
18705 return NULL;
18706 }
18707
18708
18709 static int _wrap_DateFormatStr_set(PyObject *) {
18710 PyErr_SetString(PyExc_TypeError,"Variable DateFormatStr is read-only.");
18711 return 1;
18712 }
18713
18714
18715 static PyObject *_wrap_DateFormatStr_get(void) {
18716 PyObject *pyobj;
18717
18718 {
18719 #if wxUSE_UNICODE
18720 pyobj = PyUnicode_FromWideChar((&wxPyDateFormatStr)->c_str(), (&wxPyDateFormatStr)->Len());
18721 #else
18722 pyobj = PyString_FromStringAndSize((&wxPyDateFormatStr)->c_str(), (&wxPyDateFormatStr)->Len());
18723 #endif
18724 }
18725 return pyobj;
18726 }
18727
18728
18729 static int _wrap_TimeSpanFormatStr_set(PyObject *) {
18730 PyErr_SetString(PyExc_TypeError,"Variable TimeSpanFormatStr is read-only.");
18731 return 1;
18732 }
18733
18734
18735 static PyObject *_wrap_TimeSpanFormatStr_get(void) {
18736 PyObject *pyobj;
18737
18738 {
18739 #if wxUSE_UNICODE
18740 pyobj = PyUnicode_FromWideChar((&wxPyTimeSpanFormatStr)->c_str(), (&wxPyTimeSpanFormatStr)->Len());
18741 #else
18742 pyobj = PyString_FromStringAndSize((&wxPyTimeSpanFormatStr)->c_str(), (&wxPyTimeSpanFormatStr)->Len());
18743 #endif
18744 }
18745 return pyobj;
18746 }
18747
18748
18749 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18750 PyObject *resultobj;
18751 wxDateTime::Country arg1 ;
18752 PyObject * obj0 = 0 ;
18753 char *kwnames[] = {
18754 (char *) "country", NULL
18755 };
18756
18757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18758 {
18759 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18760 if (SWIG_arg_fail(1)) SWIG_fail;
18761 }
18762 {
18763 PyThreadState* __tstate = wxPyBeginAllowThreads();
18764 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18765
18766 wxPyEndAllowThreads(__tstate);
18767 if (PyErr_Occurred()) SWIG_fail;
18768 }
18769 Py_INCREF(Py_None); resultobj = Py_None;
18770 return resultobj;
18771 fail:
18772 return NULL;
18773 }
18774
18775
18776 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18777 PyObject *resultobj;
18778 wxDateTime::Country result;
18779 char *kwnames[] = {
18780 NULL
18781 };
18782
18783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18784 {
18785 PyThreadState* __tstate = wxPyBeginAllowThreads();
18786 result = (wxDateTime::Country)wxDateTime::GetCountry();
18787
18788 wxPyEndAllowThreads(__tstate);
18789 if (PyErr_Occurred()) SWIG_fail;
18790 }
18791 resultobj = SWIG_From_int((result));
18792 return resultobj;
18793 fail:
18794 return NULL;
18795 }
18796
18797
18798 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18799 PyObject *resultobj;
18800 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18801 bool result;
18802 PyObject * obj0 = 0 ;
18803 char *kwnames[] = {
18804 (char *) "country", NULL
18805 };
18806
18807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18808 if (obj0) {
18809 {
18810 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18811 if (SWIG_arg_fail(1)) SWIG_fail;
18812 }
18813 }
18814 {
18815 PyThreadState* __tstate = wxPyBeginAllowThreads();
18816 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18817
18818 wxPyEndAllowThreads(__tstate);
18819 if (PyErr_Occurred()) SWIG_fail;
18820 }
18821 {
18822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18823 }
18824 return resultobj;
18825 fail:
18826 return NULL;
18827 }
18828
18829
18830 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18831 PyObject *resultobj;
18832 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18833 int result;
18834 PyObject * obj0 = 0 ;
18835 char *kwnames[] = {
18836 (char *) "cal", NULL
18837 };
18838
18839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18840 if (obj0) {
18841 {
18842 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18843 if (SWIG_arg_fail(1)) SWIG_fail;
18844 }
18845 }
18846 {
18847 PyThreadState* __tstate = wxPyBeginAllowThreads();
18848 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18849
18850 wxPyEndAllowThreads(__tstate);
18851 if (PyErr_Occurred()) SWIG_fail;
18852 }
18853 {
18854 resultobj = SWIG_From_int((int)(result));
18855 }
18856 return resultobj;
18857 fail:
18858 return NULL;
18859 }
18860
18861
18862 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
18863 PyObject *resultobj;
18864 int arg1 ;
18865 int result;
18866 PyObject * obj0 = 0 ;
18867 char *kwnames[] = {
18868 (char *) "year", NULL
18869 };
18870
18871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
18872 {
18873 arg1 = (int)(SWIG_As_int(obj0));
18874 if (SWIG_arg_fail(1)) SWIG_fail;
18875 }
18876 {
18877 PyThreadState* __tstate = wxPyBeginAllowThreads();
18878 result = (int)wxDateTime::ConvertYearToBC(arg1);
18879
18880 wxPyEndAllowThreads(__tstate);
18881 if (PyErr_Occurred()) SWIG_fail;
18882 }
18883 {
18884 resultobj = SWIG_From_int((int)(result));
18885 }
18886 return resultobj;
18887 fail:
18888 return NULL;
18889 }
18890
18891
18892 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18893 PyObject *resultobj;
18894 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18895 wxDateTime::Month result;
18896 PyObject * obj0 = 0 ;
18897 char *kwnames[] = {
18898 (char *) "cal", NULL
18899 };
18900
18901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
18902 if (obj0) {
18903 {
18904 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18905 if (SWIG_arg_fail(1)) SWIG_fail;
18906 }
18907 }
18908 {
18909 PyThreadState* __tstate = wxPyBeginAllowThreads();
18910 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
18911
18912 wxPyEndAllowThreads(__tstate);
18913 if (PyErr_Occurred()) SWIG_fail;
18914 }
18915 resultobj = SWIG_From_int((result));
18916 return resultobj;
18917 fail:
18918 return NULL;
18919 }
18920
18921
18922 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
18923 PyObject *resultobj;
18924 int arg1 = (int) wxDateTime::Inv_Year ;
18925 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18926 bool result;
18927 PyObject * obj0 = 0 ;
18928 PyObject * obj1 = 0 ;
18929 char *kwnames[] = {
18930 (char *) "year",(char *) "cal", NULL
18931 };
18932
18933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
18934 if (obj0) {
18935 {
18936 arg1 = (int)(SWIG_As_int(obj0));
18937 if (SWIG_arg_fail(1)) SWIG_fail;
18938 }
18939 }
18940 if (obj1) {
18941 {
18942 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18943 if (SWIG_arg_fail(2)) SWIG_fail;
18944 }
18945 }
18946 {
18947 PyThreadState* __tstate = wxPyBeginAllowThreads();
18948 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
18949
18950 wxPyEndAllowThreads(__tstate);
18951 if (PyErr_Occurred()) SWIG_fail;
18952 }
18953 {
18954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18955 }
18956 return resultobj;
18957 fail:
18958 return NULL;
18959 }
18960
18961
18962 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
18963 PyObject *resultobj;
18964 int arg1 = (int) wxDateTime::Inv_Year ;
18965 int result;
18966 PyObject * obj0 = 0 ;
18967 char *kwnames[] = {
18968 (char *) "year", NULL
18969 };
18970
18971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
18972 if (obj0) {
18973 {
18974 arg1 = (int)(SWIG_As_int(obj0));
18975 if (SWIG_arg_fail(1)) SWIG_fail;
18976 }
18977 }
18978 {
18979 PyThreadState* __tstate = wxPyBeginAllowThreads();
18980 result = (int)wxDateTime::GetCentury(arg1);
18981
18982 wxPyEndAllowThreads(__tstate);
18983 if (PyErr_Occurred()) SWIG_fail;
18984 }
18985 {
18986 resultobj = SWIG_From_int((int)(result));
18987 }
18988 return resultobj;
18989 fail:
18990 return NULL;
18991 }
18992
18993
18994 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
18995 PyObject *resultobj;
18996 int arg1 ;
18997 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18998 int result;
18999 PyObject * obj0 = 0 ;
19000 PyObject * obj1 = 0 ;
19001 char *kwnames[] = {
19002 (char *) "year",(char *) "cal", NULL
19003 };
19004
19005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19006 {
19007 arg1 = (int)(SWIG_As_int(obj0));
19008 if (SWIG_arg_fail(1)) SWIG_fail;
19009 }
19010 if (obj1) {
19011 {
19012 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19013 if (SWIG_arg_fail(2)) SWIG_fail;
19014 }
19015 }
19016 {
19017 PyThreadState* __tstate = wxPyBeginAllowThreads();
19018 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19019
19020 wxPyEndAllowThreads(__tstate);
19021 if (PyErr_Occurred()) SWIG_fail;
19022 }
19023 {
19024 resultobj = SWIG_From_int((int)(result));
19025 }
19026 return resultobj;
19027 fail:
19028 return NULL;
19029 }
19030
19031
19032 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19033 PyObject *resultobj;
19034 wxDateTime::Month arg1 ;
19035 int arg2 = (int) wxDateTime::Inv_Year ;
19036 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19037 int result;
19038 PyObject * obj0 = 0 ;
19039 PyObject * obj1 = 0 ;
19040 PyObject * obj2 = 0 ;
19041 char *kwnames[] = {
19042 (char *) "month",(char *) "year",(char *) "cal", NULL
19043 };
19044
19045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19046 {
19047 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19048 if (SWIG_arg_fail(1)) SWIG_fail;
19049 }
19050 if (obj1) {
19051 {
19052 arg2 = (int)(SWIG_As_int(obj1));
19053 if (SWIG_arg_fail(2)) SWIG_fail;
19054 }
19055 }
19056 if (obj2) {
19057 {
19058 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19059 if (SWIG_arg_fail(3)) SWIG_fail;
19060 }
19061 }
19062 {
19063 PyThreadState* __tstate = wxPyBeginAllowThreads();
19064 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19065
19066 wxPyEndAllowThreads(__tstate);
19067 if (PyErr_Occurred()) SWIG_fail;
19068 }
19069 {
19070 resultobj = SWIG_From_int((int)(result));
19071 }
19072 return resultobj;
19073 fail:
19074 return NULL;
19075 }
19076
19077
19078 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19079 PyObject *resultobj;
19080 wxDateTime::Month arg1 ;
19081 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19082 wxString result;
19083 PyObject * obj0 = 0 ;
19084 PyObject * obj1 = 0 ;
19085 char *kwnames[] = {
19086 (char *) "month",(char *) "flags", NULL
19087 };
19088
19089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19090 {
19091 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19092 if (SWIG_arg_fail(1)) SWIG_fail;
19093 }
19094 if (obj1) {
19095 {
19096 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19097 if (SWIG_arg_fail(2)) SWIG_fail;
19098 }
19099 }
19100 {
19101 PyThreadState* __tstate = wxPyBeginAllowThreads();
19102 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19103
19104 wxPyEndAllowThreads(__tstate);
19105 if (PyErr_Occurred()) SWIG_fail;
19106 }
19107 {
19108 #if wxUSE_UNICODE
19109 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19110 #else
19111 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19112 #endif
19113 }
19114 return resultobj;
19115 fail:
19116 return NULL;
19117 }
19118
19119
19120 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19121 PyObject *resultobj;
19122 wxDateTime::WeekDay arg1 ;
19123 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19124 wxString result;
19125 PyObject * obj0 = 0 ;
19126 PyObject * obj1 = 0 ;
19127 char *kwnames[] = {
19128 (char *) "weekday",(char *) "flags", NULL
19129 };
19130
19131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19132 {
19133 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19134 if (SWIG_arg_fail(1)) SWIG_fail;
19135 }
19136 if (obj1) {
19137 {
19138 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19139 if (SWIG_arg_fail(2)) SWIG_fail;
19140 }
19141 }
19142 {
19143 PyThreadState* __tstate = wxPyBeginAllowThreads();
19144 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19145
19146 wxPyEndAllowThreads(__tstate);
19147 if (PyErr_Occurred()) SWIG_fail;
19148 }
19149 {
19150 #if wxUSE_UNICODE
19151 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19152 #else
19153 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19154 #endif
19155 }
19156 return resultobj;
19157 fail:
19158 return NULL;
19159 }
19160
19161
19162 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19163 PyObject *resultobj;
19164 wxString *arg1 = (wxString *) 0 ;
19165 wxString *arg2 = (wxString *) 0 ;
19166 bool temp1 = false ;
19167 bool temp2 = false ;
19168 PyObject * obj0 = 0 ;
19169 PyObject * obj1 = 0 ;
19170 char *kwnames[] = {
19171 (char *) "OUTPUT",(char *) "OUTPUT", NULL
19172 };
19173
19174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetAmPmStrings",kwnames,&obj0,&obj1)) goto fail;
19175 {
19176 arg1 = wxString_in_helper(obj0);
19177 if (arg1 == NULL) SWIG_fail;
19178 temp1 = true;
19179 }
19180 {
19181 arg2 = wxString_in_helper(obj1);
19182 if (arg2 == NULL) SWIG_fail;
19183 temp2 = true;
19184 }
19185 {
19186 PyThreadState* __tstate = wxPyBeginAllowThreads();
19187 wxDateTime::GetAmPmStrings(arg1,arg2);
19188
19189 wxPyEndAllowThreads(__tstate);
19190 if (PyErr_Occurred()) SWIG_fail;
19191 }
19192 Py_INCREF(Py_None); resultobj = Py_None;
19193 {
19194 if (temp1)
19195 delete arg1;
19196 }
19197 {
19198 if (temp2)
19199 delete arg2;
19200 }
19201 return resultobj;
19202 fail:
19203 {
19204 if (temp1)
19205 delete arg1;
19206 }
19207 {
19208 if (temp2)
19209 delete arg2;
19210 }
19211 return NULL;
19212 }
19213
19214
19215 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19216 PyObject *resultobj;
19217 int arg1 = (int) wxDateTime::Inv_Year ;
19218 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19219 bool result;
19220 PyObject * obj0 = 0 ;
19221 PyObject * obj1 = 0 ;
19222 char *kwnames[] = {
19223 (char *) "year",(char *) "country", NULL
19224 };
19225
19226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19227 if (obj0) {
19228 {
19229 arg1 = (int)(SWIG_As_int(obj0));
19230 if (SWIG_arg_fail(1)) SWIG_fail;
19231 }
19232 }
19233 if (obj1) {
19234 {
19235 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19236 if (SWIG_arg_fail(2)) SWIG_fail;
19237 }
19238 }
19239 {
19240 PyThreadState* __tstate = wxPyBeginAllowThreads();
19241 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19242
19243 wxPyEndAllowThreads(__tstate);
19244 if (PyErr_Occurred()) SWIG_fail;
19245 }
19246 {
19247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19248 }
19249 return resultobj;
19250 fail:
19251 return NULL;
19252 }
19253
19254
19255 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19256 PyObject *resultobj;
19257 int arg1 = (int) wxDateTime::Inv_Year ;
19258 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19259 wxDateTime result;
19260 PyObject * obj0 = 0 ;
19261 PyObject * obj1 = 0 ;
19262 char *kwnames[] = {
19263 (char *) "year",(char *) "country", NULL
19264 };
19265
19266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19267 if (obj0) {
19268 {
19269 arg1 = (int)(SWIG_As_int(obj0));
19270 if (SWIG_arg_fail(1)) SWIG_fail;
19271 }
19272 }
19273 if (obj1) {
19274 {
19275 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19276 if (SWIG_arg_fail(2)) SWIG_fail;
19277 }
19278 }
19279 {
19280 PyThreadState* __tstate = wxPyBeginAllowThreads();
19281 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19282
19283 wxPyEndAllowThreads(__tstate);
19284 if (PyErr_Occurred()) SWIG_fail;
19285 }
19286 {
19287 wxDateTime * resultptr;
19288 resultptr = new wxDateTime((wxDateTime &)(result));
19289 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19290 }
19291 return resultobj;
19292 fail:
19293 return NULL;
19294 }
19295
19296
19297 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19298 PyObject *resultobj;
19299 int arg1 = (int) wxDateTime::Inv_Year ;
19300 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19301 wxDateTime result;
19302 PyObject * obj0 = 0 ;
19303 PyObject * obj1 = 0 ;
19304 char *kwnames[] = {
19305 (char *) "year",(char *) "country", NULL
19306 };
19307
19308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19309 if (obj0) {
19310 {
19311 arg1 = (int)(SWIG_As_int(obj0));
19312 if (SWIG_arg_fail(1)) SWIG_fail;
19313 }
19314 }
19315 if (obj1) {
19316 {
19317 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19318 if (SWIG_arg_fail(2)) SWIG_fail;
19319 }
19320 }
19321 {
19322 PyThreadState* __tstate = wxPyBeginAllowThreads();
19323 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19324
19325 wxPyEndAllowThreads(__tstate);
19326 if (PyErr_Occurred()) SWIG_fail;
19327 }
19328 {
19329 wxDateTime * resultptr;
19330 resultptr = new wxDateTime((wxDateTime &)(result));
19331 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19332 }
19333 return resultobj;
19334 fail:
19335 return NULL;
19336 }
19337
19338
19339 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19340 PyObject *resultobj;
19341 wxDateTime result;
19342 char *kwnames[] = {
19343 NULL
19344 };
19345
19346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19347 {
19348 PyThreadState* __tstate = wxPyBeginAllowThreads();
19349 result = wxDateTime::Now();
19350
19351 wxPyEndAllowThreads(__tstate);
19352 if (PyErr_Occurred()) SWIG_fail;
19353 }
19354 {
19355 wxDateTime * resultptr;
19356 resultptr = new wxDateTime((wxDateTime &)(result));
19357 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19358 }
19359 return resultobj;
19360 fail:
19361 return NULL;
19362 }
19363
19364
19365 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19366 PyObject *resultobj;
19367 wxDateTime result;
19368 char *kwnames[] = {
19369 NULL
19370 };
19371
19372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19373 {
19374 PyThreadState* __tstate = wxPyBeginAllowThreads();
19375 result = wxDateTime::UNow();
19376
19377 wxPyEndAllowThreads(__tstate);
19378 if (PyErr_Occurred()) SWIG_fail;
19379 }
19380 {
19381 wxDateTime * resultptr;
19382 resultptr = new wxDateTime((wxDateTime &)(result));
19383 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19384 }
19385 return resultobj;
19386 fail:
19387 return NULL;
19388 }
19389
19390
19391 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19392 PyObject *resultobj;
19393 wxDateTime result;
19394 char *kwnames[] = {
19395 NULL
19396 };
19397
19398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19399 {
19400 PyThreadState* __tstate = wxPyBeginAllowThreads();
19401 result = wxDateTime::Today();
19402
19403 wxPyEndAllowThreads(__tstate);
19404 if (PyErr_Occurred()) SWIG_fail;
19405 }
19406 {
19407 wxDateTime * resultptr;
19408 resultptr = new wxDateTime((wxDateTime &)(result));
19409 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19410 }
19411 return resultobj;
19412 fail:
19413 return NULL;
19414 }
19415
19416
19417 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19418 PyObject *resultobj;
19419 wxDateTime *result;
19420 char *kwnames[] = {
19421 NULL
19422 };
19423
19424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19425 {
19426 PyThreadState* __tstate = wxPyBeginAllowThreads();
19427 result = (wxDateTime *)new wxDateTime();
19428
19429 wxPyEndAllowThreads(__tstate);
19430 if (PyErr_Occurred()) SWIG_fail;
19431 }
19432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19433 return resultobj;
19434 fail:
19435 return NULL;
19436 }
19437
19438
19439 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19440 PyObject *resultobj;
19441 time_t arg1 ;
19442 wxDateTime *result;
19443 PyObject * obj0 = 0 ;
19444 char *kwnames[] = {
19445 (char *) "timet", NULL
19446 };
19447
19448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19449 {
19450 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19451 if (SWIG_arg_fail(1)) SWIG_fail;
19452 }
19453 {
19454 PyThreadState* __tstate = wxPyBeginAllowThreads();
19455 result = (wxDateTime *)new wxDateTime(arg1);
19456
19457 wxPyEndAllowThreads(__tstate);
19458 if (PyErr_Occurred()) SWIG_fail;
19459 }
19460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19461 return resultobj;
19462 fail:
19463 return NULL;
19464 }
19465
19466
19467 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19468 PyObject *resultobj;
19469 double arg1 ;
19470 wxDateTime *result;
19471 PyObject * obj0 = 0 ;
19472 char *kwnames[] = {
19473 (char *) "jdn", NULL
19474 };
19475
19476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19477 {
19478 arg1 = (double)(SWIG_As_double(obj0));
19479 if (SWIG_arg_fail(1)) SWIG_fail;
19480 }
19481 {
19482 PyThreadState* __tstate = wxPyBeginAllowThreads();
19483 result = (wxDateTime *)new wxDateTime(arg1);
19484
19485 wxPyEndAllowThreads(__tstate);
19486 if (PyErr_Occurred()) SWIG_fail;
19487 }
19488 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19489 return resultobj;
19490 fail:
19491 return NULL;
19492 }
19493
19494
19495 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19496 PyObject *resultobj;
19497 int arg1 ;
19498 int arg2 = (int) 0 ;
19499 int arg3 = (int) 0 ;
19500 int arg4 = (int) 0 ;
19501 wxDateTime *result;
19502 PyObject * obj0 = 0 ;
19503 PyObject * obj1 = 0 ;
19504 PyObject * obj2 = 0 ;
19505 PyObject * obj3 = 0 ;
19506 char *kwnames[] = {
19507 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19508 };
19509
19510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19511 {
19512 arg1 = (int)(SWIG_As_int(obj0));
19513 if (SWIG_arg_fail(1)) SWIG_fail;
19514 }
19515 if (obj1) {
19516 {
19517 arg2 = (int)(SWIG_As_int(obj1));
19518 if (SWIG_arg_fail(2)) SWIG_fail;
19519 }
19520 }
19521 if (obj2) {
19522 {
19523 arg3 = (int)(SWIG_As_int(obj2));
19524 if (SWIG_arg_fail(3)) SWIG_fail;
19525 }
19526 }
19527 if (obj3) {
19528 {
19529 arg4 = (int)(SWIG_As_int(obj3));
19530 if (SWIG_arg_fail(4)) SWIG_fail;
19531 }
19532 }
19533 {
19534 PyThreadState* __tstate = wxPyBeginAllowThreads();
19535 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19536
19537 wxPyEndAllowThreads(__tstate);
19538 if (PyErr_Occurred()) SWIG_fail;
19539 }
19540 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19541 return resultobj;
19542 fail:
19543 return NULL;
19544 }
19545
19546
19547 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19548 PyObject *resultobj;
19549 int arg1 ;
19550 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19551 int arg3 = (int) wxDateTime::Inv_Year ;
19552 int arg4 = (int) 0 ;
19553 int arg5 = (int) 0 ;
19554 int arg6 = (int) 0 ;
19555 int arg7 = (int) 0 ;
19556 wxDateTime *result;
19557 PyObject * obj0 = 0 ;
19558 PyObject * obj1 = 0 ;
19559 PyObject * obj2 = 0 ;
19560 PyObject * obj3 = 0 ;
19561 PyObject * obj4 = 0 ;
19562 PyObject * obj5 = 0 ;
19563 PyObject * obj6 = 0 ;
19564 char *kwnames[] = {
19565 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19566 };
19567
19568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19569 {
19570 arg1 = (int)(SWIG_As_int(obj0));
19571 if (SWIG_arg_fail(1)) SWIG_fail;
19572 }
19573 if (obj1) {
19574 {
19575 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19576 if (SWIG_arg_fail(2)) SWIG_fail;
19577 }
19578 }
19579 if (obj2) {
19580 {
19581 arg3 = (int)(SWIG_As_int(obj2));
19582 if (SWIG_arg_fail(3)) SWIG_fail;
19583 }
19584 }
19585 if (obj3) {
19586 {
19587 arg4 = (int)(SWIG_As_int(obj3));
19588 if (SWIG_arg_fail(4)) SWIG_fail;
19589 }
19590 }
19591 if (obj4) {
19592 {
19593 arg5 = (int)(SWIG_As_int(obj4));
19594 if (SWIG_arg_fail(5)) SWIG_fail;
19595 }
19596 }
19597 if (obj5) {
19598 {
19599 arg6 = (int)(SWIG_As_int(obj5));
19600 if (SWIG_arg_fail(6)) SWIG_fail;
19601 }
19602 }
19603 if (obj6) {
19604 {
19605 arg7 = (int)(SWIG_As_int(obj6));
19606 if (SWIG_arg_fail(7)) SWIG_fail;
19607 }
19608 }
19609 {
19610 PyThreadState* __tstate = wxPyBeginAllowThreads();
19611 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19612
19613 wxPyEndAllowThreads(__tstate);
19614 if (PyErr_Occurred()) SWIG_fail;
19615 }
19616 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19617 return resultobj;
19618 fail:
19619 return NULL;
19620 }
19621
19622
19623 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19624 PyObject *resultobj;
19625 wxDateTime *arg1 = (wxDateTime *) 0 ;
19626 PyObject * obj0 = 0 ;
19627 char *kwnames[] = {
19628 (char *) "self", NULL
19629 };
19630
19631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19633 if (SWIG_arg_fail(1)) SWIG_fail;
19634 {
19635 PyThreadState* __tstate = wxPyBeginAllowThreads();
19636 delete arg1;
19637
19638 wxPyEndAllowThreads(__tstate);
19639 if (PyErr_Occurred()) SWIG_fail;
19640 }
19641 Py_INCREF(Py_None); resultobj = Py_None;
19642 return resultobj;
19643 fail:
19644 return NULL;
19645 }
19646
19647
19648 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19649 PyObject *resultobj;
19650 wxDateTime *arg1 = (wxDateTime *) 0 ;
19651 wxDateTime *result;
19652 PyObject * obj0 = 0 ;
19653 char *kwnames[] = {
19654 (char *) "self", NULL
19655 };
19656
19657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19659 if (SWIG_arg_fail(1)) SWIG_fail;
19660 {
19661 PyThreadState* __tstate = wxPyBeginAllowThreads();
19662 {
19663 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19664 result = (wxDateTime *) &_result_ref;
19665 }
19666
19667 wxPyEndAllowThreads(__tstate);
19668 if (PyErr_Occurred()) SWIG_fail;
19669 }
19670 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19671 return resultobj;
19672 fail:
19673 return NULL;
19674 }
19675
19676
19677 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19678 PyObject *resultobj;
19679 wxDateTime *arg1 = (wxDateTime *) 0 ;
19680 time_t arg2 ;
19681 wxDateTime *result;
19682 PyObject * obj0 = 0 ;
19683 PyObject * obj1 = 0 ;
19684 char *kwnames[] = {
19685 (char *) "self",(char *) "timet", NULL
19686 };
19687
19688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19690 if (SWIG_arg_fail(1)) SWIG_fail;
19691 {
19692 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19693 if (SWIG_arg_fail(2)) SWIG_fail;
19694 }
19695 {
19696 PyThreadState* __tstate = wxPyBeginAllowThreads();
19697 {
19698 wxDateTime &_result_ref = (arg1)->Set(arg2);
19699 result = (wxDateTime *) &_result_ref;
19700 }
19701
19702 wxPyEndAllowThreads(__tstate);
19703 if (PyErr_Occurred()) SWIG_fail;
19704 }
19705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19706 return resultobj;
19707 fail:
19708 return NULL;
19709 }
19710
19711
19712 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19713 PyObject *resultobj;
19714 wxDateTime *arg1 = (wxDateTime *) 0 ;
19715 double arg2 ;
19716 wxDateTime *result;
19717 PyObject * obj0 = 0 ;
19718 PyObject * obj1 = 0 ;
19719 char *kwnames[] = {
19720 (char *) "self",(char *) "jdn", NULL
19721 };
19722
19723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19725 if (SWIG_arg_fail(1)) SWIG_fail;
19726 {
19727 arg2 = (double)(SWIG_As_double(obj1));
19728 if (SWIG_arg_fail(2)) SWIG_fail;
19729 }
19730 {
19731 PyThreadState* __tstate = wxPyBeginAllowThreads();
19732 {
19733 wxDateTime &_result_ref = (arg1)->Set(arg2);
19734 result = (wxDateTime *) &_result_ref;
19735 }
19736
19737 wxPyEndAllowThreads(__tstate);
19738 if (PyErr_Occurred()) SWIG_fail;
19739 }
19740 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19741 return resultobj;
19742 fail:
19743 return NULL;
19744 }
19745
19746
19747 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19748 PyObject *resultobj;
19749 wxDateTime *arg1 = (wxDateTime *) 0 ;
19750 int arg2 ;
19751 int arg3 = (int) 0 ;
19752 int arg4 = (int) 0 ;
19753 int arg5 = (int) 0 ;
19754 wxDateTime *result;
19755 PyObject * obj0 = 0 ;
19756 PyObject * obj1 = 0 ;
19757 PyObject * obj2 = 0 ;
19758 PyObject * obj3 = 0 ;
19759 PyObject * obj4 = 0 ;
19760 char *kwnames[] = {
19761 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19762 };
19763
19764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19766 if (SWIG_arg_fail(1)) SWIG_fail;
19767 {
19768 arg2 = (int)(SWIG_As_int(obj1));
19769 if (SWIG_arg_fail(2)) SWIG_fail;
19770 }
19771 if (obj2) {
19772 {
19773 arg3 = (int)(SWIG_As_int(obj2));
19774 if (SWIG_arg_fail(3)) SWIG_fail;
19775 }
19776 }
19777 if (obj3) {
19778 {
19779 arg4 = (int)(SWIG_As_int(obj3));
19780 if (SWIG_arg_fail(4)) SWIG_fail;
19781 }
19782 }
19783 if (obj4) {
19784 {
19785 arg5 = (int)(SWIG_As_int(obj4));
19786 if (SWIG_arg_fail(5)) SWIG_fail;
19787 }
19788 }
19789 {
19790 PyThreadState* __tstate = wxPyBeginAllowThreads();
19791 {
19792 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19793 result = (wxDateTime *) &_result_ref;
19794 }
19795
19796 wxPyEndAllowThreads(__tstate);
19797 if (PyErr_Occurred()) SWIG_fail;
19798 }
19799 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19800 return resultobj;
19801 fail:
19802 return NULL;
19803 }
19804
19805
19806 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19807 PyObject *resultobj;
19808 wxDateTime *arg1 = (wxDateTime *) 0 ;
19809 int arg2 ;
19810 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19811 int arg4 = (int) wxDateTime::Inv_Year ;
19812 int arg5 = (int) 0 ;
19813 int arg6 = (int) 0 ;
19814 int arg7 = (int) 0 ;
19815 int arg8 = (int) 0 ;
19816 wxDateTime *result;
19817 PyObject * obj0 = 0 ;
19818 PyObject * obj1 = 0 ;
19819 PyObject * obj2 = 0 ;
19820 PyObject * obj3 = 0 ;
19821 PyObject * obj4 = 0 ;
19822 PyObject * obj5 = 0 ;
19823 PyObject * obj6 = 0 ;
19824 PyObject * obj7 = 0 ;
19825 char *kwnames[] = {
19826 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19827 };
19828
19829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19831 if (SWIG_arg_fail(1)) SWIG_fail;
19832 {
19833 arg2 = (int)(SWIG_As_int(obj1));
19834 if (SWIG_arg_fail(2)) SWIG_fail;
19835 }
19836 if (obj2) {
19837 {
19838 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19839 if (SWIG_arg_fail(3)) SWIG_fail;
19840 }
19841 }
19842 if (obj3) {
19843 {
19844 arg4 = (int)(SWIG_As_int(obj3));
19845 if (SWIG_arg_fail(4)) SWIG_fail;
19846 }
19847 }
19848 if (obj4) {
19849 {
19850 arg5 = (int)(SWIG_As_int(obj4));
19851 if (SWIG_arg_fail(5)) SWIG_fail;
19852 }
19853 }
19854 if (obj5) {
19855 {
19856 arg6 = (int)(SWIG_As_int(obj5));
19857 if (SWIG_arg_fail(6)) SWIG_fail;
19858 }
19859 }
19860 if (obj6) {
19861 {
19862 arg7 = (int)(SWIG_As_int(obj6));
19863 if (SWIG_arg_fail(7)) SWIG_fail;
19864 }
19865 }
19866 if (obj7) {
19867 {
19868 arg8 = (int)(SWIG_As_int(obj7));
19869 if (SWIG_arg_fail(8)) SWIG_fail;
19870 }
19871 }
19872 {
19873 PyThreadState* __tstate = wxPyBeginAllowThreads();
19874 {
19875 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
19876 result = (wxDateTime *) &_result_ref;
19877 }
19878
19879 wxPyEndAllowThreads(__tstate);
19880 if (PyErr_Occurred()) SWIG_fail;
19881 }
19882 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19883 return resultobj;
19884 fail:
19885 return NULL;
19886 }
19887
19888
19889 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
19890 PyObject *resultobj;
19891 wxDateTime *arg1 = (wxDateTime *) 0 ;
19892 wxDateTime *result;
19893 PyObject * obj0 = 0 ;
19894 char *kwnames[] = {
19895 (char *) "self", NULL
19896 };
19897
19898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
19899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19900 if (SWIG_arg_fail(1)) SWIG_fail;
19901 {
19902 PyThreadState* __tstate = wxPyBeginAllowThreads();
19903 {
19904 wxDateTime &_result_ref = (arg1)->ResetTime();
19905 result = (wxDateTime *) &_result_ref;
19906 }
19907
19908 wxPyEndAllowThreads(__tstate);
19909 if (PyErr_Occurred()) SWIG_fail;
19910 }
19911 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19912 return resultobj;
19913 fail:
19914 return NULL;
19915 }
19916
19917
19918 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
19919 PyObject *resultobj;
19920 wxDateTime *arg1 = (wxDateTime *) 0 ;
19921 int arg2 ;
19922 wxDateTime *result;
19923 PyObject * obj0 = 0 ;
19924 PyObject * obj1 = 0 ;
19925 char *kwnames[] = {
19926 (char *) "self",(char *) "year", NULL
19927 };
19928
19929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
19930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19931 if (SWIG_arg_fail(1)) SWIG_fail;
19932 {
19933 arg2 = (int)(SWIG_As_int(obj1));
19934 if (SWIG_arg_fail(2)) SWIG_fail;
19935 }
19936 {
19937 PyThreadState* __tstate = wxPyBeginAllowThreads();
19938 {
19939 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
19940 result = (wxDateTime *) &_result_ref;
19941 }
19942
19943 wxPyEndAllowThreads(__tstate);
19944 if (PyErr_Occurred()) SWIG_fail;
19945 }
19946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19947 return resultobj;
19948 fail:
19949 return NULL;
19950 }
19951
19952
19953 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19954 PyObject *resultobj;
19955 wxDateTime *arg1 = (wxDateTime *) 0 ;
19956 wxDateTime::Month arg2 ;
19957 wxDateTime *result;
19958 PyObject * obj0 = 0 ;
19959 PyObject * obj1 = 0 ;
19960 char *kwnames[] = {
19961 (char *) "self",(char *) "month", NULL
19962 };
19963
19964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
19965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19966 if (SWIG_arg_fail(1)) SWIG_fail;
19967 {
19968 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19969 if (SWIG_arg_fail(2)) SWIG_fail;
19970 }
19971 {
19972 PyThreadState* __tstate = wxPyBeginAllowThreads();
19973 {
19974 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
19975 result = (wxDateTime *) &_result_ref;
19976 }
19977
19978 wxPyEndAllowThreads(__tstate);
19979 if (PyErr_Occurred()) SWIG_fail;
19980 }
19981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19982 return resultobj;
19983 fail:
19984 return NULL;
19985 }
19986
19987
19988 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
19989 PyObject *resultobj;
19990 wxDateTime *arg1 = (wxDateTime *) 0 ;
19991 int arg2 ;
19992 wxDateTime *result;
19993 PyObject * obj0 = 0 ;
19994 PyObject * obj1 = 0 ;
19995 char *kwnames[] = {
19996 (char *) "self",(char *) "day", NULL
19997 };
19998
19999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20001 if (SWIG_arg_fail(1)) SWIG_fail;
20002 {
20003 arg2 = (int)(SWIG_As_int(obj1));
20004 if (SWIG_arg_fail(2)) SWIG_fail;
20005 }
20006 {
20007 PyThreadState* __tstate = wxPyBeginAllowThreads();
20008 {
20009 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20010 result = (wxDateTime *) &_result_ref;
20011 }
20012
20013 wxPyEndAllowThreads(__tstate);
20014 if (PyErr_Occurred()) SWIG_fail;
20015 }
20016 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20017 return resultobj;
20018 fail:
20019 return NULL;
20020 }
20021
20022
20023 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20024 PyObject *resultobj;
20025 wxDateTime *arg1 = (wxDateTime *) 0 ;
20026 int arg2 ;
20027 wxDateTime *result;
20028 PyObject * obj0 = 0 ;
20029 PyObject * obj1 = 0 ;
20030 char *kwnames[] = {
20031 (char *) "self",(char *) "hour", NULL
20032 };
20033
20034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20036 if (SWIG_arg_fail(1)) SWIG_fail;
20037 {
20038 arg2 = (int)(SWIG_As_int(obj1));
20039 if (SWIG_arg_fail(2)) SWIG_fail;
20040 }
20041 {
20042 PyThreadState* __tstate = wxPyBeginAllowThreads();
20043 {
20044 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20045 result = (wxDateTime *) &_result_ref;
20046 }
20047
20048 wxPyEndAllowThreads(__tstate);
20049 if (PyErr_Occurred()) SWIG_fail;
20050 }
20051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20052 return resultobj;
20053 fail:
20054 return NULL;
20055 }
20056
20057
20058 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20059 PyObject *resultobj;
20060 wxDateTime *arg1 = (wxDateTime *) 0 ;
20061 int arg2 ;
20062 wxDateTime *result;
20063 PyObject * obj0 = 0 ;
20064 PyObject * obj1 = 0 ;
20065 char *kwnames[] = {
20066 (char *) "self",(char *) "minute", NULL
20067 };
20068
20069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20071 if (SWIG_arg_fail(1)) SWIG_fail;
20072 {
20073 arg2 = (int)(SWIG_As_int(obj1));
20074 if (SWIG_arg_fail(2)) SWIG_fail;
20075 }
20076 {
20077 PyThreadState* __tstate = wxPyBeginAllowThreads();
20078 {
20079 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20080 result = (wxDateTime *) &_result_ref;
20081 }
20082
20083 wxPyEndAllowThreads(__tstate);
20084 if (PyErr_Occurred()) SWIG_fail;
20085 }
20086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20087 return resultobj;
20088 fail:
20089 return NULL;
20090 }
20091
20092
20093 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20094 PyObject *resultobj;
20095 wxDateTime *arg1 = (wxDateTime *) 0 ;
20096 int arg2 ;
20097 wxDateTime *result;
20098 PyObject * obj0 = 0 ;
20099 PyObject * obj1 = 0 ;
20100 char *kwnames[] = {
20101 (char *) "self",(char *) "second", NULL
20102 };
20103
20104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20106 if (SWIG_arg_fail(1)) SWIG_fail;
20107 {
20108 arg2 = (int)(SWIG_As_int(obj1));
20109 if (SWIG_arg_fail(2)) SWIG_fail;
20110 }
20111 {
20112 PyThreadState* __tstate = wxPyBeginAllowThreads();
20113 {
20114 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20115 result = (wxDateTime *) &_result_ref;
20116 }
20117
20118 wxPyEndAllowThreads(__tstate);
20119 if (PyErr_Occurred()) SWIG_fail;
20120 }
20121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20122 return resultobj;
20123 fail:
20124 return NULL;
20125 }
20126
20127
20128 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20129 PyObject *resultobj;
20130 wxDateTime *arg1 = (wxDateTime *) 0 ;
20131 int arg2 ;
20132 wxDateTime *result;
20133 PyObject * obj0 = 0 ;
20134 PyObject * obj1 = 0 ;
20135 char *kwnames[] = {
20136 (char *) "self",(char *) "millisecond", NULL
20137 };
20138
20139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20141 if (SWIG_arg_fail(1)) SWIG_fail;
20142 {
20143 arg2 = (int)(SWIG_As_int(obj1));
20144 if (SWIG_arg_fail(2)) SWIG_fail;
20145 }
20146 {
20147 PyThreadState* __tstate = wxPyBeginAllowThreads();
20148 {
20149 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20150 result = (wxDateTime *) &_result_ref;
20151 }
20152
20153 wxPyEndAllowThreads(__tstate);
20154 if (PyErr_Occurred()) SWIG_fail;
20155 }
20156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20157 return resultobj;
20158 fail:
20159 return NULL;
20160 }
20161
20162
20163 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20164 PyObject *resultobj;
20165 wxDateTime *arg1 = (wxDateTime *) 0 ;
20166 wxDateTime::WeekDay arg2 ;
20167 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20168 wxDateTime *result;
20169 PyObject * obj0 = 0 ;
20170 PyObject * obj1 = 0 ;
20171 PyObject * obj2 = 0 ;
20172 char *kwnames[] = {
20173 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20174 };
20175
20176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20178 if (SWIG_arg_fail(1)) SWIG_fail;
20179 {
20180 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20181 if (SWIG_arg_fail(2)) SWIG_fail;
20182 }
20183 if (obj2) {
20184 {
20185 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20186 if (SWIG_arg_fail(3)) SWIG_fail;
20187 }
20188 }
20189 {
20190 PyThreadState* __tstate = wxPyBeginAllowThreads();
20191 {
20192 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20193 result = (wxDateTime *) &_result_ref;
20194 }
20195
20196 wxPyEndAllowThreads(__tstate);
20197 if (PyErr_Occurred()) SWIG_fail;
20198 }
20199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20200 return resultobj;
20201 fail:
20202 return NULL;
20203 }
20204
20205
20206 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20207 PyObject *resultobj;
20208 wxDateTime *arg1 = (wxDateTime *) 0 ;
20209 wxDateTime::WeekDay arg2 ;
20210 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20211 wxDateTime result;
20212 PyObject * obj0 = 0 ;
20213 PyObject * obj1 = 0 ;
20214 PyObject * obj2 = 0 ;
20215 char *kwnames[] = {
20216 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20217 };
20218
20219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20221 if (SWIG_arg_fail(1)) SWIG_fail;
20222 {
20223 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20224 if (SWIG_arg_fail(2)) SWIG_fail;
20225 }
20226 if (obj2) {
20227 {
20228 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20229 if (SWIG_arg_fail(3)) SWIG_fail;
20230 }
20231 }
20232 {
20233 PyThreadState* __tstate = wxPyBeginAllowThreads();
20234 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20235
20236 wxPyEndAllowThreads(__tstate);
20237 if (PyErr_Occurred()) SWIG_fail;
20238 }
20239 {
20240 wxDateTime * resultptr;
20241 resultptr = new wxDateTime((wxDateTime &)(result));
20242 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20243 }
20244 return resultobj;
20245 fail:
20246 return NULL;
20247 }
20248
20249
20250 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20251 PyObject *resultobj;
20252 wxDateTime *arg1 = (wxDateTime *) 0 ;
20253 wxDateTime::WeekDay arg2 ;
20254 wxDateTime *result;
20255 PyObject * obj0 = 0 ;
20256 PyObject * obj1 = 0 ;
20257 char *kwnames[] = {
20258 (char *) "self",(char *) "weekday", NULL
20259 };
20260
20261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20263 if (SWIG_arg_fail(1)) SWIG_fail;
20264 {
20265 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20266 if (SWIG_arg_fail(2)) SWIG_fail;
20267 }
20268 {
20269 PyThreadState* __tstate = wxPyBeginAllowThreads();
20270 {
20271 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20272 result = (wxDateTime *) &_result_ref;
20273 }
20274
20275 wxPyEndAllowThreads(__tstate);
20276 if (PyErr_Occurred()) SWIG_fail;
20277 }
20278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20279 return resultobj;
20280 fail:
20281 return NULL;
20282 }
20283
20284
20285 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20286 PyObject *resultobj;
20287 wxDateTime *arg1 = (wxDateTime *) 0 ;
20288 wxDateTime::WeekDay arg2 ;
20289 wxDateTime result;
20290 PyObject * obj0 = 0 ;
20291 PyObject * obj1 = 0 ;
20292 char *kwnames[] = {
20293 (char *) "self",(char *) "weekday", NULL
20294 };
20295
20296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20298 if (SWIG_arg_fail(1)) SWIG_fail;
20299 {
20300 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20301 if (SWIG_arg_fail(2)) SWIG_fail;
20302 }
20303 {
20304 PyThreadState* __tstate = wxPyBeginAllowThreads();
20305 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20306
20307 wxPyEndAllowThreads(__tstate);
20308 if (PyErr_Occurred()) SWIG_fail;
20309 }
20310 {
20311 wxDateTime * resultptr;
20312 resultptr = new wxDateTime((wxDateTime &)(result));
20313 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20314 }
20315 return resultobj;
20316 fail:
20317 return NULL;
20318 }
20319
20320
20321 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20322 PyObject *resultobj;
20323 wxDateTime *arg1 = (wxDateTime *) 0 ;
20324 wxDateTime::WeekDay arg2 ;
20325 wxDateTime *result;
20326 PyObject * obj0 = 0 ;
20327 PyObject * obj1 = 0 ;
20328 char *kwnames[] = {
20329 (char *) "self",(char *) "weekday", NULL
20330 };
20331
20332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20334 if (SWIG_arg_fail(1)) SWIG_fail;
20335 {
20336 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20337 if (SWIG_arg_fail(2)) SWIG_fail;
20338 }
20339 {
20340 PyThreadState* __tstate = wxPyBeginAllowThreads();
20341 {
20342 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20343 result = (wxDateTime *) &_result_ref;
20344 }
20345
20346 wxPyEndAllowThreads(__tstate);
20347 if (PyErr_Occurred()) SWIG_fail;
20348 }
20349 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20350 return resultobj;
20351 fail:
20352 return NULL;
20353 }
20354
20355
20356 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20357 PyObject *resultobj;
20358 wxDateTime *arg1 = (wxDateTime *) 0 ;
20359 wxDateTime::WeekDay arg2 ;
20360 wxDateTime result;
20361 PyObject * obj0 = 0 ;
20362 PyObject * obj1 = 0 ;
20363 char *kwnames[] = {
20364 (char *) "self",(char *) "weekday", NULL
20365 };
20366
20367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20369 if (SWIG_arg_fail(1)) SWIG_fail;
20370 {
20371 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20372 if (SWIG_arg_fail(2)) SWIG_fail;
20373 }
20374 {
20375 PyThreadState* __tstate = wxPyBeginAllowThreads();
20376 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20377
20378 wxPyEndAllowThreads(__tstate);
20379 if (PyErr_Occurred()) SWIG_fail;
20380 }
20381 {
20382 wxDateTime * resultptr;
20383 resultptr = new wxDateTime((wxDateTime &)(result));
20384 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20385 }
20386 return resultobj;
20387 fail:
20388 return NULL;
20389 }
20390
20391
20392 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20393 PyObject *resultobj;
20394 wxDateTime *arg1 = (wxDateTime *) 0 ;
20395 wxDateTime::WeekDay arg2 ;
20396 int arg3 = (int) 1 ;
20397 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20398 int arg5 = (int) wxDateTime::Inv_Year ;
20399 bool result;
20400 PyObject * obj0 = 0 ;
20401 PyObject * obj1 = 0 ;
20402 PyObject * obj2 = 0 ;
20403 PyObject * obj3 = 0 ;
20404 PyObject * obj4 = 0 ;
20405 char *kwnames[] = {
20406 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20407 };
20408
20409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20411 if (SWIG_arg_fail(1)) SWIG_fail;
20412 {
20413 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20414 if (SWIG_arg_fail(2)) SWIG_fail;
20415 }
20416 if (obj2) {
20417 {
20418 arg3 = (int)(SWIG_As_int(obj2));
20419 if (SWIG_arg_fail(3)) SWIG_fail;
20420 }
20421 }
20422 if (obj3) {
20423 {
20424 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20425 if (SWIG_arg_fail(4)) SWIG_fail;
20426 }
20427 }
20428 if (obj4) {
20429 {
20430 arg5 = (int)(SWIG_As_int(obj4));
20431 if (SWIG_arg_fail(5)) SWIG_fail;
20432 }
20433 }
20434 {
20435 PyThreadState* __tstate = wxPyBeginAllowThreads();
20436 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20437
20438 wxPyEndAllowThreads(__tstate);
20439 if (PyErr_Occurred()) SWIG_fail;
20440 }
20441 {
20442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20443 }
20444 return resultobj;
20445 fail:
20446 return NULL;
20447 }
20448
20449
20450 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20451 PyObject *resultobj;
20452 wxDateTime *arg1 = (wxDateTime *) 0 ;
20453 wxDateTime::WeekDay arg2 ;
20454 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20455 int arg4 = (int) wxDateTime::Inv_Year ;
20456 bool result;
20457 PyObject * obj0 = 0 ;
20458 PyObject * obj1 = 0 ;
20459 PyObject * obj2 = 0 ;
20460 PyObject * obj3 = 0 ;
20461 char *kwnames[] = {
20462 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20463 };
20464
20465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20467 if (SWIG_arg_fail(1)) SWIG_fail;
20468 {
20469 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20470 if (SWIG_arg_fail(2)) SWIG_fail;
20471 }
20472 if (obj2) {
20473 {
20474 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20475 if (SWIG_arg_fail(3)) SWIG_fail;
20476 }
20477 }
20478 if (obj3) {
20479 {
20480 arg4 = (int)(SWIG_As_int(obj3));
20481 if (SWIG_arg_fail(4)) SWIG_fail;
20482 }
20483 }
20484 {
20485 PyThreadState* __tstate = wxPyBeginAllowThreads();
20486 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20487
20488 wxPyEndAllowThreads(__tstate);
20489 if (PyErr_Occurred()) SWIG_fail;
20490 }
20491 {
20492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20493 }
20494 return resultobj;
20495 fail:
20496 return NULL;
20497 }
20498
20499
20500 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20501 PyObject *resultobj;
20502 wxDateTime *arg1 = (wxDateTime *) 0 ;
20503 wxDateTime::WeekDay arg2 ;
20504 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20505 int arg4 = (int) wxDateTime::Inv_Year ;
20506 wxDateTime result;
20507 PyObject * obj0 = 0 ;
20508 PyObject * obj1 = 0 ;
20509 PyObject * obj2 = 0 ;
20510 PyObject * obj3 = 0 ;
20511 char *kwnames[] = {
20512 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20513 };
20514
20515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20517 if (SWIG_arg_fail(1)) SWIG_fail;
20518 {
20519 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20520 if (SWIG_arg_fail(2)) SWIG_fail;
20521 }
20522 if (obj2) {
20523 {
20524 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20525 if (SWIG_arg_fail(3)) SWIG_fail;
20526 }
20527 }
20528 if (obj3) {
20529 {
20530 arg4 = (int)(SWIG_As_int(obj3));
20531 if (SWIG_arg_fail(4)) SWIG_fail;
20532 }
20533 }
20534 {
20535 PyThreadState* __tstate = wxPyBeginAllowThreads();
20536 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20537
20538 wxPyEndAllowThreads(__tstate);
20539 if (PyErr_Occurred()) SWIG_fail;
20540 }
20541 {
20542 wxDateTime * resultptr;
20543 resultptr = new wxDateTime((wxDateTime &)(result));
20544 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20545 }
20546 return resultobj;
20547 fail:
20548 return NULL;
20549 }
20550
20551
20552 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20553 PyObject *resultobj;
20554 wxDateTime *arg1 = (wxDateTime *) 0 ;
20555 int arg2 ;
20556 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20557 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20558 bool result;
20559 PyObject * obj0 = 0 ;
20560 PyObject * obj1 = 0 ;
20561 PyObject * obj2 = 0 ;
20562 PyObject * obj3 = 0 ;
20563 char *kwnames[] = {
20564 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20565 };
20566
20567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20569 if (SWIG_arg_fail(1)) SWIG_fail;
20570 {
20571 arg2 = (int)(SWIG_As_int(obj1));
20572 if (SWIG_arg_fail(2)) SWIG_fail;
20573 }
20574 if (obj2) {
20575 {
20576 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20577 if (SWIG_arg_fail(3)) SWIG_fail;
20578 }
20579 }
20580 if (obj3) {
20581 {
20582 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20583 if (SWIG_arg_fail(4)) SWIG_fail;
20584 }
20585 }
20586 {
20587 PyThreadState* __tstate = wxPyBeginAllowThreads();
20588 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20589
20590 wxPyEndAllowThreads(__tstate);
20591 if (PyErr_Occurred()) SWIG_fail;
20592 }
20593 {
20594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20595 }
20596 return resultobj;
20597 fail:
20598 return NULL;
20599 }
20600
20601
20602 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20603 PyObject *resultobj;
20604 wxDateTime *arg1 = (wxDateTime *) 0 ;
20605 int arg2 ;
20606 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20607 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20608 wxDateTime result;
20609 PyObject * obj0 = 0 ;
20610 PyObject * obj1 = 0 ;
20611 PyObject * obj2 = 0 ;
20612 PyObject * obj3 = 0 ;
20613 char *kwnames[] = {
20614 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20615 };
20616
20617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20619 if (SWIG_arg_fail(1)) SWIG_fail;
20620 {
20621 arg2 = (int)(SWIG_As_int(obj1));
20622 if (SWIG_arg_fail(2)) SWIG_fail;
20623 }
20624 if (obj2) {
20625 {
20626 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20627 if (SWIG_arg_fail(3)) SWIG_fail;
20628 }
20629 }
20630 if (obj3) {
20631 {
20632 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20633 if (SWIG_arg_fail(4)) SWIG_fail;
20634 }
20635 }
20636 {
20637 PyThreadState* __tstate = wxPyBeginAllowThreads();
20638 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20639
20640 wxPyEndAllowThreads(__tstate);
20641 if (PyErr_Occurred()) SWIG_fail;
20642 }
20643 {
20644 wxDateTime * resultptr;
20645 resultptr = new wxDateTime((wxDateTime &)(result));
20646 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20647 }
20648 return resultobj;
20649 fail:
20650 return NULL;
20651 }
20652
20653
20654 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20655 PyObject *resultobj;
20656 int arg1 ;
20657 int arg2 ;
20658 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20659 wxDateTime result;
20660 PyObject * obj0 = 0 ;
20661 PyObject * obj1 = 0 ;
20662 PyObject * obj2 = 0 ;
20663 char *kwnames[] = {
20664 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20665 };
20666
20667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20668 {
20669 arg1 = (int)(SWIG_As_int(obj0));
20670 if (SWIG_arg_fail(1)) SWIG_fail;
20671 }
20672 {
20673 arg2 = (int)(SWIG_As_int(obj1));
20674 if (SWIG_arg_fail(2)) SWIG_fail;
20675 }
20676 if (obj2) {
20677 {
20678 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20679 if (SWIG_arg_fail(3)) SWIG_fail;
20680 }
20681 }
20682 {
20683 PyThreadState* __tstate = wxPyBeginAllowThreads();
20684 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20685
20686 wxPyEndAllowThreads(__tstate);
20687 if (PyErr_Occurred()) SWIG_fail;
20688 }
20689 {
20690 wxDateTime * resultptr;
20691 resultptr = new wxDateTime((wxDateTime &)(result));
20692 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20693 }
20694 return resultobj;
20695 fail:
20696 return NULL;
20697 }
20698
20699
20700 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20701 PyObject *resultobj;
20702 wxDateTime *arg1 = (wxDateTime *) 0 ;
20703 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20704 int arg3 = (int) wxDateTime::Inv_Year ;
20705 wxDateTime *result;
20706 PyObject * obj0 = 0 ;
20707 PyObject * obj1 = 0 ;
20708 PyObject * obj2 = 0 ;
20709 char *kwnames[] = {
20710 (char *) "self",(char *) "month",(char *) "year", NULL
20711 };
20712
20713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20715 if (SWIG_arg_fail(1)) SWIG_fail;
20716 if (obj1) {
20717 {
20718 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20719 if (SWIG_arg_fail(2)) SWIG_fail;
20720 }
20721 }
20722 if (obj2) {
20723 {
20724 arg3 = (int)(SWIG_As_int(obj2));
20725 if (SWIG_arg_fail(3)) SWIG_fail;
20726 }
20727 }
20728 {
20729 PyThreadState* __tstate = wxPyBeginAllowThreads();
20730 {
20731 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20732 result = (wxDateTime *) &_result_ref;
20733 }
20734
20735 wxPyEndAllowThreads(__tstate);
20736 if (PyErr_Occurred()) SWIG_fail;
20737 }
20738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20739 return resultobj;
20740 fail:
20741 return NULL;
20742 }
20743
20744
20745 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20746 PyObject *resultobj;
20747 wxDateTime *arg1 = (wxDateTime *) 0 ;
20748 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20749 int arg3 = (int) wxDateTime::Inv_Year ;
20750 wxDateTime result;
20751 PyObject * obj0 = 0 ;
20752 PyObject * obj1 = 0 ;
20753 PyObject * obj2 = 0 ;
20754 char *kwnames[] = {
20755 (char *) "self",(char *) "month",(char *) "year", NULL
20756 };
20757
20758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20760 if (SWIG_arg_fail(1)) SWIG_fail;
20761 if (obj1) {
20762 {
20763 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20764 if (SWIG_arg_fail(2)) SWIG_fail;
20765 }
20766 }
20767 if (obj2) {
20768 {
20769 arg3 = (int)(SWIG_As_int(obj2));
20770 if (SWIG_arg_fail(3)) SWIG_fail;
20771 }
20772 }
20773 {
20774 PyThreadState* __tstate = wxPyBeginAllowThreads();
20775 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20776
20777 wxPyEndAllowThreads(__tstate);
20778 if (PyErr_Occurred()) SWIG_fail;
20779 }
20780 {
20781 wxDateTime * resultptr;
20782 resultptr = new wxDateTime((wxDateTime &)(result));
20783 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20784 }
20785 return resultobj;
20786 fail:
20787 return NULL;
20788 }
20789
20790
20791 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20792 PyObject *resultobj;
20793 wxDateTime *arg1 = (wxDateTime *) 0 ;
20794 int arg2 ;
20795 wxDateTime *result;
20796 PyObject * obj0 = 0 ;
20797 PyObject * obj1 = 0 ;
20798 char *kwnames[] = {
20799 (char *) "self",(char *) "yday", NULL
20800 };
20801
20802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20804 if (SWIG_arg_fail(1)) SWIG_fail;
20805 {
20806 arg2 = (int)(SWIG_As_int(obj1));
20807 if (SWIG_arg_fail(2)) SWIG_fail;
20808 }
20809 {
20810 PyThreadState* __tstate = wxPyBeginAllowThreads();
20811 {
20812 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20813 result = (wxDateTime *) &_result_ref;
20814 }
20815
20816 wxPyEndAllowThreads(__tstate);
20817 if (PyErr_Occurred()) SWIG_fail;
20818 }
20819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20820 return resultobj;
20821 fail:
20822 return NULL;
20823 }
20824
20825
20826 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20827 PyObject *resultobj;
20828 wxDateTime *arg1 = (wxDateTime *) 0 ;
20829 int arg2 ;
20830 wxDateTime result;
20831 PyObject * obj0 = 0 ;
20832 PyObject * obj1 = 0 ;
20833 char *kwnames[] = {
20834 (char *) "self",(char *) "yday", NULL
20835 };
20836
20837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20839 if (SWIG_arg_fail(1)) SWIG_fail;
20840 {
20841 arg2 = (int)(SWIG_As_int(obj1));
20842 if (SWIG_arg_fail(2)) SWIG_fail;
20843 }
20844 {
20845 PyThreadState* __tstate = wxPyBeginAllowThreads();
20846 result = (arg1)->GetYearDay(arg2);
20847
20848 wxPyEndAllowThreads(__tstate);
20849 if (PyErr_Occurred()) SWIG_fail;
20850 }
20851 {
20852 wxDateTime * resultptr;
20853 resultptr = new wxDateTime((wxDateTime &)(result));
20854 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20855 }
20856 return resultobj;
20857 fail:
20858 return NULL;
20859 }
20860
20861
20862 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20863 PyObject *resultobj;
20864 wxDateTime *arg1 = (wxDateTime *) 0 ;
20865 double result;
20866 PyObject * obj0 = 0 ;
20867 char *kwnames[] = {
20868 (char *) "self", NULL
20869 };
20870
20871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
20872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20873 if (SWIG_arg_fail(1)) SWIG_fail;
20874 {
20875 PyThreadState* __tstate = wxPyBeginAllowThreads();
20876 result = (double)(arg1)->GetJulianDayNumber();
20877
20878 wxPyEndAllowThreads(__tstate);
20879 if (PyErr_Occurred()) SWIG_fail;
20880 }
20881 {
20882 resultobj = SWIG_From_double((double)(result));
20883 }
20884 return resultobj;
20885 fail:
20886 return NULL;
20887 }
20888
20889
20890 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20891 PyObject *resultobj;
20892 wxDateTime *arg1 = (wxDateTime *) 0 ;
20893 double result;
20894 PyObject * obj0 = 0 ;
20895 char *kwnames[] = {
20896 (char *) "self", NULL
20897 };
20898
20899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
20900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20901 if (SWIG_arg_fail(1)) SWIG_fail;
20902 {
20903 PyThreadState* __tstate = wxPyBeginAllowThreads();
20904 result = (double)(arg1)->GetJDN();
20905
20906 wxPyEndAllowThreads(__tstate);
20907 if (PyErr_Occurred()) SWIG_fail;
20908 }
20909 {
20910 resultobj = SWIG_From_double((double)(result));
20911 }
20912 return resultobj;
20913 fail:
20914 return NULL;
20915 }
20916
20917
20918 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20919 PyObject *resultobj;
20920 wxDateTime *arg1 = (wxDateTime *) 0 ;
20921 double result;
20922 PyObject * obj0 = 0 ;
20923 char *kwnames[] = {
20924 (char *) "self", NULL
20925 };
20926
20927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
20928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20929 if (SWIG_arg_fail(1)) SWIG_fail;
20930 {
20931 PyThreadState* __tstate = wxPyBeginAllowThreads();
20932 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
20933
20934 wxPyEndAllowThreads(__tstate);
20935 if (PyErr_Occurred()) SWIG_fail;
20936 }
20937 {
20938 resultobj = SWIG_From_double((double)(result));
20939 }
20940 return resultobj;
20941 fail:
20942 return NULL;
20943 }
20944
20945
20946 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
20947 PyObject *resultobj;
20948 wxDateTime *arg1 = (wxDateTime *) 0 ;
20949 double result;
20950 PyObject * obj0 = 0 ;
20951 char *kwnames[] = {
20952 (char *) "self", NULL
20953 };
20954
20955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
20956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20957 if (SWIG_arg_fail(1)) SWIG_fail;
20958 {
20959 PyThreadState* __tstate = wxPyBeginAllowThreads();
20960 result = (double)(arg1)->GetMJD();
20961
20962 wxPyEndAllowThreads(__tstate);
20963 if (PyErr_Occurred()) SWIG_fail;
20964 }
20965 {
20966 resultobj = SWIG_From_double((double)(result));
20967 }
20968 return resultobj;
20969 fail:
20970 return NULL;
20971 }
20972
20973
20974 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
20975 PyObject *resultobj;
20976 wxDateTime *arg1 = (wxDateTime *) 0 ;
20977 double result;
20978 PyObject * obj0 = 0 ;
20979 char *kwnames[] = {
20980 (char *) "self", NULL
20981 };
20982
20983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
20984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20985 if (SWIG_arg_fail(1)) SWIG_fail;
20986 {
20987 PyThreadState* __tstate = wxPyBeginAllowThreads();
20988 result = (double)(arg1)->GetRataDie();
20989
20990 wxPyEndAllowThreads(__tstate);
20991 if (PyErr_Occurred()) SWIG_fail;
20992 }
20993 {
20994 resultobj = SWIG_From_double((double)(result));
20995 }
20996 return resultobj;
20997 fail:
20998 return NULL;
20999 }
21000
21001
21002 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21003 PyObject *resultobj;
21004 wxDateTime *arg1 = (wxDateTime *) 0 ;
21005 wxDateTime::TimeZone *arg2 = 0 ;
21006 bool arg3 = (bool) false ;
21007 wxDateTime result;
21008 bool temp2 = false ;
21009 PyObject * obj0 = 0 ;
21010 PyObject * obj1 = 0 ;
21011 PyObject * obj2 = 0 ;
21012 char *kwnames[] = {
21013 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21014 };
21015
21016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21018 if (SWIG_arg_fail(1)) SWIG_fail;
21019 {
21020 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21021 temp2 = true;
21022 }
21023 if (obj2) {
21024 {
21025 arg3 = (bool)(SWIG_As_bool(obj2));
21026 if (SWIG_arg_fail(3)) SWIG_fail;
21027 }
21028 }
21029 {
21030 PyThreadState* __tstate = wxPyBeginAllowThreads();
21031 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21032
21033 wxPyEndAllowThreads(__tstate);
21034 if (PyErr_Occurred()) SWIG_fail;
21035 }
21036 {
21037 wxDateTime * resultptr;
21038 resultptr = new wxDateTime((wxDateTime &)(result));
21039 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21040 }
21041 {
21042 if (temp2) delete arg2;
21043 }
21044 return resultobj;
21045 fail:
21046 {
21047 if (temp2) delete arg2;
21048 }
21049 return NULL;
21050 }
21051
21052
21053 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21054 PyObject *resultobj;
21055 wxDateTime *arg1 = (wxDateTime *) 0 ;
21056 wxDateTime::TimeZone *arg2 = 0 ;
21057 bool arg3 = (bool) false ;
21058 wxDateTime *result;
21059 bool temp2 = false ;
21060 PyObject * obj0 = 0 ;
21061 PyObject * obj1 = 0 ;
21062 PyObject * obj2 = 0 ;
21063 char *kwnames[] = {
21064 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21065 };
21066
21067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21069 if (SWIG_arg_fail(1)) SWIG_fail;
21070 {
21071 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21072 temp2 = true;
21073 }
21074 if (obj2) {
21075 {
21076 arg3 = (bool)(SWIG_As_bool(obj2));
21077 if (SWIG_arg_fail(3)) SWIG_fail;
21078 }
21079 }
21080 {
21081 PyThreadState* __tstate = wxPyBeginAllowThreads();
21082 {
21083 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21084 result = (wxDateTime *) &_result_ref;
21085 }
21086
21087 wxPyEndAllowThreads(__tstate);
21088 if (PyErr_Occurred()) SWIG_fail;
21089 }
21090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21091 {
21092 if (temp2) delete arg2;
21093 }
21094 return resultobj;
21095 fail:
21096 {
21097 if (temp2) delete arg2;
21098 }
21099 return NULL;
21100 }
21101
21102
21103 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21104 PyObject *resultobj;
21105 wxDateTime *arg1 = (wxDateTime *) 0 ;
21106 bool arg2 = (bool) false ;
21107 wxDateTime result;
21108 PyObject * obj0 = 0 ;
21109 PyObject * obj1 = 0 ;
21110 char *kwnames[] = {
21111 (char *) "self",(char *) "noDST", NULL
21112 };
21113
21114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21116 if (SWIG_arg_fail(1)) SWIG_fail;
21117 if (obj1) {
21118 {
21119 arg2 = (bool)(SWIG_As_bool(obj1));
21120 if (SWIG_arg_fail(2)) SWIG_fail;
21121 }
21122 }
21123 {
21124 PyThreadState* __tstate = wxPyBeginAllowThreads();
21125 result = (arg1)->ToGMT(arg2);
21126
21127 wxPyEndAllowThreads(__tstate);
21128 if (PyErr_Occurred()) SWIG_fail;
21129 }
21130 {
21131 wxDateTime * resultptr;
21132 resultptr = new wxDateTime((wxDateTime &)(result));
21133 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21134 }
21135 return resultobj;
21136 fail:
21137 return NULL;
21138 }
21139
21140
21141 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21142 PyObject *resultobj;
21143 wxDateTime *arg1 = (wxDateTime *) 0 ;
21144 bool arg2 = (bool) false ;
21145 wxDateTime *result;
21146 PyObject * obj0 = 0 ;
21147 PyObject * obj1 = 0 ;
21148 char *kwnames[] = {
21149 (char *) "self",(char *) "noDST", NULL
21150 };
21151
21152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21154 if (SWIG_arg_fail(1)) SWIG_fail;
21155 if (obj1) {
21156 {
21157 arg2 = (bool)(SWIG_As_bool(obj1));
21158 if (SWIG_arg_fail(2)) SWIG_fail;
21159 }
21160 }
21161 {
21162 PyThreadState* __tstate = wxPyBeginAllowThreads();
21163 {
21164 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21165 result = (wxDateTime *) &_result_ref;
21166 }
21167
21168 wxPyEndAllowThreads(__tstate);
21169 if (PyErr_Occurred()) SWIG_fail;
21170 }
21171 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21172 return resultobj;
21173 fail:
21174 return NULL;
21175 }
21176
21177
21178 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21179 PyObject *resultobj;
21180 wxDateTime *arg1 = (wxDateTime *) 0 ;
21181 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21182 int result;
21183 PyObject * obj0 = 0 ;
21184 PyObject * obj1 = 0 ;
21185 char *kwnames[] = {
21186 (char *) "self",(char *) "country", NULL
21187 };
21188
21189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21191 if (SWIG_arg_fail(1)) SWIG_fail;
21192 if (obj1) {
21193 {
21194 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21195 if (SWIG_arg_fail(2)) SWIG_fail;
21196 }
21197 }
21198 {
21199 PyThreadState* __tstate = wxPyBeginAllowThreads();
21200 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21201
21202 wxPyEndAllowThreads(__tstate);
21203 if (PyErr_Occurred()) SWIG_fail;
21204 }
21205 {
21206 resultobj = SWIG_From_int((int)(result));
21207 }
21208 return resultobj;
21209 fail:
21210 return NULL;
21211 }
21212
21213
21214 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21215 PyObject *resultobj;
21216 wxDateTime *arg1 = (wxDateTime *) 0 ;
21217 bool result;
21218 PyObject * obj0 = 0 ;
21219 char *kwnames[] = {
21220 (char *) "self", NULL
21221 };
21222
21223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21225 if (SWIG_arg_fail(1)) SWIG_fail;
21226 {
21227 PyThreadState* __tstate = wxPyBeginAllowThreads();
21228 result = (bool)((wxDateTime const *)arg1)->IsValid();
21229
21230 wxPyEndAllowThreads(__tstate);
21231 if (PyErr_Occurred()) SWIG_fail;
21232 }
21233 {
21234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21235 }
21236 return resultobj;
21237 fail:
21238 return NULL;
21239 }
21240
21241
21242 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21243 PyObject *resultobj;
21244 wxDateTime *arg1 = (wxDateTime *) 0 ;
21245 time_t result;
21246 PyObject * obj0 = 0 ;
21247 char *kwnames[] = {
21248 (char *) "self", NULL
21249 };
21250
21251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21253 if (SWIG_arg_fail(1)) SWIG_fail;
21254 {
21255 PyThreadState* __tstate = wxPyBeginAllowThreads();
21256 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21257
21258 wxPyEndAllowThreads(__tstate);
21259 if (PyErr_Occurred()) SWIG_fail;
21260 }
21261 {
21262 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21263 }
21264 return resultobj;
21265 fail:
21266 return NULL;
21267 }
21268
21269
21270 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21271 PyObject *resultobj;
21272 wxDateTime *arg1 = (wxDateTime *) 0 ;
21273 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21274 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21275 int result;
21276 bool temp2 = false ;
21277 PyObject * obj0 = 0 ;
21278 PyObject * obj1 = 0 ;
21279 char *kwnames[] = {
21280 (char *) "self",(char *) "tz", NULL
21281 };
21282
21283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21285 if (SWIG_arg_fail(1)) SWIG_fail;
21286 if (obj1) {
21287 {
21288 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21289 temp2 = true;
21290 }
21291 }
21292 {
21293 PyThreadState* __tstate = wxPyBeginAllowThreads();
21294 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21295
21296 wxPyEndAllowThreads(__tstate);
21297 if (PyErr_Occurred()) SWIG_fail;
21298 }
21299 {
21300 resultobj = SWIG_From_int((int)(result));
21301 }
21302 {
21303 if (temp2) delete arg2;
21304 }
21305 return resultobj;
21306 fail:
21307 {
21308 if (temp2) delete arg2;
21309 }
21310 return NULL;
21311 }
21312
21313
21314 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21315 PyObject *resultobj;
21316 wxDateTime *arg1 = (wxDateTime *) 0 ;
21317 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21318 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21319 wxDateTime::Month result;
21320 bool temp2 = false ;
21321 PyObject * obj0 = 0 ;
21322 PyObject * obj1 = 0 ;
21323 char *kwnames[] = {
21324 (char *) "self",(char *) "tz", NULL
21325 };
21326
21327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21329 if (SWIG_arg_fail(1)) SWIG_fail;
21330 if (obj1) {
21331 {
21332 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21333 temp2 = true;
21334 }
21335 }
21336 {
21337 PyThreadState* __tstate = wxPyBeginAllowThreads();
21338 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21339
21340 wxPyEndAllowThreads(__tstate);
21341 if (PyErr_Occurred()) SWIG_fail;
21342 }
21343 resultobj = SWIG_From_int((result));
21344 {
21345 if (temp2) delete arg2;
21346 }
21347 return resultobj;
21348 fail:
21349 {
21350 if (temp2) delete arg2;
21351 }
21352 return NULL;
21353 }
21354
21355
21356 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21357 PyObject *resultobj;
21358 wxDateTime *arg1 = (wxDateTime *) 0 ;
21359 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21360 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21361 int result;
21362 bool temp2 = false ;
21363 PyObject * obj0 = 0 ;
21364 PyObject * obj1 = 0 ;
21365 char *kwnames[] = {
21366 (char *) "self",(char *) "tz", NULL
21367 };
21368
21369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21371 if (SWIG_arg_fail(1)) SWIG_fail;
21372 if (obj1) {
21373 {
21374 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21375 temp2 = true;
21376 }
21377 }
21378 {
21379 PyThreadState* __tstate = wxPyBeginAllowThreads();
21380 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21381
21382 wxPyEndAllowThreads(__tstate);
21383 if (PyErr_Occurred()) SWIG_fail;
21384 }
21385 {
21386 resultobj = SWIG_From_int((int)(result));
21387 }
21388 {
21389 if (temp2) delete arg2;
21390 }
21391 return resultobj;
21392 fail:
21393 {
21394 if (temp2) delete arg2;
21395 }
21396 return NULL;
21397 }
21398
21399
21400 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21401 PyObject *resultobj;
21402 wxDateTime *arg1 = (wxDateTime *) 0 ;
21403 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21404 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21405 wxDateTime::WeekDay result;
21406 bool temp2 = false ;
21407 PyObject * obj0 = 0 ;
21408 PyObject * obj1 = 0 ;
21409 char *kwnames[] = {
21410 (char *) "self",(char *) "tz", NULL
21411 };
21412
21413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21415 if (SWIG_arg_fail(1)) SWIG_fail;
21416 if (obj1) {
21417 {
21418 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21419 temp2 = true;
21420 }
21421 }
21422 {
21423 PyThreadState* __tstate = wxPyBeginAllowThreads();
21424 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21425
21426 wxPyEndAllowThreads(__tstate);
21427 if (PyErr_Occurred()) SWIG_fail;
21428 }
21429 resultobj = SWIG_From_int((result));
21430 {
21431 if (temp2) delete arg2;
21432 }
21433 return resultobj;
21434 fail:
21435 {
21436 if (temp2) delete arg2;
21437 }
21438 return NULL;
21439 }
21440
21441
21442 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21443 PyObject *resultobj;
21444 wxDateTime *arg1 = (wxDateTime *) 0 ;
21445 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21446 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21447 int result;
21448 bool temp2 = false ;
21449 PyObject * obj0 = 0 ;
21450 PyObject * obj1 = 0 ;
21451 char *kwnames[] = {
21452 (char *) "self",(char *) "tz", NULL
21453 };
21454
21455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21457 if (SWIG_arg_fail(1)) SWIG_fail;
21458 if (obj1) {
21459 {
21460 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21461 temp2 = true;
21462 }
21463 }
21464 {
21465 PyThreadState* __tstate = wxPyBeginAllowThreads();
21466 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21467
21468 wxPyEndAllowThreads(__tstate);
21469 if (PyErr_Occurred()) SWIG_fail;
21470 }
21471 {
21472 resultobj = SWIG_From_int((int)(result));
21473 }
21474 {
21475 if (temp2) delete arg2;
21476 }
21477 return resultobj;
21478 fail:
21479 {
21480 if (temp2) delete arg2;
21481 }
21482 return NULL;
21483 }
21484
21485
21486 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21487 PyObject *resultobj;
21488 wxDateTime *arg1 = (wxDateTime *) 0 ;
21489 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21490 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21491 int result;
21492 bool temp2 = false ;
21493 PyObject * obj0 = 0 ;
21494 PyObject * obj1 = 0 ;
21495 char *kwnames[] = {
21496 (char *) "self",(char *) "tz", NULL
21497 };
21498
21499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21501 if (SWIG_arg_fail(1)) SWIG_fail;
21502 if (obj1) {
21503 {
21504 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21505 temp2 = true;
21506 }
21507 }
21508 {
21509 PyThreadState* __tstate = wxPyBeginAllowThreads();
21510 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21511
21512 wxPyEndAllowThreads(__tstate);
21513 if (PyErr_Occurred()) SWIG_fail;
21514 }
21515 {
21516 resultobj = SWIG_From_int((int)(result));
21517 }
21518 {
21519 if (temp2) delete arg2;
21520 }
21521 return resultobj;
21522 fail:
21523 {
21524 if (temp2) delete arg2;
21525 }
21526 return NULL;
21527 }
21528
21529
21530 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21531 PyObject *resultobj;
21532 wxDateTime *arg1 = (wxDateTime *) 0 ;
21533 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21534 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21535 int result;
21536 bool temp2 = false ;
21537 PyObject * obj0 = 0 ;
21538 PyObject * obj1 = 0 ;
21539 char *kwnames[] = {
21540 (char *) "self",(char *) "tz", NULL
21541 };
21542
21543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21545 if (SWIG_arg_fail(1)) SWIG_fail;
21546 if (obj1) {
21547 {
21548 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21549 temp2 = true;
21550 }
21551 }
21552 {
21553 PyThreadState* __tstate = wxPyBeginAllowThreads();
21554 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21555
21556 wxPyEndAllowThreads(__tstate);
21557 if (PyErr_Occurred()) SWIG_fail;
21558 }
21559 {
21560 resultobj = SWIG_From_int((int)(result));
21561 }
21562 {
21563 if (temp2) delete arg2;
21564 }
21565 return resultobj;
21566 fail:
21567 {
21568 if (temp2) delete arg2;
21569 }
21570 return NULL;
21571 }
21572
21573
21574 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21575 PyObject *resultobj;
21576 wxDateTime *arg1 = (wxDateTime *) 0 ;
21577 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21578 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21579 int result;
21580 bool temp2 = false ;
21581 PyObject * obj0 = 0 ;
21582 PyObject * obj1 = 0 ;
21583 char *kwnames[] = {
21584 (char *) "self",(char *) "tz", NULL
21585 };
21586
21587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21589 if (SWIG_arg_fail(1)) SWIG_fail;
21590 if (obj1) {
21591 {
21592 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21593 temp2 = true;
21594 }
21595 }
21596 {
21597 PyThreadState* __tstate = wxPyBeginAllowThreads();
21598 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21599
21600 wxPyEndAllowThreads(__tstate);
21601 if (PyErr_Occurred()) SWIG_fail;
21602 }
21603 {
21604 resultobj = SWIG_From_int((int)(result));
21605 }
21606 {
21607 if (temp2) delete arg2;
21608 }
21609 return resultobj;
21610 fail:
21611 {
21612 if (temp2) delete arg2;
21613 }
21614 return NULL;
21615 }
21616
21617
21618 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21619 PyObject *resultobj;
21620 wxDateTime *arg1 = (wxDateTime *) 0 ;
21621 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21622 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21623 int result;
21624 bool temp2 = false ;
21625 PyObject * obj0 = 0 ;
21626 PyObject * obj1 = 0 ;
21627 char *kwnames[] = {
21628 (char *) "self",(char *) "tz", NULL
21629 };
21630
21631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21633 if (SWIG_arg_fail(1)) SWIG_fail;
21634 if (obj1) {
21635 {
21636 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21637 temp2 = true;
21638 }
21639 }
21640 {
21641 PyThreadState* __tstate = wxPyBeginAllowThreads();
21642 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21643
21644 wxPyEndAllowThreads(__tstate);
21645 if (PyErr_Occurred()) SWIG_fail;
21646 }
21647 {
21648 resultobj = SWIG_From_int((int)(result));
21649 }
21650 {
21651 if (temp2) delete arg2;
21652 }
21653 return resultobj;
21654 fail:
21655 {
21656 if (temp2) delete arg2;
21657 }
21658 return NULL;
21659 }
21660
21661
21662 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21663 PyObject *resultobj;
21664 wxDateTime *arg1 = (wxDateTime *) 0 ;
21665 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21666 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21667 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21668 int result;
21669 bool temp3 = false ;
21670 PyObject * obj0 = 0 ;
21671 PyObject * obj1 = 0 ;
21672 PyObject * obj2 = 0 ;
21673 char *kwnames[] = {
21674 (char *) "self",(char *) "flags",(char *) "tz", NULL
21675 };
21676
21677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21679 if (SWIG_arg_fail(1)) SWIG_fail;
21680 if (obj1) {
21681 {
21682 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21683 if (SWIG_arg_fail(2)) SWIG_fail;
21684 }
21685 }
21686 if (obj2) {
21687 {
21688 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21689 temp3 = true;
21690 }
21691 }
21692 {
21693 PyThreadState* __tstate = wxPyBeginAllowThreads();
21694 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21695
21696 wxPyEndAllowThreads(__tstate);
21697 if (PyErr_Occurred()) SWIG_fail;
21698 }
21699 {
21700 resultobj = SWIG_From_int((int)(result));
21701 }
21702 {
21703 if (temp3) delete arg3;
21704 }
21705 return resultobj;
21706 fail:
21707 {
21708 if (temp3) delete arg3;
21709 }
21710 return NULL;
21711 }
21712
21713
21714 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21715 PyObject *resultobj;
21716 wxDateTime *arg1 = (wxDateTime *) 0 ;
21717 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21718 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21719 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21720 int result;
21721 bool temp3 = false ;
21722 PyObject * obj0 = 0 ;
21723 PyObject * obj1 = 0 ;
21724 PyObject * obj2 = 0 ;
21725 char *kwnames[] = {
21726 (char *) "self",(char *) "flags",(char *) "tz", NULL
21727 };
21728
21729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21731 if (SWIG_arg_fail(1)) SWIG_fail;
21732 if (obj1) {
21733 {
21734 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21735 if (SWIG_arg_fail(2)) SWIG_fail;
21736 }
21737 }
21738 if (obj2) {
21739 {
21740 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21741 temp3 = true;
21742 }
21743 }
21744 {
21745 PyThreadState* __tstate = wxPyBeginAllowThreads();
21746 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21747
21748 wxPyEndAllowThreads(__tstate);
21749 if (PyErr_Occurred()) SWIG_fail;
21750 }
21751 {
21752 resultobj = SWIG_From_int((int)(result));
21753 }
21754 {
21755 if (temp3) delete arg3;
21756 }
21757 return resultobj;
21758 fail:
21759 {
21760 if (temp3) delete arg3;
21761 }
21762 return NULL;
21763 }
21764
21765
21766 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21767 PyObject *resultobj;
21768 wxDateTime *arg1 = (wxDateTime *) 0 ;
21769 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21770 bool result;
21771 PyObject * obj0 = 0 ;
21772 PyObject * obj1 = 0 ;
21773 char *kwnames[] = {
21774 (char *) "self",(char *) "country", NULL
21775 };
21776
21777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21779 if (SWIG_arg_fail(1)) SWIG_fail;
21780 if (obj1) {
21781 {
21782 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21783 if (SWIG_arg_fail(2)) SWIG_fail;
21784 }
21785 }
21786 {
21787 PyThreadState* __tstate = wxPyBeginAllowThreads();
21788 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21789
21790 wxPyEndAllowThreads(__tstate);
21791 if (PyErr_Occurred()) SWIG_fail;
21792 }
21793 {
21794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21795 }
21796 return resultobj;
21797 fail:
21798 return NULL;
21799 }
21800
21801
21802 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21803 PyObject *resultobj;
21804 wxDateTime *arg1 = (wxDateTime *) 0 ;
21805 wxDateTime *arg2 = 0 ;
21806 bool result;
21807 PyObject * obj0 = 0 ;
21808 PyObject * obj1 = 0 ;
21809 char *kwnames[] = {
21810 (char *) "self",(char *) "datetime", NULL
21811 };
21812
21813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21815 if (SWIG_arg_fail(1)) SWIG_fail;
21816 {
21817 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21818 if (SWIG_arg_fail(2)) SWIG_fail;
21819 if (arg2 == NULL) {
21820 SWIG_null_ref("wxDateTime");
21821 }
21822 if (SWIG_arg_fail(2)) SWIG_fail;
21823 }
21824 {
21825 PyThreadState* __tstate = wxPyBeginAllowThreads();
21826 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21827
21828 wxPyEndAllowThreads(__tstate);
21829 if (PyErr_Occurred()) SWIG_fail;
21830 }
21831 {
21832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21833 }
21834 return resultobj;
21835 fail:
21836 return NULL;
21837 }
21838
21839
21840 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21841 PyObject *resultobj;
21842 wxDateTime *arg1 = (wxDateTime *) 0 ;
21843 wxDateTime *arg2 = 0 ;
21844 bool result;
21845 PyObject * obj0 = 0 ;
21846 PyObject * obj1 = 0 ;
21847 char *kwnames[] = {
21848 (char *) "self",(char *) "datetime", NULL
21849 };
21850
21851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21853 if (SWIG_arg_fail(1)) SWIG_fail;
21854 {
21855 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21856 if (SWIG_arg_fail(2)) SWIG_fail;
21857 if (arg2 == NULL) {
21858 SWIG_null_ref("wxDateTime");
21859 }
21860 if (SWIG_arg_fail(2)) SWIG_fail;
21861 }
21862 {
21863 PyThreadState* __tstate = wxPyBeginAllowThreads();
21864 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
21865
21866 wxPyEndAllowThreads(__tstate);
21867 if (PyErr_Occurred()) SWIG_fail;
21868 }
21869 {
21870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21871 }
21872 return resultobj;
21873 fail:
21874 return NULL;
21875 }
21876
21877
21878 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
21879 PyObject *resultobj;
21880 wxDateTime *arg1 = (wxDateTime *) 0 ;
21881 wxDateTime *arg2 = 0 ;
21882 bool result;
21883 PyObject * obj0 = 0 ;
21884 PyObject * obj1 = 0 ;
21885 char *kwnames[] = {
21886 (char *) "self",(char *) "datetime", NULL
21887 };
21888
21889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
21890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21891 if (SWIG_arg_fail(1)) SWIG_fail;
21892 {
21893 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21894 if (SWIG_arg_fail(2)) SWIG_fail;
21895 if (arg2 == NULL) {
21896 SWIG_null_ref("wxDateTime");
21897 }
21898 if (SWIG_arg_fail(2)) SWIG_fail;
21899 }
21900 {
21901 PyThreadState* __tstate = wxPyBeginAllowThreads();
21902 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
21903
21904 wxPyEndAllowThreads(__tstate);
21905 if (PyErr_Occurred()) SWIG_fail;
21906 }
21907 {
21908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21909 }
21910 return resultobj;
21911 fail:
21912 return NULL;
21913 }
21914
21915
21916 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21917 PyObject *resultobj;
21918 wxDateTime *arg1 = (wxDateTime *) 0 ;
21919 wxDateTime *arg2 = 0 ;
21920 wxDateTime *arg3 = 0 ;
21921 bool result;
21922 PyObject * obj0 = 0 ;
21923 PyObject * obj1 = 0 ;
21924 PyObject * obj2 = 0 ;
21925 char *kwnames[] = {
21926 (char *) "self",(char *) "t1",(char *) "t2", NULL
21927 };
21928
21929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21931 if (SWIG_arg_fail(1)) SWIG_fail;
21932 {
21933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21934 if (SWIG_arg_fail(2)) SWIG_fail;
21935 if (arg2 == NULL) {
21936 SWIG_null_ref("wxDateTime");
21937 }
21938 if (SWIG_arg_fail(2)) SWIG_fail;
21939 }
21940 {
21941 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21942 if (SWIG_arg_fail(3)) SWIG_fail;
21943 if (arg3 == NULL) {
21944 SWIG_null_ref("wxDateTime");
21945 }
21946 if (SWIG_arg_fail(3)) SWIG_fail;
21947 }
21948 {
21949 PyThreadState* __tstate = wxPyBeginAllowThreads();
21950 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21951
21952 wxPyEndAllowThreads(__tstate);
21953 if (PyErr_Occurred()) SWIG_fail;
21954 }
21955 {
21956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21957 }
21958 return resultobj;
21959 fail:
21960 return NULL;
21961 }
21962
21963
21964 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21965 PyObject *resultobj;
21966 wxDateTime *arg1 = (wxDateTime *) 0 ;
21967 wxDateTime *arg2 = 0 ;
21968 wxDateTime *arg3 = 0 ;
21969 bool result;
21970 PyObject * obj0 = 0 ;
21971 PyObject * obj1 = 0 ;
21972 PyObject * obj2 = 0 ;
21973 char *kwnames[] = {
21974 (char *) "self",(char *) "t1",(char *) "t2", NULL
21975 };
21976
21977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21979 if (SWIG_arg_fail(1)) SWIG_fail;
21980 {
21981 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21982 if (SWIG_arg_fail(2)) SWIG_fail;
21983 if (arg2 == NULL) {
21984 SWIG_null_ref("wxDateTime");
21985 }
21986 if (SWIG_arg_fail(2)) SWIG_fail;
21987 }
21988 {
21989 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21990 if (SWIG_arg_fail(3)) SWIG_fail;
21991 if (arg3 == NULL) {
21992 SWIG_null_ref("wxDateTime");
21993 }
21994 if (SWIG_arg_fail(3)) SWIG_fail;
21995 }
21996 {
21997 PyThreadState* __tstate = wxPyBeginAllowThreads();
21998 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21999
22000 wxPyEndAllowThreads(__tstate);
22001 if (PyErr_Occurred()) SWIG_fail;
22002 }
22003 {
22004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22005 }
22006 return resultobj;
22007 fail:
22008 return NULL;
22009 }
22010
22011
22012 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22013 PyObject *resultobj;
22014 wxDateTime *arg1 = (wxDateTime *) 0 ;
22015 wxDateTime *arg2 = 0 ;
22016 bool result;
22017 PyObject * obj0 = 0 ;
22018 PyObject * obj1 = 0 ;
22019 char *kwnames[] = {
22020 (char *) "self",(char *) "dt", NULL
22021 };
22022
22023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22025 if (SWIG_arg_fail(1)) SWIG_fail;
22026 {
22027 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22028 if (SWIG_arg_fail(2)) SWIG_fail;
22029 if (arg2 == NULL) {
22030 SWIG_null_ref("wxDateTime");
22031 }
22032 if (SWIG_arg_fail(2)) SWIG_fail;
22033 }
22034 {
22035 PyThreadState* __tstate = wxPyBeginAllowThreads();
22036 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22037
22038 wxPyEndAllowThreads(__tstate);
22039 if (PyErr_Occurred()) SWIG_fail;
22040 }
22041 {
22042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22043 }
22044 return resultobj;
22045 fail:
22046 return NULL;
22047 }
22048
22049
22050 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22051 PyObject *resultobj;
22052 wxDateTime *arg1 = (wxDateTime *) 0 ;
22053 wxDateTime *arg2 = 0 ;
22054 bool result;
22055 PyObject * obj0 = 0 ;
22056 PyObject * obj1 = 0 ;
22057 char *kwnames[] = {
22058 (char *) "self",(char *) "dt", NULL
22059 };
22060
22061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22063 if (SWIG_arg_fail(1)) SWIG_fail;
22064 {
22065 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22066 if (SWIG_arg_fail(2)) SWIG_fail;
22067 if (arg2 == NULL) {
22068 SWIG_null_ref("wxDateTime");
22069 }
22070 if (SWIG_arg_fail(2)) SWIG_fail;
22071 }
22072 {
22073 PyThreadState* __tstate = wxPyBeginAllowThreads();
22074 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22075
22076 wxPyEndAllowThreads(__tstate);
22077 if (PyErr_Occurred()) SWIG_fail;
22078 }
22079 {
22080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22081 }
22082 return resultobj;
22083 fail:
22084 return NULL;
22085 }
22086
22087
22088 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22089 PyObject *resultobj;
22090 wxDateTime *arg1 = (wxDateTime *) 0 ;
22091 wxDateTime *arg2 = 0 ;
22092 wxTimeSpan *arg3 = 0 ;
22093 bool result;
22094 PyObject * obj0 = 0 ;
22095 PyObject * obj1 = 0 ;
22096 PyObject * obj2 = 0 ;
22097 char *kwnames[] = {
22098 (char *) "self",(char *) "dt",(char *) "ts", NULL
22099 };
22100
22101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22103 if (SWIG_arg_fail(1)) SWIG_fail;
22104 {
22105 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22106 if (SWIG_arg_fail(2)) SWIG_fail;
22107 if (arg2 == NULL) {
22108 SWIG_null_ref("wxDateTime");
22109 }
22110 if (SWIG_arg_fail(2)) SWIG_fail;
22111 }
22112 {
22113 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22114 if (SWIG_arg_fail(3)) SWIG_fail;
22115 if (arg3 == NULL) {
22116 SWIG_null_ref("wxTimeSpan");
22117 }
22118 if (SWIG_arg_fail(3)) SWIG_fail;
22119 }
22120 {
22121 PyThreadState* __tstate = wxPyBeginAllowThreads();
22122 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22123
22124 wxPyEndAllowThreads(__tstate);
22125 if (PyErr_Occurred()) SWIG_fail;
22126 }
22127 {
22128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22129 }
22130 return resultobj;
22131 fail:
22132 return NULL;
22133 }
22134
22135
22136 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22137 PyObject *resultobj;
22138 wxDateTime *arg1 = (wxDateTime *) 0 ;
22139 wxTimeSpan *arg2 = 0 ;
22140 wxDateTime *result;
22141 PyObject * obj0 = 0 ;
22142 PyObject * obj1 = 0 ;
22143 char *kwnames[] = {
22144 (char *) "self",(char *) "diff", NULL
22145 };
22146
22147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22149 if (SWIG_arg_fail(1)) SWIG_fail;
22150 {
22151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22152 if (SWIG_arg_fail(2)) SWIG_fail;
22153 if (arg2 == NULL) {
22154 SWIG_null_ref("wxTimeSpan");
22155 }
22156 if (SWIG_arg_fail(2)) SWIG_fail;
22157 }
22158 {
22159 PyThreadState* __tstate = wxPyBeginAllowThreads();
22160 {
22161 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22162 result = (wxDateTime *) &_result_ref;
22163 }
22164
22165 wxPyEndAllowThreads(__tstate);
22166 if (PyErr_Occurred()) SWIG_fail;
22167 }
22168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22169 return resultobj;
22170 fail:
22171 return NULL;
22172 }
22173
22174
22175 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22176 PyObject *resultobj;
22177 wxDateTime *arg1 = (wxDateTime *) 0 ;
22178 wxDateSpan *arg2 = 0 ;
22179 wxDateTime *result;
22180 PyObject * obj0 = 0 ;
22181 PyObject * obj1 = 0 ;
22182 char *kwnames[] = {
22183 (char *) "self",(char *) "diff", NULL
22184 };
22185
22186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22188 if (SWIG_arg_fail(1)) SWIG_fail;
22189 {
22190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22191 if (SWIG_arg_fail(2)) SWIG_fail;
22192 if (arg2 == NULL) {
22193 SWIG_null_ref("wxDateSpan");
22194 }
22195 if (SWIG_arg_fail(2)) SWIG_fail;
22196 }
22197 {
22198 PyThreadState* __tstate = wxPyBeginAllowThreads();
22199 {
22200 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22201 result = (wxDateTime *) &_result_ref;
22202 }
22203
22204 wxPyEndAllowThreads(__tstate);
22205 if (PyErr_Occurred()) SWIG_fail;
22206 }
22207 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22208 return resultobj;
22209 fail:
22210 return NULL;
22211 }
22212
22213
22214 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22215 PyObject *resultobj;
22216 wxDateTime *arg1 = (wxDateTime *) 0 ;
22217 wxTimeSpan *arg2 = 0 ;
22218 wxDateTime *result;
22219 PyObject * obj0 = 0 ;
22220 PyObject * obj1 = 0 ;
22221 char *kwnames[] = {
22222 (char *) "self",(char *) "diff", NULL
22223 };
22224
22225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22227 if (SWIG_arg_fail(1)) SWIG_fail;
22228 {
22229 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22230 if (SWIG_arg_fail(2)) SWIG_fail;
22231 if (arg2 == NULL) {
22232 SWIG_null_ref("wxTimeSpan");
22233 }
22234 if (SWIG_arg_fail(2)) SWIG_fail;
22235 }
22236 {
22237 PyThreadState* __tstate = wxPyBeginAllowThreads();
22238 {
22239 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22240 result = (wxDateTime *) &_result_ref;
22241 }
22242
22243 wxPyEndAllowThreads(__tstate);
22244 if (PyErr_Occurred()) SWIG_fail;
22245 }
22246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22247 return resultobj;
22248 fail:
22249 return NULL;
22250 }
22251
22252
22253 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22254 PyObject *resultobj;
22255 wxDateTime *arg1 = (wxDateTime *) 0 ;
22256 wxDateSpan *arg2 = 0 ;
22257 wxDateTime *result;
22258 PyObject * obj0 = 0 ;
22259 PyObject * obj1 = 0 ;
22260 char *kwnames[] = {
22261 (char *) "self",(char *) "diff", NULL
22262 };
22263
22264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22266 if (SWIG_arg_fail(1)) SWIG_fail;
22267 {
22268 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22269 if (SWIG_arg_fail(2)) SWIG_fail;
22270 if (arg2 == NULL) {
22271 SWIG_null_ref("wxDateSpan");
22272 }
22273 if (SWIG_arg_fail(2)) SWIG_fail;
22274 }
22275 {
22276 PyThreadState* __tstate = wxPyBeginAllowThreads();
22277 {
22278 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22279 result = (wxDateTime *) &_result_ref;
22280 }
22281
22282 wxPyEndAllowThreads(__tstate);
22283 if (PyErr_Occurred()) SWIG_fail;
22284 }
22285 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22286 return resultobj;
22287 fail:
22288 return NULL;
22289 }
22290
22291
22292 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22293 PyObject *resultobj;
22294 wxDateTime *arg1 = (wxDateTime *) 0 ;
22295 wxDateTime *arg2 = 0 ;
22296 wxTimeSpan result;
22297 PyObject * obj0 = 0 ;
22298 PyObject * obj1 = 0 ;
22299 char *kwnames[] = {
22300 (char *) "self",(char *) "dt", NULL
22301 };
22302
22303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22305 if (SWIG_arg_fail(1)) SWIG_fail;
22306 {
22307 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22308 if (SWIG_arg_fail(2)) SWIG_fail;
22309 if (arg2 == NULL) {
22310 SWIG_null_ref("wxDateTime");
22311 }
22312 if (SWIG_arg_fail(2)) SWIG_fail;
22313 }
22314 {
22315 PyThreadState* __tstate = wxPyBeginAllowThreads();
22316 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22317
22318 wxPyEndAllowThreads(__tstate);
22319 if (PyErr_Occurred()) SWIG_fail;
22320 }
22321 {
22322 wxTimeSpan * resultptr;
22323 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22324 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22325 }
22326 return resultobj;
22327 fail:
22328 return NULL;
22329 }
22330
22331
22332 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22333 PyObject *resultobj;
22334 wxDateTime *arg1 = (wxDateTime *) 0 ;
22335 wxTimeSpan *arg2 = 0 ;
22336 wxDateTime *result;
22337 PyObject * obj0 = 0 ;
22338 PyObject * obj1 = 0 ;
22339
22340 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22342 if (SWIG_arg_fail(1)) SWIG_fail;
22343 {
22344 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22345 if (SWIG_arg_fail(2)) SWIG_fail;
22346 if (arg2 == NULL) {
22347 SWIG_null_ref("wxTimeSpan");
22348 }
22349 if (SWIG_arg_fail(2)) SWIG_fail;
22350 }
22351 {
22352 PyThreadState* __tstate = wxPyBeginAllowThreads();
22353 {
22354 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22355 result = (wxDateTime *) &_result_ref;
22356 }
22357
22358 wxPyEndAllowThreads(__tstate);
22359 if (PyErr_Occurred()) SWIG_fail;
22360 }
22361 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22362 return resultobj;
22363 fail:
22364 return NULL;
22365 }
22366
22367
22368 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22369 PyObject *resultobj;
22370 wxDateTime *arg1 = (wxDateTime *) 0 ;
22371 wxDateSpan *arg2 = 0 ;
22372 wxDateTime *result;
22373 PyObject * obj0 = 0 ;
22374 PyObject * obj1 = 0 ;
22375
22376 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22378 if (SWIG_arg_fail(1)) SWIG_fail;
22379 {
22380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22381 if (SWIG_arg_fail(2)) SWIG_fail;
22382 if (arg2 == NULL) {
22383 SWIG_null_ref("wxDateSpan");
22384 }
22385 if (SWIG_arg_fail(2)) SWIG_fail;
22386 }
22387 {
22388 PyThreadState* __tstate = wxPyBeginAllowThreads();
22389 {
22390 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22391 result = (wxDateTime *) &_result_ref;
22392 }
22393
22394 wxPyEndAllowThreads(__tstate);
22395 if (PyErr_Occurred()) SWIG_fail;
22396 }
22397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22398 return resultobj;
22399 fail:
22400 return NULL;
22401 }
22402
22403
22404 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22405 int argc;
22406 PyObject *argv[3];
22407 int ii;
22408
22409 argc = PyObject_Length(args);
22410 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22411 argv[ii] = PyTuple_GetItem(args,ii);
22412 }
22413 if (argc == 2) {
22414 int _v;
22415 {
22416 void *ptr;
22417 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22418 _v = 0;
22419 PyErr_Clear();
22420 } else {
22421 _v = 1;
22422 }
22423 }
22424 if (_v) {
22425 {
22426 void *ptr = 0;
22427 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22428 _v = 0;
22429 PyErr_Clear();
22430 } else {
22431 _v = (ptr != 0);
22432 }
22433 }
22434 if (_v) {
22435 return _wrap_DateTime___iadd____SWIG_0(self,args);
22436 }
22437 }
22438 }
22439 if (argc == 2) {
22440 int _v;
22441 {
22442 void *ptr;
22443 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22444 _v = 0;
22445 PyErr_Clear();
22446 } else {
22447 _v = 1;
22448 }
22449 }
22450 if (_v) {
22451 {
22452 void *ptr = 0;
22453 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22454 _v = 0;
22455 PyErr_Clear();
22456 } else {
22457 _v = (ptr != 0);
22458 }
22459 }
22460 if (_v) {
22461 return _wrap_DateTime___iadd____SWIG_1(self,args);
22462 }
22463 }
22464 }
22465
22466 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22467 return NULL;
22468 }
22469
22470
22471 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22472 PyObject *resultobj;
22473 wxDateTime *arg1 = (wxDateTime *) 0 ;
22474 wxTimeSpan *arg2 = 0 ;
22475 wxDateTime *result;
22476 PyObject * obj0 = 0 ;
22477 PyObject * obj1 = 0 ;
22478
22479 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22481 if (SWIG_arg_fail(1)) SWIG_fail;
22482 {
22483 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22484 if (SWIG_arg_fail(2)) SWIG_fail;
22485 if (arg2 == NULL) {
22486 SWIG_null_ref("wxTimeSpan");
22487 }
22488 if (SWIG_arg_fail(2)) SWIG_fail;
22489 }
22490 {
22491 PyThreadState* __tstate = wxPyBeginAllowThreads();
22492 {
22493 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22494 result = (wxDateTime *) &_result_ref;
22495 }
22496
22497 wxPyEndAllowThreads(__tstate);
22498 if (PyErr_Occurred()) SWIG_fail;
22499 }
22500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22501 return resultobj;
22502 fail:
22503 return NULL;
22504 }
22505
22506
22507 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22508 PyObject *resultobj;
22509 wxDateTime *arg1 = (wxDateTime *) 0 ;
22510 wxDateSpan *arg2 = 0 ;
22511 wxDateTime *result;
22512 PyObject * obj0 = 0 ;
22513 PyObject * obj1 = 0 ;
22514
22515 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
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)->operator -=((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, 1);
22537 return resultobj;
22538 fail:
22539 return NULL;
22540 }
22541
22542
22543 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22544 int argc;
22545 PyObject *argv[3];
22546 int ii;
22547
22548 argc = PyObject_Length(args);
22549 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22550 argv[ii] = PyTuple_GetItem(args,ii);
22551 }
22552 if (argc == 2) {
22553 int _v;
22554 {
22555 void *ptr;
22556 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22557 _v = 0;
22558 PyErr_Clear();
22559 } else {
22560 _v = 1;
22561 }
22562 }
22563 if (_v) {
22564 {
22565 void *ptr = 0;
22566 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22567 _v = 0;
22568 PyErr_Clear();
22569 } else {
22570 _v = (ptr != 0);
22571 }
22572 }
22573 if (_v) {
22574 return _wrap_DateTime___isub____SWIG_0(self,args);
22575 }
22576 }
22577 }
22578 if (argc == 2) {
22579 int _v;
22580 {
22581 void *ptr;
22582 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22583 _v = 0;
22584 PyErr_Clear();
22585 } else {
22586 _v = 1;
22587 }
22588 }
22589 if (_v) {
22590 {
22591 void *ptr = 0;
22592 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22593 _v = 0;
22594 PyErr_Clear();
22595 } else {
22596 _v = (ptr != 0);
22597 }
22598 }
22599 if (_v) {
22600 return _wrap_DateTime___isub____SWIG_1(self,args);
22601 }
22602 }
22603 }
22604
22605 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22606 return NULL;
22607 }
22608
22609
22610 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22611 PyObject *resultobj;
22612 wxDateTime *arg1 = (wxDateTime *) 0 ;
22613 wxTimeSpan *arg2 = 0 ;
22614 wxDateTime result;
22615 PyObject * obj0 = 0 ;
22616 PyObject * obj1 = 0 ;
22617
22618 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22620 if (SWIG_arg_fail(1)) SWIG_fail;
22621 {
22622 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22623 if (SWIG_arg_fail(2)) SWIG_fail;
22624 if (arg2 == NULL) {
22625 SWIG_null_ref("wxTimeSpan");
22626 }
22627 if (SWIG_arg_fail(2)) SWIG_fail;
22628 }
22629 {
22630 PyThreadState* __tstate = wxPyBeginAllowThreads();
22631 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22632
22633 wxPyEndAllowThreads(__tstate);
22634 if (PyErr_Occurred()) SWIG_fail;
22635 }
22636 {
22637 wxDateTime * resultptr;
22638 resultptr = new wxDateTime((wxDateTime &)(result));
22639 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22640 }
22641 return resultobj;
22642 fail:
22643 return NULL;
22644 }
22645
22646
22647 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22648 PyObject *resultobj;
22649 wxDateTime *arg1 = (wxDateTime *) 0 ;
22650 wxDateSpan *arg2 = 0 ;
22651 wxDateTime result;
22652 PyObject * obj0 = 0 ;
22653 PyObject * obj1 = 0 ;
22654
22655 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22657 if (SWIG_arg_fail(1)) SWIG_fail;
22658 {
22659 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22660 if (SWIG_arg_fail(2)) SWIG_fail;
22661 if (arg2 == NULL) {
22662 SWIG_null_ref("wxDateSpan");
22663 }
22664 if (SWIG_arg_fail(2)) SWIG_fail;
22665 }
22666 {
22667 PyThreadState* __tstate = wxPyBeginAllowThreads();
22668 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22669
22670 wxPyEndAllowThreads(__tstate);
22671 if (PyErr_Occurred()) SWIG_fail;
22672 }
22673 {
22674 wxDateTime * resultptr;
22675 resultptr = new wxDateTime((wxDateTime &)(result));
22676 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22677 }
22678 return resultobj;
22679 fail:
22680 return NULL;
22681 }
22682
22683
22684 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22685 int argc;
22686 PyObject *argv[3];
22687 int ii;
22688
22689 argc = PyObject_Length(args);
22690 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22691 argv[ii] = PyTuple_GetItem(args,ii);
22692 }
22693 if (argc == 2) {
22694 int _v;
22695 {
22696 void *ptr;
22697 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22698 _v = 0;
22699 PyErr_Clear();
22700 } else {
22701 _v = 1;
22702 }
22703 }
22704 if (_v) {
22705 {
22706 void *ptr = 0;
22707 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22708 _v = 0;
22709 PyErr_Clear();
22710 } else {
22711 _v = (ptr != 0);
22712 }
22713 }
22714 if (_v) {
22715 return _wrap_DateTime___add____SWIG_0(self,args);
22716 }
22717 }
22718 }
22719 if (argc == 2) {
22720 int _v;
22721 {
22722 void *ptr;
22723 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22724 _v = 0;
22725 PyErr_Clear();
22726 } else {
22727 _v = 1;
22728 }
22729 }
22730 if (_v) {
22731 {
22732 void *ptr = 0;
22733 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22734 _v = 0;
22735 PyErr_Clear();
22736 } else {
22737 _v = (ptr != 0);
22738 }
22739 }
22740 if (_v) {
22741 return _wrap_DateTime___add____SWIG_1(self,args);
22742 }
22743 }
22744 }
22745
22746 Py_INCREF(Py_NotImplemented);
22747 return Py_NotImplemented;
22748 }
22749
22750
22751 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22752 PyObject *resultobj;
22753 wxDateTime *arg1 = (wxDateTime *) 0 ;
22754 wxDateTime *arg2 = 0 ;
22755 wxTimeSpan result;
22756 PyObject * obj0 = 0 ;
22757 PyObject * obj1 = 0 ;
22758
22759 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22761 if (SWIG_arg_fail(1)) SWIG_fail;
22762 {
22763 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22764 if (SWIG_arg_fail(2)) SWIG_fail;
22765 if (arg2 == NULL) {
22766 SWIG_null_ref("wxDateTime");
22767 }
22768 if (SWIG_arg_fail(2)) SWIG_fail;
22769 }
22770 {
22771 PyThreadState* __tstate = wxPyBeginAllowThreads();
22772 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22773
22774 wxPyEndAllowThreads(__tstate);
22775 if (PyErr_Occurred()) SWIG_fail;
22776 }
22777 {
22778 wxTimeSpan * resultptr;
22779 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22780 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22781 }
22782 return resultobj;
22783 fail:
22784 return NULL;
22785 }
22786
22787
22788 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22789 PyObject *resultobj;
22790 wxDateTime *arg1 = (wxDateTime *) 0 ;
22791 wxTimeSpan *arg2 = 0 ;
22792 wxDateTime result;
22793 PyObject * obj0 = 0 ;
22794 PyObject * obj1 = 0 ;
22795
22796 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22798 if (SWIG_arg_fail(1)) SWIG_fail;
22799 {
22800 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22801 if (SWIG_arg_fail(2)) SWIG_fail;
22802 if (arg2 == NULL) {
22803 SWIG_null_ref("wxTimeSpan");
22804 }
22805 if (SWIG_arg_fail(2)) SWIG_fail;
22806 }
22807 {
22808 PyThreadState* __tstate = wxPyBeginAllowThreads();
22809 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22810
22811 wxPyEndAllowThreads(__tstate);
22812 if (PyErr_Occurred()) SWIG_fail;
22813 }
22814 {
22815 wxDateTime * resultptr;
22816 resultptr = new wxDateTime((wxDateTime &)(result));
22817 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22818 }
22819 return resultobj;
22820 fail:
22821 return NULL;
22822 }
22823
22824
22825 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22826 PyObject *resultobj;
22827 wxDateTime *arg1 = (wxDateTime *) 0 ;
22828 wxDateSpan *arg2 = 0 ;
22829 wxDateTime result;
22830 PyObject * obj0 = 0 ;
22831 PyObject * obj1 = 0 ;
22832
22833 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22835 if (SWIG_arg_fail(1)) SWIG_fail;
22836 {
22837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22838 if (SWIG_arg_fail(2)) SWIG_fail;
22839 if (arg2 == NULL) {
22840 SWIG_null_ref("wxDateSpan");
22841 }
22842 if (SWIG_arg_fail(2)) SWIG_fail;
22843 }
22844 {
22845 PyThreadState* __tstate = wxPyBeginAllowThreads();
22846 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22847
22848 wxPyEndAllowThreads(__tstate);
22849 if (PyErr_Occurred()) SWIG_fail;
22850 }
22851 {
22852 wxDateTime * resultptr;
22853 resultptr = new wxDateTime((wxDateTime &)(result));
22854 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22855 }
22856 return resultobj;
22857 fail:
22858 return NULL;
22859 }
22860
22861
22862 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
22863 int argc;
22864 PyObject *argv[3];
22865 int ii;
22866
22867 argc = PyObject_Length(args);
22868 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22869 argv[ii] = PyTuple_GetItem(args,ii);
22870 }
22871 if (argc == 2) {
22872 int _v;
22873 {
22874 void *ptr;
22875 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22876 _v = 0;
22877 PyErr_Clear();
22878 } else {
22879 _v = 1;
22880 }
22881 }
22882 if (_v) {
22883 {
22884 void *ptr = 0;
22885 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22886 _v = 0;
22887 PyErr_Clear();
22888 } else {
22889 _v = (ptr != 0);
22890 }
22891 }
22892 if (_v) {
22893 return _wrap_DateTime___sub____SWIG_0(self,args);
22894 }
22895 }
22896 }
22897 if (argc == 2) {
22898 int _v;
22899 {
22900 void *ptr;
22901 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22902 _v = 0;
22903 PyErr_Clear();
22904 } else {
22905 _v = 1;
22906 }
22907 }
22908 if (_v) {
22909 {
22910 void *ptr = 0;
22911 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22912 _v = 0;
22913 PyErr_Clear();
22914 } else {
22915 _v = (ptr != 0);
22916 }
22917 }
22918 if (_v) {
22919 return _wrap_DateTime___sub____SWIG_1(self,args);
22920 }
22921 }
22922 }
22923 if (argc == 2) {
22924 int _v;
22925 {
22926 void *ptr;
22927 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22928 _v = 0;
22929 PyErr_Clear();
22930 } else {
22931 _v = 1;
22932 }
22933 }
22934 if (_v) {
22935 {
22936 void *ptr = 0;
22937 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22938 _v = 0;
22939 PyErr_Clear();
22940 } else {
22941 _v = (ptr != 0);
22942 }
22943 }
22944 if (_v) {
22945 return _wrap_DateTime___sub____SWIG_2(self,args);
22946 }
22947 }
22948 }
22949
22950 Py_INCREF(Py_NotImplemented);
22951 return Py_NotImplemented;
22952 }
22953
22954
22955 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args) {
22956 PyObject *resultobj;
22957 wxDateTime *arg1 = (wxDateTime *) 0 ;
22958 wxDateTime *arg2 = (wxDateTime *) 0 ;
22959 bool result;
22960 PyObject * obj0 = 0 ;
22961 PyObject * obj1 = 0 ;
22962
22963 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___lt__",&obj0,&obj1)) goto fail;
22964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22965 if (SWIG_arg_fail(1)) SWIG_fail;
22966 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22967 if (SWIG_arg_fail(2)) SWIG_fail;
22968 {
22969 PyThreadState* __tstate = wxPyBeginAllowThreads();
22970 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
22971
22972 wxPyEndAllowThreads(__tstate);
22973 if (PyErr_Occurred()) SWIG_fail;
22974 }
22975 {
22976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22977 }
22978 return resultobj;
22979 fail:
22980 return NULL;
22981 }
22982
22983
22984 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args) {
22985 PyObject *resultobj;
22986 wxDateTime *arg1 = (wxDateTime *) 0 ;
22987 wxDateTime *arg2 = (wxDateTime *) 0 ;
22988 bool result;
22989 PyObject * obj0 = 0 ;
22990 PyObject * obj1 = 0 ;
22991
22992 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___le__",&obj0,&obj1)) goto fail;
22993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22994 if (SWIG_arg_fail(1)) SWIG_fail;
22995 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22996 if (SWIG_arg_fail(2)) SWIG_fail;
22997 {
22998 PyThreadState* __tstate = wxPyBeginAllowThreads();
22999 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23000
23001 wxPyEndAllowThreads(__tstate);
23002 if (PyErr_Occurred()) SWIG_fail;
23003 }
23004 {
23005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23006 }
23007 return resultobj;
23008 fail:
23009 return NULL;
23010 }
23011
23012
23013 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args) {
23014 PyObject *resultobj;
23015 wxDateTime *arg1 = (wxDateTime *) 0 ;
23016 wxDateTime *arg2 = (wxDateTime *) 0 ;
23017 bool result;
23018 PyObject * obj0 = 0 ;
23019 PyObject * obj1 = 0 ;
23020
23021 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___gt__",&obj0,&obj1)) goto fail;
23022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23023 if (SWIG_arg_fail(1)) SWIG_fail;
23024 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23025 if (SWIG_arg_fail(2)) SWIG_fail;
23026 {
23027 PyThreadState* __tstate = wxPyBeginAllowThreads();
23028 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23029
23030 wxPyEndAllowThreads(__tstate);
23031 if (PyErr_Occurred()) SWIG_fail;
23032 }
23033 {
23034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23035 }
23036 return resultobj;
23037 fail:
23038 return NULL;
23039 }
23040
23041
23042 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args) {
23043 PyObject *resultobj;
23044 wxDateTime *arg1 = (wxDateTime *) 0 ;
23045 wxDateTime *arg2 = (wxDateTime *) 0 ;
23046 bool result;
23047 PyObject * obj0 = 0 ;
23048 PyObject * obj1 = 0 ;
23049
23050 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___ge__",&obj0,&obj1)) goto fail;
23051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23052 if (SWIG_arg_fail(1)) SWIG_fail;
23053 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23054 if (SWIG_arg_fail(2)) SWIG_fail;
23055 {
23056 PyThreadState* __tstate = wxPyBeginAllowThreads();
23057 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23058
23059 wxPyEndAllowThreads(__tstate);
23060 if (PyErr_Occurred()) SWIG_fail;
23061 }
23062 {
23063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23064 }
23065 return resultobj;
23066 fail:
23067 return NULL;
23068 }
23069
23070
23071 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args) {
23072 PyObject *resultobj;
23073 wxDateTime *arg1 = (wxDateTime *) 0 ;
23074 wxDateTime *arg2 = (wxDateTime *) 0 ;
23075 bool result;
23076 PyObject * obj0 = 0 ;
23077 PyObject * obj1 = 0 ;
23078
23079 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___eq__",&obj0,&obj1)) goto fail;
23080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23081 if (SWIG_arg_fail(1)) SWIG_fail;
23082 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23083 if (SWIG_arg_fail(2)) SWIG_fail;
23084 {
23085 PyThreadState* __tstate = wxPyBeginAllowThreads();
23086 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23087
23088 wxPyEndAllowThreads(__tstate);
23089 if (PyErr_Occurred()) SWIG_fail;
23090 }
23091 {
23092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23093 }
23094 return resultobj;
23095 fail:
23096 return NULL;
23097 }
23098
23099
23100 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args) {
23101 PyObject *resultobj;
23102 wxDateTime *arg1 = (wxDateTime *) 0 ;
23103 wxDateTime *arg2 = (wxDateTime *) 0 ;
23104 bool result;
23105 PyObject * obj0 = 0 ;
23106 PyObject * obj1 = 0 ;
23107
23108 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___ne__",&obj0,&obj1)) goto fail;
23109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23110 if (SWIG_arg_fail(1)) SWIG_fail;
23111 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23112 if (SWIG_arg_fail(2)) SWIG_fail;
23113 {
23114 PyThreadState* __tstate = wxPyBeginAllowThreads();
23115 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23116
23117 wxPyEndAllowThreads(__tstate);
23118 if (PyErr_Occurred()) SWIG_fail;
23119 }
23120 {
23121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23122 }
23123 return resultobj;
23124 fail:
23125 return NULL;
23126 }
23127
23128
23129 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23130 PyObject *resultobj;
23131 wxDateTime *arg1 = (wxDateTime *) 0 ;
23132 wxString *arg2 = 0 ;
23133 int result;
23134 bool temp2 = false ;
23135 PyObject * obj0 = 0 ;
23136 PyObject * obj1 = 0 ;
23137 char *kwnames[] = {
23138 (char *) "self",(char *) "date", NULL
23139 };
23140
23141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23143 if (SWIG_arg_fail(1)) SWIG_fail;
23144 {
23145 arg2 = wxString_in_helper(obj1);
23146 if (arg2 == NULL) SWIG_fail;
23147 temp2 = true;
23148 }
23149 {
23150 PyThreadState* __tstate = wxPyBeginAllowThreads();
23151 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23152
23153 wxPyEndAllowThreads(__tstate);
23154 if (PyErr_Occurred()) SWIG_fail;
23155 }
23156 {
23157 resultobj = SWIG_From_int((int)(result));
23158 }
23159 {
23160 if (temp2)
23161 delete arg2;
23162 }
23163 return resultobj;
23164 fail:
23165 {
23166 if (temp2)
23167 delete arg2;
23168 }
23169 return NULL;
23170 }
23171
23172
23173 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23174 PyObject *resultobj;
23175 wxDateTime *arg1 = (wxDateTime *) 0 ;
23176 wxString *arg2 = 0 ;
23177 wxString const &arg3_defvalue = wxPyDateFormatStr ;
23178 wxString *arg3 = (wxString *) &arg3_defvalue ;
23179 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23180 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23181 int result;
23182 bool temp2 = false ;
23183 bool temp3 = false ;
23184 PyObject * obj0 = 0 ;
23185 PyObject * obj1 = 0 ;
23186 PyObject * obj2 = 0 ;
23187 PyObject * obj3 = 0 ;
23188 char *kwnames[] = {
23189 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23190 };
23191
23192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23194 if (SWIG_arg_fail(1)) SWIG_fail;
23195 {
23196 arg2 = wxString_in_helper(obj1);
23197 if (arg2 == NULL) SWIG_fail;
23198 temp2 = true;
23199 }
23200 if (obj2) {
23201 {
23202 arg3 = wxString_in_helper(obj2);
23203 if (arg3 == NULL) SWIG_fail;
23204 temp3 = true;
23205 }
23206 }
23207 if (obj3) {
23208 {
23209 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23210 if (SWIG_arg_fail(4)) SWIG_fail;
23211 if (arg4 == NULL) {
23212 SWIG_null_ref("wxDateTime");
23213 }
23214 if (SWIG_arg_fail(4)) SWIG_fail;
23215 }
23216 }
23217 {
23218 PyThreadState* __tstate = wxPyBeginAllowThreads();
23219 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23220
23221 wxPyEndAllowThreads(__tstate);
23222 if (PyErr_Occurred()) SWIG_fail;
23223 }
23224 {
23225 resultobj = SWIG_From_int((int)(result));
23226 }
23227 {
23228 if (temp2)
23229 delete arg2;
23230 }
23231 {
23232 if (temp3)
23233 delete arg3;
23234 }
23235 return resultobj;
23236 fail:
23237 {
23238 if (temp2)
23239 delete arg2;
23240 }
23241 {
23242 if (temp3)
23243 delete arg3;
23244 }
23245 return NULL;
23246 }
23247
23248
23249 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23250 PyObject *resultobj;
23251 wxDateTime *arg1 = (wxDateTime *) 0 ;
23252 wxString *arg2 = 0 ;
23253 int result;
23254 bool temp2 = false ;
23255 PyObject * obj0 = 0 ;
23256 PyObject * obj1 = 0 ;
23257 char *kwnames[] = {
23258 (char *) "self",(char *) "datetime", NULL
23259 };
23260
23261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23263 if (SWIG_arg_fail(1)) SWIG_fail;
23264 {
23265 arg2 = wxString_in_helper(obj1);
23266 if (arg2 == NULL) SWIG_fail;
23267 temp2 = true;
23268 }
23269 {
23270 PyThreadState* __tstate = wxPyBeginAllowThreads();
23271 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23272
23273 wxPyEndAllowThreads(__tstate);
23274 if (PyErr_Occurred()) SWIG_fail;
23275 }
23276 {
23277 resultobj = SWIG_From_int((int)(result));
23278 }
23279 {
23280 if (temp2)
23281 delete arg2;
23282 }
23283 return resultobj;
23284 fail:
23285 {
23286 if (temp2)
23287 delete arg2;
23288 }
23289 return NULL;
23290 }
23291
23292
23293 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23294 PyObject *resultobj;
23295 wxDateTime *arg1 = (wxDateTime *) 0 ;
23296 wxString *arg2 = 0 ;
23297 int result;
23298 bool temp2 = false ;
23299 PyObject * obj0 = 0 ;
23300 PyObject * obj1 = 0 ;
23301 char *kwnames[] = {
23302 (char *) "self",(char *) "date", NULL
23303 };
23304
23305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23307 if (SWIG_arg_fail(1)) SWIG_fail;
23308 {
23309 arg2 = wxString_in_helper(obj1);
23310 if (arg2 == NULL) SWIG_fail;
23311 temp2 = true;
23312 }
23313 {
23314 PyThreadState* __tstate = wxPyBeginAllowThreads();
23315 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23316
23317 wxPyEndAllowThreads(__tstate);
23318 if (PyErr_Occurred()) SWIG_fail;
23319 }
23320 {
23321 resultobj = SWIG_From_int((int)(result));
23322 }
23323 {
23324 if (temp2)
23325 delete arg2;
23326 }
23327 return resultobj;
23328 fail:
23329 {
23330 if (temp2)
23331 delete arg2;
23332 }
23333 return NULL;
23334 }
23335
23336
23337 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23338 PyObject *resultobj;
23339 wxDateTime *arg1 = (wxDateTime *) 0 ;
23340 wxString *arg2 = 0 ;
23341 int result;
23342 bool temp2 = false ;
23343 PyObject * obj0 = 0 ;
23344 PyObject * obj1 = 0 ;
23345 char *kwnames[] = {
23346 (char *) "self",(char *) "time", NULL
23347 };
23348
23349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23351 if (SWIG_arg_fail(1)) SWIG_fail;
23352 {
23353 arg2 = wxString_in_helper(obj1);
23354 if (arg2 == NULL) SWIG_fail;
23355 temp2 = true;
23356 }
23357 {
23358 PyThreadState* __tstate = wxPyBeginAllowThreads();
23359 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23360
23361 wxPyEndAllowThreads(__tstate);
23362 if (PyErr_Occurred()) SWIG_fail;
23363 }
23364 {
23365 resultobj = SWIG_From_int((int)(result));
23366 }
23367 {
23368 if (temp2)
23369 delete arg2;
23370 }
23371 return resultobj;
23372 fail:
23373 {
23374 if (temp2)
23375 delete arg2;
23376 }
23377 return NULL;
23378 }
23379
23380
23381 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23382 PyObject *resultobj;
23383 wxDateTime *arg1 = (wxDateTime *) 0 ;
23384 wxString const &arg2_defvalue = wxPyDateFormatStr ;
23385 wxString *arg2 = (wxString *) &arg2_defvalue ;
23386 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23387 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23388 wxString result;
23389 bool temp2 = false ;
23390 bool temp3 = false ;
23391 PyObject * obj0 = 0 ;
23392 PyObject * obj1 = 0 ;
23393 PyObject * obj2 = 0 ;
23394 char *kwnames[] = {
23395 (char *) "self",(char *) "format",(char *) "tz", NULL
23396 };
23397
23398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23400 if (SWIG_arg_fail(1)) SWIG_fail;
23401 if (obj1) {
23402 {
23403 arg2 = wxString_in_helper(obj1);
23404 if (arg2 == NULL) SWIG_fail;
23405 temp2 = true;
23406 }
23407 }
23408 if (obj2) {
23409 {
23410 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23411 temp3 = true;
23412 }
23413 }
23414 {
23415 PyThreadState* __tstate = wxPyBeginAllowThreads();
23416 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23417
23418 wxPyEndAllowThreads(__tstate);
23419 if (PyErr_Occurred()) SWIG_fail;
23420 }
23421 {
23422 #if wxUSE_UNICODE
23423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23424 #else
23425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23426 #endif
23427 }
23428 {
23429 if (temp2)
23430 delete arg2;
23431 }
23432 {
23433 if (temp3) delete arg3;
23434 }
23435 return resultobj;
23436 fail:
23437 {
23438 if (temp2)
23439 delete arg2;
23440 }
23441 {
23442 if (temp3) delete arg3;
23443 }
23444 return NULL;
23445 }
23446
23447
23448 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23449 PyObject *resultobj;
23450 wxDateTime *arg1 = (wxDateTime *) 0 ;
23451 wxString result;
23452 PyObject * obj0 = 0 ;
23453 char *kwnames[] = {
23454 (char *) "self", NULL
23455 };
23456
23457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23459 if (SWIG_arg_fail(1)) SWIG_fail;
23460 {
23461 PyThreadState* __tstate = wxPyBeginAllowThreads();
23462 result = ((wxDateTime const *)arg1)->FormatDate();
23463
23464 wxPyEndAllowThreads(__tstate);
23465 if (PyErr_Occurred()) SWIG_fail;
23466 }
23467 {
23468 #if wxUSE_UNICODE
23469 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23470 #else
23471 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23472 #endif
23473 }
23474 return resultobj;
23475 fail:
23476 return NULL;
23477 }
23478
23479
23480 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23481 PyObject *resultobj;
23482 wxDateTime *arg1 = (wxDateTime *) 0 ;
23483 wxString result;
23484 PyObject * obj0 = 0 ;
23485 char *kwnames[] = {
23486 (char *) "self", NULL
23487 };
23488
23489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23491 if (SWIG_arg_fail(1)) SWIG_fail;
23492 {
23493 PyThreadState* __tstate = wxPyBeginAllowThreads();
23494 result = ((wxDateTime const *)arg1)->FormatTime();
23495
23496 wxPyEndAllowThreads(__tstate);
23497 if (PyErr_Occurred()) SWIG_fail;
23498 }
23499 {
23500 #if wxUSE_UNICODE
23501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23502 #else
23503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23504 #endif
23505 }
23506 return resultobj;
23507 fail:
23508 return NULL;
23509 }
23510
23511
23512 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23513 PyObject *resultobj;
23514 wxDateTime *arg1 = (wxDateTime *) 0 ;
23515 wxString result;
23516 PyObject * obj0 = 0 ;
23517 char *kwnames[] = {
23518 (char *) "self", NULL
23519 };
23520
23521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23523 if (SWIG_arg_fail(1)) SWIG_fail;
23524 {
23525 PyThreadState* __tstate = wxPyBeginAllowThreads();
23526 result = ((wxDateTime const *)arg1)->FormatISODate();
23527
23528 wxPyEndAllowThreads(__tstate);
23529 if (PyErr_Occurred()) SWIG_fail;
23530 }
23531 {
23532 #if wxUSE_UNICODE
23533 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23534 #else
23535 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23536 #endif
23537 }
23538 return resultobj;
23539 fail:
23540 return NULL;
23541 }
23542
23543
23544 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23545 PyObject *resultobj;
23546 wxDateTime *arg1 = (wxDateTime *) 0 ;
23547 wxString result;
23548 PyObject * obj0 = 0 ;
23549 char *kwnames[] = {
23550 (char *) "self", NULL
23551 };
23552
23553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23555 if (SWIG_arg_fail(1)) SWIG_fail;
23556 {
23557 PyThreadState* __tstate = wxPyBeginAllowThreads();
23558 result = ((wxDateTime const *)arg1)->FormatISOTime();
23559
23560 wxPyEndAllowThreads(__tstate);
23561 if (PyErr_Occurred()) SWIG_fail;
23562 }
23563 {
23564 #if wxUSE_UNICODE
23565 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23566 #else
23567 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23568 #endif
23569 }
23570 return resultobj;
23571 fail:
23572 return NULL;
23573 }
23574
23575
23576 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23577 PyObject *obj;
23578 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23579 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23580 Py_INCREF(obj);
23581 return Py_BuildValue((char *)"");
23582 }
23583 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23584 PyObject *resultobj;
23585 long arg1 ;
23586 wxTimeSpan result;
23587 PyObject * obj0 = 0 ;
23588 char *kwnames[] = {
23589 (char *) "sec", NULL
23590 };
23591
23592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23593 {
23594 arg1 = (long)(SWIG_As_long(obj0));
23595 if (SWIG_arg_fail(1)) SWIG_fail;
23596 }
23597 {
23598 PyThreadState* __tstate = wxPyBeginAllowThreads();
23599 result = wxTimeSpan::Seconds(arg1);
23600
23601 wxPyEndAllowThreads(__tstate);
23602 if (PyErr_Occurred()) SWIG_fail;
23603 }
23604 {
23605 wxTimeSpan * resultptr;
23606 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23607 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23608 }
23609 return resultobj;
23610 fail:
23611 return NULL;
23612 }
23613
23614
23615 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23616 PyObject *resultobj;
23617 wxTimeSpan result;
23618 char *kwnames[] = {
23619 NULL
23620 };
23621
23622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23623 {
23624 PyThreadState* __tstate = wxPyBeginAllowThreads();
23625 result = wxTimeSpan::Second();
23626
23627 wxPyEndAllowThreads(__tstate);
23628 if (PyErr_Occurred()) SWIG_fail;
23629 }
23630 {
23631 wxTimeSpan * resultptr;
23632 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23633 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23634 }
23635 return resultobj;
23636 fail:
23637 return NULL;
23638 }
23639
23640
23641 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23642 PyObject *resultobj;
23643 long arg1 ;
23644 wxTimeSpan result;
23645 PyObject * obj0 = 0 ;
23646 char *kwnames[] = {
23647 (char *) "min", NULL
23648 };
23649
23650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23651 {
23652 arg1 = (long)(SWIG_As_long(obj0));
23653 if (SWIG_arg_fail(1)) SWIG_fail;
23654 }
23655 {
23656 PyThreadState* __tstate = wxPyBeginAllowThreads();
23657 result = wxTimeSpan::Minutes(arg1);
23658
23659 wxPyEndAllowThreads(__tstate);
23660 if (PyErr_Occurred()) SWIG_fail;
23661 }
23662 {
23663 wxTimeSpan * resultptr;
23664 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23665 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23666 }
23667 return resultobj;
23668 fail:
23669 return NULL;
23670 }
23671
23672
23673 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23674 PyObject *resultobj;
23675 wxTimeSpan result;
23676 char *kwnames[] = {
23677 NULL
23678 };
23679
23680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23681 {
23682 PyThreadState* __tstate = wxPyBeginAllowThreads();
23683 result = wxTimeSpan::Minute();
23684
23685 wxPyEndAllowThreads(__tstate);
23686 if (PyErr_Occurred()) SWIG_fail;
23687 }
23688 {
23689 wxTimeSpan * resultptr;
23690 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23691 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23692 }
23693 return resultobj;
23694 fail:
23695 return NULL;
23696 }
23697
23698
23699 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23700 PyObject *resultobj;
23701 long arg1 ;
23702 wxTimeSpan result;
23703 PyObject * obj0 = 0 ;
23704 char *kwnames[] = {
23705 (char *) "hours", NULL
23706 };
23707
23708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23709 {
23710 arg1 = (long)(SWIG_As_long(obj0));
23711 if (SWIG_arg_fail(1)) SWIG_fail;
23712 }
23713 {
23714 PyThreadState* __tstate = wxPyBeginAllowThreads();
23715 result = wxTimeSpan::Hours(arg1);
23716
23717 wxPyEndAllowThreads(__tstate);
23718 if (PyErr_Occurred()) SWIG_fail;
23719 }
23720 {
23721 wxTimeSpan * resultptr;
23722 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23723 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23724 }
23725 return resultobj;
23726 fail:
23727 return NULL;
23728 }
23729
23730
23731 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23732 PyObject *resultobj;
23733 wxTimeSpan result;
23734 char *kwnames[] = {
23735 NULL
23736 };
23737
23738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23739 {
23740 PyThreadState* __tstate = wxPyBeginAllowThreads();
23741 result = wxTimeSpan::Hour();
23742
23743 wxPyEndAllowThreads(__tstate);
23744 if (PyErr_Occurred()) SWIG_fail;
23745 }
23746 {
23747 wxTimeSpan * resultptr;
23748 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23749 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23750 }
23751 return resultobj;
23752 fail:
23753 return NULL;
23754 }
23755
23756
23757 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23758 PyObject *resultobj;
23759 long arg1 ;
23760 wxTimeSpan result;
23761 PyObject * obj0 = 0 ;
23762 char *kwnames[] = {
23763 (char *) "days", NULL
23764 };
23765
23766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23767 {
23768 arg1 = (long)(SWIG_As_long(obj0));
23769 if (SWIG_arg_fail(1)) SWIG_fail;
23770 }
23771 {
23772 PyThreadState* __tstate = wxPyBeginAllowThreads();
23773 result = wxTimeSpan::Days(arg1);
23774
23775 wxPyEndAllowThreads(__tstate);
23776 if (PyErr_Occurred()) SWIG_fail;
23777 }
23778 {
23779 wxTimeSpan * resultptr;
23780 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23781 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23782 }
23783 return resultobj;
23784 fail:
23785 return NULL;
23786 }
23787
23788
23789 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23790 PyObject *resultobj;
23791 wxTimeSpan result;
23792 char *kwnames[] = {
23793 NULL
23794 };
23795
23796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23797 {
23798 PyThreadState* __tstate = wxPyBeginAllowThreads();
23799 result = wxTimeSpan::Day();
23800
23801 wxPyEndAllowThreads(__tstate);
23802 if (PyErr_Occurred()) SWIG_fail;
23803 }
23804 {
23805 wxTimeSpan * resultptr;
23806 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23807 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23808 }
23809 return resultobj;
23810 fail:
23811 return NULL;
23812 }
23813
23814
23815 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23816 PyObject *resultobj;
23817 long arg1 ;
23818 wxTimeSpan result;
23819 PyObject * obj0 = 0 ;
23820 char *kwnames[] = {
23821 (char *) "days", NULL
23822 };
23823
23824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23825 {
23826 arg1 = (long)(SWIG_As_long(obj0));
23827 if (SWIG_arg_fail(1)) SWIG_fail;
23828 }
23829 {
23830 PyThreadState* __tstate = wxPyBeginAllowThreads();
23831 result = wxTimeSpan::Weeks(arg1);
23832
23833 wxPyEndAllowThreads(__tstate);
23834 if (PyErr_Occurred()) SWIG_fail;
23835 }
23836 {
23837 wxTimeSpan * resultptr;
23838 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23839 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23840 }
23841 return resultobj;
23842 fail:
23843 return NULL;
23844 }
23845
23846
23847 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
23848 PyObject *resultobj;
23849 wxTimeSpan result;
23850 char *kwnames[] = {
23851 NULL
23852 };
23853
23854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
23855 {
23856 PyThreadState* __tstate = wxPyBeginAllowThreads();
23857 result = wxTimeSpan::Week();
23858
23859 wxPyEndAllowThreads(__tstate);
23860 if (PyErr_Occurred()) SWIG_fail;
23861 }
23862 {
23863 wxTimeSpan * resultptr;
23864 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23865 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23866 }
23867 return resultobj;
23868 fail:
23869 return NULL;
23870 }
23871
23872
23873 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23874 PyObject *resultobj;
23875 long arg1 = (long) 0 ;
23876 long arg2 = (long) 0 ;
23877 long arg3 = (long) 0 ;
23878 long arg4 = (long) 0 ;
23879 wxTimeSpan *result;
23880 PyObject * obj0 = 0 ;
23881 PyObject * obj1 = 0 ;
23882 PyObject * obj2 = 0 ;
23883 PyObject * obj3 = 0 ;
23884 char *kwnames[] = {
23885 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
23886 };
23887
23888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23889 if (obj0) {
23890 {
23891 arg1 = (long)(SWIG_As_long(obj0));
23892 if (SWIG_arg_fail(1)) SWIG_fail;
23893 }
23894 }
23895 if (obj1) {
23896 {
23897 arg2 = (long)(SWIG_As_long(obj1));
23898 if (SWIG_arg_fail(2)) SWIG_fail;
23899 }
23900 }
23901 if (obj2) {
23902 {
23903 arg3 = (long)(SWIG_As_long(obj2));
23904 if (SWIG_arg_fail(3)) SWIG_fail;
23905 }
23906 }
23907 if (obj3) {
23908 {
23909 arg4 = (long)(SWIG_As_long(obj3));
23910 if (SWIG_arg_fail(4)) SWIG_fail;
23911 }
23912 }
23913 {
23914 PyThreadState* __tstate = wxPyBeginAllowThreads();
23915 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
23916
23917 wxPyEndAllowThreads(__tstate);
23918 if (PyErr_Occurred()) SWIG_fail;
23919 }
23920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23921 return resultobj;
23922 fail:
23923 return NULL;
23924 }
23925
23926
23927 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23928 PyObject *resultobj;
23929 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23930 PyObject * obj0 = 0 ;
23931 char *kwnames[] = {
23932 (char *) "self", NULL
23933 };
23934
23935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
23936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23937 if (SWIG_arg_fail(1)) SWIG_fail;
23938 {
23939 PyThreadState* __tstate = wxPyBeginAllowThreads();
23940 delete arg1;
23941
23942 wxPyEndAllowThreads(__tstate);
23943 if (PyErr_Occurred()) SWIG_fail;
23944 }
23945 Py_INCREF(Py_None); resultobj = Py_None;
23946 return resultobj;
23947 fail:
23948 return NULL;
23949 }
23950
23951
23952 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
23953 PyObject *resultobj;
23954 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23955 wxTimeSpan *arg2 = 0 ;
23956 wxTimeSpan *result;
23957 PyObject * obj0 = 0 ;
23958 PyObject * obj1 = 0 ;
23959 char *kwnames[] = {
23960 (char *) "self",(char *) "diff", NULL
23961 };
23962
23963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
23964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23965 if (SWIG_arg_fail(1)) SWIG_fail;
23966 {
23967 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23968 if (SWIG_arg_fail(2)) SWIG_fail;
23969 if (arg2 == NULL) {
23970 SWIG_null_ref("wxTimeSpan");
23971 }
23972 if (SWIG_arg_fail(2)) SWIG_fail;
23973 }
23974 {
23975 PyThreadState* __tstate = wxPyBeginAllowThreads();
23976 {
23977 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
23978 result = (wxTimeSpan *) &_result_ref;
23979 }
23980
23981 wxPyEndAllowThreads(__tstate);
23982 if (PyErr_Occurred()) SWIG_fail;
23983 }
23984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23985 return resultobj;
23986 fail:
23987 return NULL;
23988 }
23989
23990
23991 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
23992 PyObject *resultobj;
23993 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23994 wxTimeSpan *arg2 = 0 ;
23995 wxTimeSpan *result;
23996 PyObject * obj0 = 0 ;
23997 PyObject * obj1 = 0 ;
23998 char *kwnames[] = {
23999 (char *) "self",(char *) "diff", NULL
24000 };
24001
24002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24004 if (SWIG_arg_fail(1)) SWIG_fail;
24005 {
24006 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24007 if (SWIG_arg_fail(2)) SWIG_fail;
24008 if (arg2 == NULL) {
24009 SWIG_null_ref("wxTimeSpan");
24010 }
24011 if (SWIG_arg_fail(2)) SWIG_fail;
24012 }
24013 {
24014 PyThreadState* __tstate = wxPyBeginAllowThreads();
24015 {
24016 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24017 result = (wxTimeSpan *) &_result_ref;
24018 }
24019
24020 wxPyEndAllowThreads(__tstate);
24021 if (PyErr_Occurred()) SWIG_fail;
24022 }
24023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24024 return resultobj;
24025 fail:
24026 return NULL;
24027 }
24028
24029
24030 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24031 PyObject *resultobj;
24032 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24033 int arg2 ;
24034 wxTimeSpan *result;
24035 PyObject * obj0 = 0 ;
24036 PyObject * obj1 = 0 ;
24037 char *kwnames[] = {
24038 (char *) "self",(char *) "n", NULL
24039 };
24040
24041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24043 if (SWIG_arg_fail(1)) SWIG_fail;
24044 {
24045 arg2 = (int)(SWIG_As_int(obj1));
24046 if (SWIG_arg_fail(2)) SWIG_fail;
24047 }
24048 {
24049 PyThreadState* __tstate = wxPyBeginAllowThreads();
24050 {
24051 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24052 result = (wxTimeSpan *) &_result_ref;
24053 }
24054
24055 wxPyEndAllowThreads(__tstate);
24056 if (PyErr_Occurred()) SWIG_fail;
24057 }
24058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24059 return resultobj;
24060 fail:
24061 return NULL;
24062 }
24063
24064
24065 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24066 PyObject *resultobj;
24067 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24068 wxTimeSpan *result;
24069 PyObject * obj0 = 0 ;
24070 char *kwnames[] = {
24071 (char *) "self", NULL
24072 };
24073
24074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24076 if (SWIG_arg_fail(1)) SWIG_fail;
24077 {
24078 PyThreadState* __tstate = wxPyBeginAllowThreads();
24079 {
24080 wxTimeSpan &_result_ref = (arg1)->Neg();
24081 result = (wxTimeSpan *) &_result_ref;
24082 }
24083
24084 wxPyEndAllowThreads(__tstate);
24085 if (PyErr_Occurred()) SWIG_fail;
24086 }
24087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24088 return resultobj;
24089 fail:
24090 return NULL;
24091 }
24092
24093
24094 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24095 PyObject *resultobj;
24096 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24097 wxTimeSpan result;
24098 PyObject * obj0 = 0 ;
24099 char *kwnames[] = {
24100 (char *) "self", NULL
24101 };
24102
24103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24105 if (SWIG_arg_fail(1)) SWIG_fail;
24106 {
24107 PyThreadState* __tstate = wxPyBeginAllowThreads();
24108 result = ((wxTimeSpan const *)arg1)->Abs();
24109
24110 wxPyEndAllowThreads(__tstate);
24111 if (PyErr_Occurred()) SWIG_fail;
24112 }
24113 {
24114 wxTimeSpan * resultptr;
24115 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24116 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24117 }
24118 return resultobj;
24119 fail:
24120 return NULL;
24121 }
24122
24123
24124 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24125 PyObject *resultobj;
24126 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24127 wxTimeSpan *arg2 = 0 ;
24128 wxTimeSpan *result;
24129 PyObject * obj0 = 0 ;
24130 PyObject * obj1 = 0 ;
24131 char *kwnames[] = {
24132 (char *) "self",(char *) "diff", NULL
24133 };
24134
24135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24137 if (SWIG_arg_fail(1)) SWIG_fail;
24138 {
24139 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24140 if (SWIG_arg_fail(2)) SWIG_fail;
24141 if (arg2 == NULL) {
24142 SWIG_null_ref("wxTimeSpan");
24143 }
24144 if (SWIG_arg_fail(2)) SWIG_fail;
24145 }
24146 {
24147 PyThreadState* __tstate = wxPyBeginAllowThreads();
24148 {
24149 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24150 result = (wxTimeSpan *) &_result_ref;
24151 }
24152
24153 wxPyEndAllowThreads(__tstate);
24154 if (PyErr_Occurred()) SWIG_fail;
24155 }
24156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24157 return resultobj;
24158 fail:
24159 return NULL;
24160 }
24161
24162
24163 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24164 PyObject *resultobj;
24165 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24166 wxTimeSpan *arg2 = 0 ;
24167 wxTimeSpan *result;
24168 PyObject * obj0 = 0 ;
24169 PyObject * obj1 = 0 ;
24170 char *kwnames[] = {
24171 (char *) "self",(char *) "diff", NULL
24172 };
24173
24174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24176 if (SWIG_arg_fail(1)) SWIG_fail;
24177 {
24178 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24179 if (SWIG_arg_fail(2)) SWIG_fail;
24180 if (arg2 == NULL) {
24181 SWIG_null_ref("wxTimeSpan");
24182 }
24183 if (SWIG_arg_fail(2)) SWIG_fail;
24184 }
24185 {
24186 PyThreadState* __tstate = wxPyBeginAllowThreads();
24187 {
24188 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24189 result = (wxTimeSpan *) &_result_ref;
24190 }
24191
24192 wxPyEndAllowThreads(__tstate);
24193 if (PyErr_Occurred()) SWIG_fail;
24194 }
24195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24196 return resultobj;
24197 fail:
24198 return NULL;
24199 }
24200
24201
24202 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24203 PyObject *resultobj;
24204 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24205 int arg2 ;
24206 wxTimeSpan *result;
24207 PyObject * obj0 = 0 ;
24208 PyObject * obj1 = 0 ;
24209 char *kwnames[] = {
24210 (char *) "self",(char *) "n", NULL
24211 };
24212
24213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24215 if (SWIG_arg_fail(1)) SWIG_fail;
24216 {
24217 arg2 = (int)(SWIG_As_int(obj1));
24218 if (SWIG_arg_fail(2)) SWIG_fail;
24219 }
24220 {
24221 PyThreadState* __tstate = wxPyBeginAllowThreads();
24222 {
24223 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24224 result = (wxTimeSpan *) &_result_ref;
24225 }
24226
24227 wxPyEndAllowThreads(__tstate);
24228 if (PyErr_Occurred()) SWIG_fail;
24229 }
24230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24231 return resultobj;
24232 fail:
24233 return NULL;
24234 }
24235
24236
24237 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24238 PyObject *resultobj;
24239 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24240 wxTimeSpan *result;
24241 PyObject * obj0 = 0 ;
24242 char *kwnames[] = {
24243 (char *) "self", NULL
24244 };
24245
24246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24248 if (SWIG_arg_fail(1)) SWIG_fail;
24249 {
24250 PyThreadState* __tstate = wxPyBeginAllowThreads();
24251 {
24252 wxTimeSpan &_result_ref = (arg1)->operator -();
24253 result = (wxTimeSpan *) &_result_ref;
24254 }
24255
24256 wxPyEndAllowThreads(__tstate);
24257 if (PyErr_Occurred()) SWIG_fail;
24258 }
24259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24260 return resultobj;
24261 fail:
24262 return NULL;
24263 }
24264
24265
24266 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24267 PyObject *resultobj;
24268 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24269 wxTimeSpan *arg2 = 0 ;
24270 wxTimeSpan result;
24271 PyObject * obj0 = 0 ;
24272 PyObject * obj1 = 0 ;
24273 char *kwnames[] = {
24274 (char *) "self",(char *) "other", NULL
24275 };
24276
24277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24279 if (SWIG_arg_fail(1)) SWIG_fail;
24280 {
24281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24282 if (SWIG_arg_fail(2)) SWIG_fail;
24283 if (arg2 == NULL) {
24284 SWIG_null_ref("wxTimeSpan");
24285 }
24286 if (SWIG_arg_fail(2)) SWIG_fail;
24287 }
24288 {
24289 PyThreadState* __tstate = wxPyBeginAllowThreads();
24290 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24291
24292 wxPyEndAllowThreads(__tstate);
24293 if (PyErr_Occurred()) SWIG_fail;
24294 }
24295 {
24296 wxTimeSpan * resultptr;
24297 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24298 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24299 }
24300 return resultobj;
24301 fail:
24302 return NULL;
24303 }
24304
24305
24306 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24307 PyObject *resultobj;
24308 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24309 wxTimeSpan *arg2 = 0 ;
24310 wxTimeSpan result;
24311 PyObject * obj0 = 0 ;
24312 PyObject * obj1 = 0 ;
24313 char *kwnames[] = {
24314 (char *) "self",(char *) "other", NULL
24315 };
24316
24317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24319 if (SWIG_arg_fail(1)) SWIG_fail;
24320 {
24321 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24322 if (SWIG_arg_fail(2)) SWIG_fail;
24323 if (arg2 == NULL) {
24324 SWIG_null_ref("wxTimeSpan");
24325 }
24326 if (SWIG_arg_fail(2)) SWIG_fail;
24327 }
24328 {
24329 PyThreadState* __tstate = wxPyBeginAllowThreads();
24330 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24331
24332 wxPyEndAllowThreads(__tstate);
24333 if (PyErr_Occurred()) SWIG_fail;
24334 }
24335 {
24336 wxTimeSpan * resultptr;
24337 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24338 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24339 }
24340 return resultobj;
24341 fail:
24342 return NULL;
24343 }
24344
24345
24346 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24347 PyObject *resultobj;
24348 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24349 int arg2 ;
24350 wxTimeSpan result;
24351 PyObject * obj0 = 0 ;
24352 PyObject * obj1 = 0 ;
24353 char *kwnames[] = {
24354 (char *) "self",(char *) "n", NULL
24355 };
24356
24357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24359 if (SWIG_arg_fail(1)) SWIG_fail;
24360 {
24361 arg2 = (int)(SWIG_As_int(obj1));
24362 if (SWIG_arg_fail(2)) SWIG_fail;
24363 }
24364 {
24365 PyThreadState* __tstate = wxPyBeginAllowThreads();
24366 result = wxTimeSpan___mul__(arg1,arg2);
24367
24368 wxPyEndAllowThreads(__tstate);
24369 if (PyErr_Occurred()) SWIG_fail;
24370 }
24371 {
24372 wxTimeSpan * resultptr;
24373 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24374 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24375 }
24376 return resultobj;
24377 fail:
24378 return NULL;
24379 }
24380
24381
24382 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24383 PyObject *resultobj;
24384 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24385 int arg2 ;
24386 wxTimeSpan result;
24387 PyObject * obj0 = 0 ;
24388 PyObject * obj1 = 0 ;
24389 char *kwnames[] = {
24390 (char *) "self",(char *) "n", NULL
24391 };
24392
24393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24395 if (SWIG_arg_fail(1)) SWIG_fail;
24396 {
24397 arg2 = (int)(SWIG_As_int(obj1));
24398 if (SWIG_arg_fail(2)) SWIG_fail;
24399 }
24400 {
24401 PyThreadState* __tstate = wxPyBeginAllowThreads();
24402 result = wxTimeSpan___rmul__(arg1,arg2);
24403
24404 wxPyEndAllowThreads(__tstate);
24405 if (PyErr_Occurred()) SWIG_fail;
24406 }
24407 {
24408 wxTimeSpan * resultptr;
24409 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24410 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24411 }
24412 return resultobj;
24413 fail:
24414 return NULL;
24415 }
24416
24417
24418 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24419 PyObject *resultobj;
24420 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24421 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24422 bool result;
24423 PyObject * obj0 = 0 ;
24424 PyObject * obj1 = 0 ;
24425 char *kwnames[] = {
24426 (char *) "self",(char *) "other", NULL
24427 };
24428
24429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24431 if (SWIG_arg_fail(1)) SWIG_fail;
24432 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24433 if (SWIG_arg_fail(2)) SWIG_fail;
24434 {
24435 PyThreadState* __tstate = wxPyBeginAllowThreads();
24436 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24437
24438 wxPyEndAllowThreads(__tstate);
24439 if (PyErr_Occurred()) SWIG_fail;
24440 }
24441 {
24442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24443 }
24444 return resultobj;
24445 fail:
24446 return NULL;
24447 }
24448
24449
24450 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24451 PyObject *resultobj;
24452 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24453 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24454 bool result;
24455 PyObject * obj0 = 0 ;
24456 PyObject * obj1 = 0 ;
24457 char *kwnames[] = {
24458 (char *) "self",(char *) "other", NULL
24459 };
24460
24461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24463 if (SWIG_arg_fail(1)) SWIG_fail;
24464 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24465 if (SWIG_arg_fail(2)) SWIG_fail;
24466 {
24467 PyThreadState* __tstate = wxPyBeginAllowThreads();
24468 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24469
24470 wxPyEndAllowThreads(__tstate);
24471 if (PyErr_Occurred()) SWIG_fail;
24472 }
24473 {
24474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24475 }
24476 return resultobj;
24477 fail:
24478 return NULL;
24479 }
24480
24481
24482 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24483 PyObject *resultobj;
24484 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24485 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24486 bool result;
24487 PyObject * obj0 = 0 ;
24488 PyObject * obj1 = 0 ;
24489 char *kwnames[] = {
24490 (char *) "self",(char *) "other", NULL
24491 };
24492
24493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24495 if (SWIG_arg_fail(1)) SWIG_fail;
24496 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24497 if (SWIG_arg_fail(2)) SWIG_fail;
24498 {
24499 PyThreadState* __tstate = wxPyBeginAllowThreads();
24500 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24501
24502 wxPyEndAllowThreads(__tstate);
24503 if (PyErr_Occurred()) SWIG_fail;
24504 }
24505 {
24506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24507 }
24508 return resultobj;
24509 fail:
24510 return NULL;
24511 }
24512
24513
24514 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24515 PyObject *resultobj;
24516 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24517 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24518 bool result;
24519 PyObject * obj0 = 0 ;
24520 PyObject * obj1 = 0 ;
24521 char *kwnames[] = {
24522 (char *) "self",(char *) "other", NULL
24523 };
24524
24525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24527 if (SWIG_arg_fail(1)) SWIG_fail;
24528 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24529 if (SWIG_arg_fail(2)) SWIG_fail;
24530 {
24531 PyThreadState* __tstate = wxPyBeginAllowThreads();
24532 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24533
24534 wxPyEndAllowThreads(__tstate);
24535 if (PyErr_Occurred()) SWIG_fail;
24536 }
24537 {
24538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24539 }
24540 return resultobj;
24541 fail:
24542 return NULL;
24543 }
24544
24545
24546 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24547 PyObject *resultobj;
24548 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24549 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24550 bool result;
24551 PyObject * obj0 = 0 ;
24552 PyObject * obj1 = 0 ;
24553 char *kwnames[] = {
24554 (char *) "self",(char *) "other", NULL
24555 };
24556
24557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24559 if (SWIG_arg_fail(1)) SWIG_fail;
24560 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24561 if (SWIG_arg_fail(2)) SWIG_fail;
24562 {
24563 PyThreadState* __tstate = wxPyBeginAllowThreads();
24564 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24565
24566 wxPyEndAllowThreads(__tstate);
24567 if (PyErr_Occurred()) SWIG_fail;
24568 }
24569 {
24570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24571 }
24572 return resultobj;
24573 fail:
24574 return NULL;
24575 }
24576
24577
24578 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24579 PyObject *resultobj;
24580 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24581 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24582 bool result;
24583 PyObject * obj0 = 0 ;
24584 PyObject * obj1 = 0 ;
24585 char *kwnames[] = {
24586 (char *) "self",(char *) "other", NULL
24587 };
24588
24589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24591 if (SWIG_arg_fail(1)) SWIG_fail;
24592 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24593 if (SWIG_arg_fail(2)) SWIG_fail;
24594 {
24595 PyThreadState* __tstate = wxPyBeginAllowThreads();
24596 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24597
24598 wxPyEndAllowThreads(__tstate);
24599 if (PyErr_Occurred()) SWIG_fail;
24600 }
24601 {
24602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24603 }
24604 return resultobj;
24605 fail:
24606 return NULL;
24607 }
24608
24609
24610 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24611 PyObject *resultobj;
24612 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24613 bool result;
24614 PyObject * obj0 = 0 ;
24615 char *kwnames[] = {
24616 (char *) "self", NULL
24617 };
24618
24619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24621 if (SWIG_arg_fail(1)) SWIG_fail;
24622 {
24623 PyThreadState* __tstate = wxPyBeginAllowThreads();
24624 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24625
24626 wxPyEndAllowThreads(__tstate);
24627 if (PyErr_Occurred()) SWIG_fail;
24628 }
24629 {
24630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24631 }
24632 return resultobj;
24633 fail:
24634 return NULL;
24635 }
24636
24637
24638 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24639 PyObject *resultobj;
24640 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24641 bool result;
24642 PyObject * obj0 = 0 ;
24643 char *kwnames[] = {
24644 (char *) "self", NULL
24645 };
24646
24647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24649 if (SWIG_arg_fail(1)) SWIG_fail;
24650 {
24651 PyThreadState* __tstate = wxPyBeginAllowThreads();
24652 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24653
24654 wxPyEndAllowThreads(__tstate);
24655 if (PyErr_Occurred()) SWIG_fail;
24656 }
24657 {
24658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24659 }
24660 return resultobj;
24661 fail:
24662 return NULL;
24663 }
24664
24665
24666 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24667 PyObject *resultobj;
24668 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24669 bool result;
24670 PyObject * obj0 = 0 ;
24671 char *kwnames[] = {
24672 (char *) "self", NULL
24673 };
24674
24675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24677 if (SWIG_arg_fail(1)) SWIG_fail;
24678 {
24679 PyThreadState* __tstate = wxPyBeginAllowThreads();
24680 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24681
24682 wxPyEndAllowThreads(__tstate);
24683 if (PyErr_Occurred()) SWIG_fail;
24684 }
24685 {
24686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24687 }
24688 return resultobj;
24689 fail:
24690 return NULL;
24691 }
24692
24693
24694 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24695 PyObject *resultobj;
24696 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24697 wxTimeSpan *arg2 = 0 ;
24698 bool result;
24699 PyObject * obj0 = 0 ;
24700 PyObject * obj1 = 0 ;
24701 char *kwnames[] = {
24702 (char *) "self",(char *) "ts", NULL
24703 };
24704
24705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24707 if (SWIG_arg_fail(1)) SWIG_fail;
24708 {
24709 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24710 if (SWIG_arg_fail(2)) SWIG_fail;
24711 if (arg2 == NULL) {
24712 SWIG_null_ref("wxTimeSpan");
24713 }
24714 if (SWIG_arg_fail(2)) SWIG_fail;
24715 }
24716 {
24717 PyThreadState* __tstate = wxPyBeginAllowThreads();
24718 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24719
24720 wxPyEndAllowThreads(__tstate);
24721 if (PyErr_Occurred()) SWIG_fail;
24722 }
24723 {
24724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24725 }
24726 return resultobj;
24727 fail:
24728 return NULL;
24729 }
24730
24731
24732 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24733 PyObject *resultobj;
24734 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24735 wxTimeSpan *arg2 = 0 ;
24736 bool result;
24737 PyObject * obj0 = 0 ;
24738 PyObject * obj1 = 0 ;
24739 char *kwnames[] = {
24740 (char *) "self",(char *) "ts", NULL
24741 };
24742
24743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24745 if (SWIG_arg_fail(1)) SWIG_fail;
24746 {
24747 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24748 if (SWIG_arg_fail(2)) SWIG_fail;
24749 if (arg2 == NULL) {
24750 SWIG_null_ref("wxTimeSpan");
24751 }
24752 if (SWIG_arg_fail(2)) SWIG_fail;
24753 }
24754 {
24755 PyThreadState* __tstate = wxPyBeginAllowThreads();
24756 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24757
24758 wxPyEndAllowThreads(__tstate);
24759 if (PyErr_Occurred()) SWIG_fail;
24760 }
24761 {
24762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24763 }
24764 return resultobj;
24765 fail:
24766 return NULL;
24767 }
24768
24769
24770 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24771 PyObject *resultobj;
24772 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24773 wxTimeSpan *arg2 = 0 ;
24774 bool result;
24775 PyObject * obj0 = 0 ;
24776 PyObject * obj1 = 0 ;
24777 char *kwnames[] = {
24778 (char *) "self",(char *) "t", NULL
24779 };
24780
24781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24783 if (SWIG_arg_fail(1)) SWIG_fail;
24784 {
24785 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24786 if (SWIG_arg_fail(2)) SWIG_fail;
24787 if (arg2 == NULL) {
24788 SWIG_null_ref("wxTimeSpan");
24789 }
24790 if (SWIG_arg_fail(2)) SWIG_fail;
24791 }
24792 {
24793 PyThreadState* __tstate = wxPyBeginAllowThreads();
24794 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24795
24796 wxPyEndAllowThreads(__tstate);
24797 if (PyErr_Occurred()) SWIG_fail;
24798 }
24799 {
24800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24801 }
24802 return resultobj;
24803 fail:
24804 return NULL;
24805 }
24806
24807
24808 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24809 PyObject *resultobj;
24810 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24811 int result;
24812 PyObject * obj0 = 0 ;
24813 char *kwnames[] = {
24814 (char *) "self", NULL
24815 };
24816
24817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24819 if (SWIG_arg_fail(1)) SWIG_fail;
24820 {
24821 PyThreadState* __tstate = wxPyBeginAllowThreads();
24822 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24823
24824 wxPyEndAllowThreads(__tstate);
24825 if (PyErr_Occurred()) SWIG_fail;
24826 }
24827 {
24828 resultobj = SWIG_From_int((int)(result));
24829 }
24830 return resultobj;
24831 fail:
24832 return NULL;
24833 }
24834
24835
24836 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24837 PyObject *resultobj;
24838 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24839 int result;
24840 PyObject * obj0 = 0 ;
24841 char *kwnames[] = {
24842 (char *) "self", NULL
24843 };
24844
24845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
24846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24847 if (SWIG_arg_fail(1)) SWIG_fail;
24848 {
24849 PyThreadState* __tstate = wxPyBeginAllowThreads();
24850 result = (int)((wxTimeSpan const *)arg1)->GetDays();
24851
24852 wxPyEndAllowThreads(__tstate);
24853 if (PyErr_Occurred()) SWIG_fail;
24854 }
24855 {
24856 resultobj = SWIG_From_int((int)(result));
24857 }
24858 return resultobj;
24859 fail:
24860 return NULL;
24861 }
24862
24863
24864 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
24865 PyObject *resultobj;
24866 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24867 int result;
24868 PyObject * obj0 = 0 ;
24869 char *kwnames[] = {
24870 (char *) "self", NULL
24871 };
24872
24873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
24874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24875 if (SWIG_arg_fail(1)) SWIG_fail;
24876 {
24877 PyThreadState* __tstate = wxPyBeginAllowThreads();
24878 result = (int)((wxTimeSpan const *)arg1)->GetHours();
24879
24880 wxPyEndAllowThreads(__tstate);
24881 if (PyErr_Occurred()) SWIG_fail;
24882 }
24883 {
24884 resultobj = SWIG_From_int((int)(result));
24885 }
24886 return resultobj;
24887 fail:
24888 return NULL;
24889 }
24890
24891
24892 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
24893 PyObject *resultobj;
24894 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24895 int result;
24896 PyObject * obj0 = 0 ;
24897 char *kwnames[] = {
24898 (char *) "self", NULL
24899 };
24900
24901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
24902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24903 if (SWIG_arg_fail(1)) SWIG_fail;
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
24907
24908 wxPyEndAllowThreads(__tstate);
24909 if (PyErr_Occurred()) SWIG_fail;
24910 }
24911 {
24912 resultobj = SWIG_From_int((int)(result));
24913 }
24914 return resultobj;
24915 fail:
24916 return NULL;
24917 }
24918
24919
24920 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
24921 PyObject *resultobj;
24922 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24923 wxLongLong result;
24924 PyObject * obj0 = 0 ;
24925 char *kwnames[] = {
24926 (char *) "self", NULL
24927 };
24928
24929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
24930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24931 if (SWIG_arg_fail(1)) SWIG_fail;
24932 {
24933 PyThreadState* __tstate = wxPyBeginAllowThreads();
24934 result = ((wxTimeSpan const *)arg1)->GetSeconds();
24935
24936 wxPyEndAllowThreads(__tstate);
24937 if (PyErr_Occurred()) SWIG_fail;
24938 }
24939 {
24940 PyObject *hi, *lo, *shifter, *shifted;
24941 hi = PyLong_FromLong( (&result)->GetHi() );
24942 lo = PyLong_FromLong( (&result)->GetLo() );
24943 shifter = PyLong_FromLong(32);
24944 shifted = PyNumber_Lshift(hi, shifter);
24945 resultobj = PyNumber_Or(shifted, lo);
24946 Py_DECREF(hi);
24947 Py_DECREF(lo);
24948 Py_DECREF(shifter);
24949 Py_DECREF(shifted);
24950 }
24951 return resultobj;
24952 fail:
24953 return NULL;
24954 }
24955
24956
24957 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
24958 PyObject *resultobj;
24959 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24960 wxLongLong result;
24961 PyObject * obj0 = 0 ;
24962 char *kwnames[] = {
24963 (char *) "self", NULL
24964 };
24965
24966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
24967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24968 if (SWIG_arg_fail(1)) SWIG_fail;
24969 {
24970 PyThreadState* __tstate = wxPyBeginAllowThreads();
24971 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
24972
24973 wxPyEndAllowThreads(__tstate);
24974 if (PyErr_Occurred()) SWIG_fail;
24975 }
24976 {
24977 PyObject *hi, *lo, *shifter, *shifted;
24978 hi = PyLong_FromLong( (&result)->GetHi() );
24979 lo = PyLong_FromLong( (&result)->GetLo() );
24980 shifter = PyLong_FromLong(32);
24981 shifted = PyNumber_Lshift(hi, shifter);
24982 resultobj = PyNumber_Or(shifted, lo);
24983 Py_DECREF(hi);
24984 Py_DECREF(lo);
24985 Py_DECREF(shifter);
24986 Py_DECREF(shifted);
24987 }
24988 return resultobj;
24989 fail:
24990 return NULL;
24991 }
24992
24993
24994 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
24995 PyObject *resultobj;
24996 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24997 wxString const &arg2_defvalue = wxPyTimeSpanFormatStr ;
24998 wxString *arg2 = (wxString *) &arg2_defvalue ;
24999 wxString result;
25000 bool temp2 = false ;
25001 PyObject * obj0 = 0 ;
25002 PyObject * obj1 = 0 ;
25003 char *kwnames[] = {
25004 (char *) "self",(char *) "format", NULL
25005 };
25006
25007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25009 if (SWIG_arg_fail(1)) SWIG_fail;
25010 if (obj1) {
25011 {
25012 arg2 = wxString_in_helper(obj1);
25013 if (arg2 == NULL) SWIG_fail;
25014 temp2 = true;
25015 }
25016 }
25017 {
25018 PyThreadState* __tstate = wxPyBeginAllowThreads();
25019 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25020
25021 wxPyEndAllowThreads(__tstate);
25022 if (PyErr_Occurred()) SWIG_fail;
25023 }
25024 {
25025 #if wxUSE_UNICODE
25026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25027 #else
25028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25029 #endif
25030 }
25031 {
25032 if (temp2)
25033 delete arg2;
25034 }
25035 return resultobj;
25036 fail:
25037 {
25038 if (temp2)
25039 delete arg2;
25040 }
25041 return NULL;
25042 }
25043
25044
25045 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25046 PyObject *obj;
25047 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25048 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25049 Py_INCREF(obj);
25050 return Py_BuildValue((char *)"");
25051 }
25052 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25053 PyObject *resultobj;
25054 int arg1 = (int) 0 ;
25055 int arg2 = (int) 0 ;
25056 int arg3 = (int) 0 ;
25057 int arg4 = (int) 0 ;
25058 wxDateSpan *result;
25059 PyObject * obj0 = 0 ;
25060 PyObject * obj1 = 0 ;
25061 PyObject * obj2 = 0 ;
25062 PyObject * obj3 = 0 ;
25063 char *kwnames[] = {
25064 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25065 };
25066
25067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25068 if (obj0) {
25069 {
25070 arg1 = (int)(SWIG_As_int(obj0));
25071 if (SWIG_arg_fail(1)) SWIG_fail;
25072 }
25073 }
25074 if (obj1) {
25075 {
25076 arg2 = (int)(SWIG_As_int(obj1));
25077 if (SWIG_arg_fail(2)) SWIG_fail;
25078 }
25079 }
25080 if (obj2) {
25081 {
25082 arg3 = (int)(SWIG_As_int(obj2));
25083 if (SWIG_arg_fail(3)) SWIG_fail;
25084 }
25085 }
25086 if (obj3) {
25087 {
25088 arg4 = (int)(SWIG_As_int(obj3));
25089 if (SWIG_arg_fail(4)) SWIG_fail;
25090 }
25091 }
25092 {
25093 PyThreadState* __tstate = wxPyBeginAllowThreads();
25094 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25095
25096 wxPyEndAllowThreads(__tstate);
25097 if (PyErr_Occurred()) SWIG_fail;
25098 }
25099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25100 return resultobj;
25101 fail:
25102 return NULL;
25103 }
25104
25105
25106 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25107 PyObject *resultobj;
25108 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25109 PyObject * obj0 = 0 ;
25110 char *kwnames[] = {
25111 (char *) "self", NULL
25112 };
25113
25114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25116 if (SWIG_arg_fail(1)) SWIG_fail;
25117 {
25118 PyThreadState* __tstate = wxPyBeginAllowThreads();
25119 delete arg1;
25120
25121 wxPyEndAllowThreads(__tstate);
25122 if (PyErr_Occurred()) SWIG_fail;
25123 }
25124 Py_INCREF(Py_None); resultobj = Py_None;
25125 return resultobj;
25126 fail:
25127 return NULL;
25128 }
25129
25130
25131 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25132 PyObject *resultobj;
25133 int arg1 ;
25134 wxDateSpan result;
25135 PyObject * obj0 = 0 ;
25136 char *kwnames[] = {
25137 (char *) "days", NULL
25138 };
25139
25140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25141 {
25142 arg1 = (int)(SWIG_As_int(obj0));
25143 if (SWIG_arg_fail(1)) SWIG_fail;
25144 }
25145 {
25146 PyThreadState* __tstate = wxPyBeginAllowThreads();
25147 result = wxDateSpan::Days(arg1);
25148
25149 wxPyEndAllowThreads(__tstate);
25150 if (PyErr_Occurred()) SWIG_fail;
25151 }
25152 {
25153 wxDateSpan * resultptr;
25154 resultptr = new wxDateSpan((wxDateSpan &)(result));
25155 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25156 }
25157 return resultobj;
25158 fail:
25159 return NULL;
25160 }
25161
25162
25163 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25164 PyObject *resultobj;
25165 wxDateSpan result;
25166 char *kwnames[] = {
25167 NULL
25168 };
25169
25170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25171 {
25172 PyThreadState* __tstate = wxPyBeginAllowThreads();
25173 result = wxDateSpan::Day();
25174
25175 wxPyEndAllowThreads(__tstate);
25176 if (PyErr_Occurred()) SWIG_fail;
25177 }
25178 {
25179 wxDateSpan * resultptr;
25180 resultptr = new wxDateSpan((wxDateSpan &)(result));
25181 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25182 }
25183 return resultobj;
25184 fail:
25185 return NULL;
25186 }
25187
25188
25189 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25190 PyObject *resultobj;
25191 int arg1 ;
25192 wxDateSpan result;
25193 PyObject * obj0 = 0 ;
25194 char *kwnames[] = {
25195 (char *) "weeks", NULL
25196 };
25197
25198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25199 {
25200 arg1 = (int)(SWIG_As_int(obj0));
25201 if (SWIG_arg_fail(1)) SWIG_fail;
25202 }
25203 {
25204 PyThreadState* __tstate = wxPyBeginAllowThreads();
25205 result = wxDateSpan::Weeks(arg1);
25206
25207 wxPyEndAllowThreads(__tstate);
25208 if (PyErr_Occurred()) SWIG_fail;
25209 }
25210 {
25211 wxDateSpan * resultptr;
25212 resultptr = new wxDateSpan((wxDateSpan &)(result));
25213 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25214 }
25215 return resultobj;
25216 fail:
25217 return NULL;
25218 }
25219
25220
25221 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25222 PyObject *resultobj;
25223 wxDateSpan result;
25224 char *kwnames[] = {
25225 NULL
25226 };
25227
25228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25229 {
25230 PyThreadState* __tstate = wxPyBeginAllowThreads();
25231 result = wxDateSpan::Week();
25232
25233 wxPyEndAllowThreads(__tstate);
25234 if (PyErr_Occurred()) SWIG_fail;
25235 }
25236 {
25237 wxDateSpan * resultptr;
25238 resultptr = new wxDateSpan((wxDateSpan &)(result));
25239 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25240 }
25241 return resultobj;
25242 fail:
25243 return NULL;
25244 }
25245
25246
25247 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25248 PyObject *resultobj;
25249 int arg1 ;
25250 wxDateSpan result;
25251 PyObject * obj0 = 0 ;
25252 char *kwnames[] = {
25253 (char *) "mon", NULL
25254 };
25255
25256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25257 {
25258 arg1 = (int)(SWIG_As_int(obj0));
25259 if (SWIG_arg_fail(1)) SWIG_fail;
25260 }
25261 {
25262 PyThreadState* __tstate = wxPyBeginAllowThreads();
25263 result = wxDateSpan::Months(arg1);
25264
25265 wxPyEndAllowThreads(__tstate);
25266 if (PyErr_Occurred()) SWIG_fail;
25267 }
25268 {
25269 wxDateSpan * resultptr;
25270 resultptr = new wxDateSpan((wxDateSpan &)(result));
25271 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25272 }
25273 return resultobj;
25274 fail:
25275 return NULL;
25276 }
25277
25278
25279 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25280 PyObject *resultobj;
25281 wxDateSpan result;
25282 char *kwnames[] = {
25283 NULL
25284 };
25285
25286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25287 {
25288 PyThreadState* __tstate = wxPyBeginAllowThreads();
25289 result = wxDateSpan::Month();
25290
25291 wxPyEndAllowThreads(__tstate);
25292 if (PyErr_Occurred()) SWIG_fail;
25293 }
25294 {
25295 wxDateSpan * resultptr;
25296 resultptr = new wxDateSpan((wxDateSpan &)(result));
25297 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25298 }
25299 return resultobj;
25300 fail:
25301 return NULL;
25302 }
25303
25304
25305 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25306 PyObject *resultobj;
25307 int arg1 ;
25308 wxDateSpan result;
25309 PyObject * obj0 = 0 ;
25310 char *kwnames[] = {
25311 (char *) "years", NULL
25312 };
25313
25314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25315 {
25316 arg1 = (int)(SWIG_As_int(obj0));
25317 if (SWIG_arg_fail(1)) SWIG_fail;
25318 }
25319 {
25320 PyThreadState* __tstate = wxPyBeginAllowThreads();
25321 result = wxDateSpan::Years(arg1);
25322
25323 wxPyEndAllowThreads(__tstate);
25324 if (PyErr_Occurred()) SWIG_fail;
25325 }
25326 {
25327 wxDateSpan * resultptr;
25328 resultptr = new wxDateSpan((wxDateSpan &)(result));
25329 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25330 }
25331 return resultobj;
25332 fail:
25333 return NULL;
25334 }
25335
25336
25337 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25338 PyObject *resultobj;
25339 wxDateSpan result;
25340 char *kwnames[] = {
25341 NULL
25342 };
25343
25344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25345 {
25346 PyThreadState* __tstate = wxPyBeginAllowThreads();
25347 result = wxDateSpan::Year();
25348
25349 wxPyEndAllowThreads(__tstate);
25350 if (PyErr_Occurred()) SWIG_fail;
25351 }
25352 {
25353 wxDateSpan * resultptr;
25354 resultptr = new wxDateSpan((wxDateSpan &)(result));
25355 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25356 }
25357 return resultobj;
25358 fail:
25359 return NULL;
25360 }
25361
25362
25363 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25364 PyObject *resultobj;
25365 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25366 int arg2 ;
25367 wxDateSpan *result;
25368 PyObject * obj0 = 0 ;
25369 PyObject * obj1 = 0 ;
25370 char *kwnames[] = {
25371 (char *) "self",(char *) "n", NULL
25372 };
25373
25374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25376 if (SWIG_arg_fail(1)) SWIG_fail;
25377 {
25378 arg2 = (int)(SWIG_As_int(obj1));
25379 if (SWIG_arg_fail(2)) SWIG_fail;
25380 }
25381 {
25382 PyThreadState* __tstate = wxPyBeginAllowThreads();
25383 {
25384 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25385 result = (wxDateSpan *) &_result_ref;
25386 }
25387
25388 wxPyEndAllowThreads(__tstate);
25389 if (PyErr_Occurred()) SWIG_fail;
25390 }
25391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25392 return resultobj;
25393 fail:
25394 return NULL;
25395 }
25396
25397
25398 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25399 PyObject *resultobj;
25400 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25401 int arg2 ;
25402 wxDateSpan *result;
25403 PyObject * obj0 = 0 ;
25404 PyObject * obj1 = 0 ;
25405 char *kwnames[] = {
25406 (char *) "self",(char *) "n", NULL
25407 };
25408
25409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25411 if (SWIG_arg_fail(1)) SWIG_fail;
25412 {
25413 arg2 = (int)(SWIG_As_int(obj1));
25414 if (SWIG_arg_fail(2)) SWIG_fail;
25415 }
25416 {
25417 PyThreadState* __tstate = wxPyBeginAllowThreads();
25418 {
25419 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25420 result = (wxDateSpan *) &_result_ref;
25421 }
25422
25423 wxPyEndAllowThreads(__tstate);
25424 if (PyErr_Occurred()) SWIG_fail;
25425 }
25426 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25427 return resultobj;
25428 fail:
25429 return NULL;
25430 }
25431
25432
25433 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25434 PyObject *resultobj;
25435 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25436 int arg2 ;
25437 wxDateSpan *result;
25438 PyObject * obj0 = 0 ;
25439 PyObject * obj1 = 0 ;
25440 char *kwnames[] = {
25441 (char *) "self",(char *) "n", NULL
25442 };
25443
25444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25446 if (SWIG_arg_fail(1)) SWIG_fail;
25447 {
25448 arg2 = (int)(SWIG_As_int(obj1));
25449 if (SWIG_arg_fail(2)) SWIG_fail;
25450 }
25451 {
25452 PyThreadState* __tstate = wxPyBeginAllowThreads();
25453 {
25454 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25455 result = (wxDateSpan *) &_result_ref;
25456 }
25457
25458 wxPyEndAllowThreads(__tstate);
25459 if (PyErr_Occurred()) SWIG_fail;
25460 }
25461 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25462 return resultobj;
25463 fail:
25464 return NULL;
25465 }
25466
25467
25468 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25469 PyObject *resultobj;
25470 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25471 int arg2 ;
25472 wxDateSpan *result;
25473 PyObject * obj0 = 0 ;
25474 PyObject * obj1 = 0 ;
25475 char *kwnames[] = {
25476 (char *) "self",(char *) "n", NULL
25477 };
25478
25479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25481 if (SWIG_arg_fail(1)) SWIG_fail;
25482 {
25483 arg2 = (int)(SWIG_As_int(obj1));
25484 if (SWIG_arg_fail(2)) SWIG_fail;
25485 }
25486 {
25487 PyThreadState* __tstate = wxPyBeginAllowThreads();
25488 {
25489 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25490 result = (wxDateSpan *) &_result_ref;
25491 }
25492
25493 wxPyEndAllowThreads(__tstate);
25494 if (PyErr_Occurred()) SWIG_fail;
25495 }
25496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25497 return resultobj;
25498 fail:
25499 return NULL;
25500 }
25501
25502
25503 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25504 PyObject *resultobj;
25505 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25506 int result;
25507 PyObject * obj0 = 0 ;
25508 char *kwnames[] = {
25509 (char *) "self", NULL
25510 };
25511
25512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25514 if (SWIG_arg_fail(1)) SWIG_fail;
25515 {
25516 PyThreadState* __tstate = wxPyBeginAllowThreads();
25517 result = (int)((wxDateSpan const *)arg1)->GetYears();
25518
25519 wxPyEndAllowThreads(__tstate);
25520 if (PyErr_Occurred()) SWIG_fail;
25521 }
25522 {
25523 resultobj = SWIG_From_int((int)(result));
25524 }
25525 return resultobj;
25526 fail:
25527 return NULL;
25528 }
25529
25530
25531 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25532 PyObject *resultobj;
25533 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25534 int result;
25535 PyObject * obj0 = 0 ;
25536 char *kwnames[] = {
25537 (char *) "self", NULL
25538 };
25539
25540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25542 if (SWIG_arg_fail(1)) SWIG_fail;
25543 {
25544 PyThreadState* __tstate = wxPyBeginAllowThreads();
25545 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25546
25547 wxPyEndAllowThreads(__tstate);
25548 if (PyErr_Occurred()) SWIG_fail;
25549 }
25550 {
25551 resultobj = SWIG_From_int((int)(result));
25552 }
25553 return resultobj;
25554 fail:
25555 return NULL;
25556 }
25557
25558
25559 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25560 PyObject *resultobj;
25561 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25562 int result;
25563 PyObject * obj0 = 0 ;
25564 char *kwnames[] = {
25565 (char *) "self", NULL
25566 };
25567
25568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25570 if (SWIG_arg_fail(1)) SWIG_fail;
25571 {
25572 PyThreadState* __tstate = wxPyBeginAllowThreads();
25573 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25574
25575 wxPyEndAllowThreads(__tstate);
25576 if (PyErr_Occurred()) SWIG_fail;
25577 }
25578 {
25579 resultobj = SWIG_From_int((int)(result));
25580 }
25581 return resultobj;
25582 fail:
25583 return NULL;
25584 }
25585
25586
25587 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25588 PyObject *resultobj;
25589 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25590 int result;
25591 PyObject * obj0 = 0 ;
25592 char *kwnames[] = {
25593 (char *) "self", NULL
25594 };
25595
25596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25598 if (SWIG_arg_fail(1)) SWIG_fail;
25599 {
25600 PyThreadState* __tstate = wxPyBeginAllowThreads();
25601 result = (int)((wxDateSpan const *)arg1)->GetDays();
25602
25603 wxPyEndAllowThreads(__tstate);
25604 if (PyErr_Occurred()) SWIG_fail;
25605 }
25606 {
25607 resultobj = SWIG_From_int((int)(result));
25608 }
25609 return resultobj;
25610 fail:
25611 return NULL;
25612 }
25613
25614
25615 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25616 PyObject *resultobj;
25617 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25618 int result;
25619 PyObject * obj0 = 0 ;
25620 char *kwnames[] = {
25621 (char *) "self", NULL
25622 };
25623
25624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25626 if (SWIG_arg_fail(1)) SWIG_fail;
25627 {
25628 PyThreadState* __tstate = wxPyBeginAllowThreads();
25629 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25630
25631 wxPyEndAllowThreads(__tstate);
25632 if (PyErr_Occurred()) SWIG_fail;
25633 }
25634 {
25635 resultobj = SWIG_From_int((int)(result));
25636 }
25637 return resultobj;
25638 fail:
25639 return NULL;
25640 }
25641
25642
25643 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25644 PyObject *resultobj;
25645 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25646 wxDateSpan *arg2 = 0 ;
25647 wxDateSpan *result;
25648 PyObject * obj0 = 0 ;
25649 PyObject * obj1 = 0 ;
25650 char *kwnames[] = {
25651 (char *) "self",(char *) "other", NULL
25652 };
25653
25654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25656 if (SWIG_arg_fail(1)) SWIG_fail;
25657 {
25658 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25659 if (SWIG_arg_fail(2)) SWIG_fail;
25660 if (arg2 == NULL) {
25661 SWIG_null_ref("wxDateSpan");
25662 }
25663 if (SWIG_arg_fail(2)) SWIG_fail;
25664 }
25665 {
25666 PyThreadState* __tstate = wxPyBeginAllowThreads();
25667 {
25668 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25669 result = (wxDateSpan *) &_result_ref;
25670 }
25671
25672 wxPyEndAllowThreads(__tstate);
25673 if (PyErr_Occurred()) SWIG_fail;
25674 }
25675 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25676 return resultobj;
25677 fail:
25678 return NULL;
25679 }
25680
25681
25682 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25683 PyObject *resultobj;
25684 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25685 wxDateSpan *arg2 = 0 ;
25686 wxDateSpan *result;
25687 PyObject * obj0 = 0 ;
25688 PyObject * obj1 = 0 ;
25689 char *kwnames[] = {
25690 (char *) "self",(char *) "other", NULL
25691 };
25692
25693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25695 if (SWIG_arg_fail(1)) SWIG_fail;
25696 {
25697 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25698 if (SWIG_arg_fail(2)) SWIG_fail;
25699 if (arg2 == NULL) {
25700 SWIG_null_ref("wxDateSpan");
25701 }
25702 if (SWIG_arg_fail(2)) SWIG_fail;
25703 }
25704 {
25705 PyThreadState* __tstate = wxPyBeginAllowThreads();
25706 {
25707 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25708 result = (wxDateSpan *) &_result_ref;
25709 }
25710
25711 wxPyEndAllowThreads(__tstate);
25712 if (PyErr_Occurred()) SWIG_fail;
25713 }
25714 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25715 return resultobj;
25716 fail:
25717 return NULL;
25718 }
25719
25720
25721 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25722 PyObject *resultobj;
25723 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25724 wxDateSpan *result;
25725 PyObject * obj0 = 0 ;
25726 char *kwnames[] = {
25727 (char *) "self", NULL
25728 };
25729
25730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25732 if (SWIG_arg_fail(1)) SWIG_fail;
25733 {
25734 PyThreadState* __tstate = wxPyBeginAllowThreads();
25735 {
25736 wxDateSpan &_result_ref = (arg1)->Neg();
25737 result = (wxDateSpan *) &_result_ref;
25738 }
25739
25740 wxPyEndAllowThreads(__tstate);
25741 if (PyErr_Occurred()) SWIG_fail;
25742 }
25743 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25744 return resultobj;
25745 fail:
25746 return NULL;
25747 }
25748
25749
25750 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25751 PyObject *resultobj;
25752 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25753 int arg2 ;
25754 wxDateSpan *result;
25755 PyObject * obj0 = 0 ;
25756 PyObject * obj1 = 0 ;
25757 char *kwnames[] = {
25758 (char *) "self",(char *) "factor", NULL
25759 };
25760
25761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25763 if (SWIG_arg_fail(1)) SWIG_fail;
25764 {
25765 arg2 = (int)(SWIG_As_int(obj1));
25766 if (SWIG_arg_fail(2)) SWIG_fail;
25767 }
25768 {
25769 PyThreadState* __tstate = wxPyBeginAllowThreads();
25770 {
25771 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25772 result = (wxDateSpan *) &_result_ref;
25773 }
25774
25775 wxPyEndAllowThreads(__tstate);
25776 if (PyErr_Occurred()) SWIG_fail;
25777 }
25778 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25779 return resultobj;
25780 fail:
25781 return NULL;
25782 }
25783
25784
25785 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25786 PyObject *resultobj;
25787 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25788 wxDateSpan *arg2 = 0 ;
25789 wxDateSpan *result;
25790 PyObject * obj0 = 0 ;
25791 PyObject * obj1 = 0 ;
25792 char *kwnames[] = {
25793 (char *) "self",(char *) "other", NULL
25794 };
25795
25796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25798 if (SWIG_arg_fail(1)) SWIG_fail;
25799 {
25800 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25801 if (SWIG_arg_fail(2)) SWIG_fail;
25802 if (arg2 == NULL) {
25803 SWIG_null_ref("wxDateSpan");
25804 }
25805 if (SWIG_arg_fail(2)) SWIG_fail;
25806 }
25807 {
25808 PyThreadState* __tstate = wxPyBeginAllowThreads();
25809 {
25810 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25811 result = (wxDateSpan *) &_result_ref;
25812 }
25813
25814 wxPyEndAllowThreads(__tstate);
25815 if (PyErr_Occurred()) SWIG_fail;
25816 }
25817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25818 return resultobj;
25819 fail:
25820 return NULL;
25821 }
25822
25823
25824 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25825 PyObject *resultobj;
25826 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25827 wxDateSpan *arg2 = 0 ;
25828 wxDateSpan *result;
25829 PyObject * obj0 = 0 ;
25830 PyObject * obj1 = 0 ;
25831 char *kwnames[] = {
25832 (char *) "self",(char *) "other", NULL
25833 };
25834
25835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25837 if (SWIG_arg_fail(1)) SWIG_fail;
25838 {
25839 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25840 if (SWIG_arg_fail(2)) SWIG_fail;
25841 if (arg2 == NULL) {
25842 SWIG_null_ref("wxDateSpan");
25843 }
25844 if (SWIG_arg_fail(2)) SWIG_fail;
25845 }
25846 {
25847 PyThreadState* __tstate = wxPyBeginAllowThreads();
25848 {
25849 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
25850 result = (wxDateSpan *) &_result_ref;
25851 }
25852
25853 wxPyEndAllowThreads(__tstate);
25854 if (PyErr_Occurred()) SWIG_fail;
25855 }
25856 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25857 return resultobj;
25858 fail:
25859 return NULL;
25860 }
25861
25862
25863 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25864 PyObject *resultobj;
25865 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25866 wxDateSpan *result;
25867 PyObject * obj0 = 0 ;
25868 char *kwnames[] = {
25869 (char *) "self", NULL
25870 };
25871
25872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
25873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25874 if (SWIG_arg_fail(1)) SWIG_fail;
25875 {
25876 PyThreadState* __tstate = wxPyBeginAllowThreads();
25877 {
25878 wxDateSpan &_result_ref = (arg1)->operator -();
25879 result = (wxDateSpan *) &_result_ref;
25880 }
25881
25882 wxPyEndAllowThreads(__tstate);
25883 if (PyErr_Occurred()) SWIG_fail;
25884 }
25885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25886 return resultobj;
25887 fail:
25888 return NULL;
25889 }
25890
25891
25892 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
25893 PyObject *resultobj;
25894 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25895 int arg2 ;
25896 wxDateSpan *result;
25897 PyObject * obj0 = 0 ;
25898 PyObject * obj1 = 0 ;
25899 char *kwnames[] = {
25900 (char *) "self",(char *) "factor", NULL
25901 };
25902
25903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
25904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25905 if (SWIG_arg_fail(1)) SWIG_fail;
25906 {
25907 arg2 = (int)(SWIG_As_int(obj1));
25908 if (SWIG_arg_fail(2)) SWIG_fail;
25909 }
25910 {
25911 PyThreadState* __tstate = wxPyBeginAllowThreads();
25912 {
25913 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
25914 result = (wxDateSpan *) &_result_ref;
25915 }
25916
25917 wxPyEndAllowThreads(__tstate);
25918 if (PyErr_Occurred()) SWIG_fail;
25919 }
25920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25921 return resultobj;
25922 fail:
25923 return NULL;
25924 }
25925
25926
25927 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
25928 PyObject *resultobj;
25929 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25930 wxDateSpan *arg2 = 0 ;
25931 wxDateSpan result;
25932 PyObject * obj0 = 0 ;
25933 PyObject * obj1 = 0 ;
25934 char *kwnames[] = {
25935 (char *) "self",(char *) "other", NULL
25936 };
25937
25938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
25939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25940 if (SWIG_arg_fail(1)) SWIG_fail;
25941 {
25942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25943 if (SWIG_arg_fail(2)) SWIG_fail;
25944 if (arg2 == NULL) {
25945 SWIG_null_ref("wxDateSpan");
25946 }
25947 if (SWIG_arg_fail(2)) SWIG_fail;
25948 }
25949 {
25950 PyThreadState* __tstate = wxPyBeginAllowThreads();
25951 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
25952
25953 wxPyEndAllowThreads(__tstate);
25954 if (PyErr_Occurred()) SWIG_fail;
25955 }
25956 {
25957 wxDateSpan * resultptr;
25958 resultptr = new wxDateSpan((wxDateSpan &)(result));
25959 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25960 }
25961 return resultobj;
25962 fail:
25963 return NULL;
25964 }
25965
25966
25967 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
25968 PyObject *resultobj;
25969 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25970 wxDateSpan *arg2 = 0 ;
25971 wxDateSpan result;
25972 PyObject * obj0 = 0 ;
25973 PyObject * obj1 = 0 ;
25974 char *kwnames[] = {
25975 (char *) "self",(char *) "other", NULL
25976 };
25977
25978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
25979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25980 if (SWIG_arg_fail(1)) SWIG_fail;
25981 {
25982 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25983 if (SWIG_arg_fail(2)) SWIG_fail;
25984 if (arg2 == NULL) {
25985 SWIG_null_ref("wxDateSpan");
25986 }
25987 if (SWIG_arg_fail(2)) SWIG_fail;
25988 }
25989 {
25990 PyThreadState* __tstate = wxPyBeginAllowThreads();
25991 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
25992
25993 wxPyEndAllowThreads(__tstate);
25994 if (PyErr_Occurred()) SWIG_fail;
25995 }
25996 {
25997 wxDateSpan * resultptr;
25998 resultptr = new wxDateSpan((wxDateSpan &)(result));
25999 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26000 }
26001 return resultobj;
26002 fail:
26003 return NULL;
26004 }
26005
26006
26007 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26008 PyObject *resultobj;
26009 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26010 int arg2 ;
26011 wxDateSpan result;
26012 PyObject * obj0 = 0 ;
26013 PyObject * obj1 = 0 ;
26014 char *kwnames[] = {
26015 (char *) "self",(char *) "n", NULL
26016 };
26017
26018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26020 if (SWIG_arg_fail(1)) SWIG_fail;
26021 {
26022 arg2 = (int)(SWIG_As_int(obj1));
26023 if (SWIG_arg_fail(2)) SWIG_fail;
26024 }
26025 {
26026 PyThreadState* __tstate = wxPyBeginAllowThreads();
26027 result = wxDateSpan___mul__(arg1,arg2);
26028
26029 wxPyEndAllowThreads(__tstate);
26030 if (PyErr_Occurred()) SWIG_fail;
26031 }
26032 {
26033 wxDateSpan * resultptr;
26034 resultptr = new wxDateSpan((wxDateSpan &)(result));
26035 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26036 }
26037 return resultobj;
26038 fail:
26039 return NULL;
26040 }
26041
26042
26043 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26044 PyObject *resultobj;
26045 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26046 int arg2 ;
26047 wxDateSpan result;
26048 PyObject * obj0 = 0 ;
26049 PyObject * obj1 = 0 ;
26050 char *kwnames[] = {
26051 (char *) "self",(char *) "n", NULL
26052 };
26053
26054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26056 if (SWIG_arg_fail(1)) SWIG_fail;
26057 {
26058 arg2 = (int)(SWIG_As_int(obj1));
26059 if (SWIG_arg_fail(2)) SWIG_fail;
26060 }
26061 {
26062 PyThreadState* __tstate = wxPyBeginAllowThreads();
26063 result = wxDateSpan___rmul__(arg1,arg2);
26064
26065 wxPyEndAllowThreads(__tstate);
26066 if (PyErr_Occurred()) SWIG_fail;
26067 }
26068 {
26069 wxDateSpan * resultptr;
26070 resultptr = new wxDateSpan((wxDateSpan &)(result));
26071 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26072 }
26073 return resultobj;
26074 fail:
26075 return NULL;
26076 }
26077
26078
26079 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26080 PyObject *resultobj;
26081 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26082 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26083 bool result;
26084 PyObject * obj0 = 0 ;
26085 PyObject * obj1 = 0 ;
26086 char *kwnames[] = {
26087 (char *) "self",(char *) "other", NULL
26088 };
26089
26090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26092 if (SWIG_arg_fail(1)) SWIG_fail;
26093 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26094 if (SWIG_arg_fail(2)) SWIG_fail;
26095 {
26096 PyThreadState* __tstate = wxPyBeginAllowThreads();
26097 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26098
26099 wxPyEndAllowThreads(__tstate);
26100 if (PyErr_Occurred()) SWIG_fail;
26101 }
26102 {
26103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26104 }
26105 return resultobj;
26106 fail:
26107 return NULL;
26108 }
26109
26110
26111 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26112 PyObject *resultobj;
26113 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26114 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26115 bool result;
26116 PyObject * obj0 = 0 ;
26117 PyObject * obj1 = 0 ;
26118 char *kwnames[] = {
26119 (char *) "self",(char *) "other", NULL
26120 };
26121
26122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26124 if (SWIG_arg_fail(1)) SWIG_fail;
26125 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26126 if (SWIG_arg_fail(2)) SWIG_fail;
26127 {
26128 PyThreadState* __tstate = wxPyBeginAllowThreads();
26129 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26130
26131 wxPyEndAllowThreads(__tstate);
26132 if (PyErr_Occurred()) SWIG_fail;
26133 }
26134 {
26135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26136 }
26137 return resultobj;
26138 fail:
26139 return NULL;
26140 }
26141
26142
26143 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26144 PyObject *obj;
26145 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26146 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26147 Py_INCREF(obj);
26148 return Py_BuildValue((char *)"");
26149 }
26150 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26151 PyObject *resultobj;
26152 long result;
26153 char *kwnames[] = {
26154 NULL
26155 };
26156
26157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26158 {
26159 PyThreadState* __tstate = wxPyBeginAllowThreads();
26160 result = (long)wxGetLocalTime();
26161
26162 wxPyEndAllowThreads(__tstate);
26163 if (PyErr_Occurred()) SWIG_fail;
26164 }
26165 {
26166 resultobj = SWIG_From_long((long)(result));
26167 }
26168 return resultobj;
26169 fail:
26170 return NULL;
26171 }
26172
26173
26174 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26175 PyObject *resultobj;
26176 long result;
26177 char *kwnames[] = {
26178 NULL
26179 };
26180
26181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26182 {
26183 PyThreadState* __tstate = wxPyBeginAllowThreads();
26184 result = (long)wxGetUTCTime();
26185
26186 wxPyEndAllowThreads(__tstate);
26187 if (PyErr_Occurred()) SWIG_fail;
26188 }
26189 {
26190 resultobj = SWIG_From_long((long)(result));
26191 }
26192 return resultobj;
26193 fail:
26194 return NULL;
26195 }
26196
26197
26198 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26199 PyObject *resultobj;
26200 long result;
26201 char *kwnames[] = {
26202 NULL
26203 };
26204
26205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26206 {
26207 PyThreadState* __tstate = wxPyBeginAllowThreads();
26208 result = (long)wxGetCurrentTime();
26209
26210 wxPyEndAllowThreads(__tstate);
26211 if (PyErr_Occurred()) SWIG_fail;
26212 }
26213 {
26214 resultobj = SWIG_From_long((long)(result));
26215 }
26216 return resultobj;
26217 fail:
26218 return NULL;
26219 }
26220
26221
26222 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26223 PyObject *resultobj;
26224 wxLongLong result;
26225 char *kwnames[] = {
26226 NULL
26227 };
26228
26229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26230 {
26231 PyThreadState* __tstate = wxPyBeginAllowThreads();
26232 result = wxGetLocalTimeMillis();
26233
26234 wxPyEndAllowThreads(__tstate);
26235 if (PyErr_Occurred()) SWIG_fail;
26236 }
26237 {
26238 PyObject *hi, *lo, *shifter, *shifted;
26239 hi = PyLong_FromLong( (&result)->GetHi() );
26240 lo = PyLong_FromLong( (&result)->GetLo() );
26241 shifter = PyLong_FromLong(32);
26242 shifted = PyNumber_Lshift(hi, shifter);
26243 resultobj = PyNumber_Or(shifted, lo);
26244 Py_DECREF(hi);
26245 Py_DECREF(lo);
26246 Py_DECREF(shifter);
26247 Py_DECREF(shifted);
26248 }
26249 return resultobj;
26250 fail:
26251 return NULL;
26252 }
26253
26254
26255 static int _wrap_DefaultDateTime_set(PyObject *) {
26256 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26257 return 1;
26258 }
26259
26260
26261 static PyObject *_wrap_DefaultDateTime_get(void) {
26262 PyObject *pyobj;
26263
26264 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26265 return pyobj;
26266 }
26267
26268
26269 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26270 PyObject *resultobj;
26271 wxDataFormatId arg1 ;
26272 wxDataFormat *result;
26273 PyObject * obj0 = 0 ;
26274 char *kwnames[] = {
26275 (char *) "type", NULL
26276 };
26277
26278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26279 {
26280 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26281 if (SWIG_arg_fail(1)) SWIG_fail;
26282 }
26283 {
26284 PyThreadState* __tstate = wxPyBeginAllowThreads();
26285 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26286
26287 wxPyEndAllowThreads(__tstate);
26288 if (PyErr_Occurred()) SWIG_fail;
26289 }
26290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26291 return resultobj;
26292 fail:
26293 return NULL;
26294 }
26295
26296
26297 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26298 PyObject *resultobj;
26299 wxString *arg1 = 0 ;
26300 wxDataFormat *result;
26301 bool temp1 = false ;
26302 PyObject * obj0 = 0 ;
26303 char *kwnames[] = {
26304 (char *) "format", NULL
26305 };
26306
26307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26308 {
26309 arg1 = wxString_in_helper(obj0);
26310 if (arg1 == NULL) SWIG_fail;
26311 temp1 = true;
26312 }
26313 {
26314 PyThreadState* __tstate = wxPyBeginAllowThreads();
26315 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26316
26317 wxPyEndAllowThreads(__tstate);
26318 if (PyErr_Occurred()) SWIG_fail;
26319 }
26320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26321 {
26322 if (temp1)
26323 delete arg1;
26324 }
26325 return resultobj;
26326 fail:
26327 {
26328 if (temp1)
26329 delete arg1;
26330 }
26331 return NULL;
26332 }
26333
26334
26335 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26336 PyObject *resultobj;
26337 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26338 PyObject * obj0 = 0 ;
26339 char *kwnames[] = {
26340 (char *) "self", NULL
26341 };
26342
26343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26345 if (SWIG_arg_fail(1)) SWIG_fail;
26346 {
26347 PyThreadState* __tstate = wxPyBeginAllowThreads();
26348 delete arg1;
26349
26350 wxPyEndAllowThreads(__tstate);
26351 if (PyErr_Occurred()) SWIG_fail;
26352 }
26353 Py_INCREF(Py_None); resultobj = Py_None;
26354 return resultobj;
26355 fail:
26356 return NULL;
26357 }
26358
26359
26360 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26361 PyObject *resultobj;
26362 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26363 wxDataFormatId arg2 ;
26364 bool result;
26365 PyObject * obj0 = 0 ;
26366 PyObject * obj1 = 0 ;
26367
26368 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26370 if (SWIG_arg_fail(1)) SWIG_fail;
26371 {
26372 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26373 if (SWIG_arg_fail(2)) SWIG_fail;
26374 }
26375 {
26376 PyThreadState* __tstate = wxPyBeginAllowThreads();
26377 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26378
26379 wxPyEndAllowThreads(__tstate);
26380 if (PyErr_Occurred()) SWIG_fail;
26381 }
26382 {
26383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26384 }
26385 return resultobj;
26386 fail:
26387 return NULL;
26388 }
26389
26390
26391 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26392 PyObject *resultobj;
26393 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26394 wxDataFormatId arg2 ;
26395 bool result;
26396 PyObject * obj0 = 0 ;
26397 PyObject * obj1 = 0 ;
26398
26399 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26401 if (SWIG_arg_fail(1)) SWIG_fail;
26402 {
26403 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26404 if (SWIG_arg_fail(2)) SWIG_fail;
26405 }
26406 {
26407 PyThreadState* __tstate = wxPyBeginAllowThreads();
26408 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26409
26410 wxPyEndAllowThreads(__tstate);
26411 if (PyErr_Occurred()) SWIG_fail;
26412 }
26413 {
26414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26415 }
26416 return resultobj;
26417 fail:
26418 return NULL;
26419 }
26420
26421
26422 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26423 PyObject *resultobj;
26424 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26425 wxDataFormat *arg2 = 0 ;
26426 bool result;
26427 PyObject * obj0 = 0 ;
26428 PyObject * obj1 = 0 ;
26429
26430 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26432 if (SWIG_arg_fail(1)) SWIG_fail;
26433 {
26434 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26435 if (SWIG_arg_fail(2)) SWIG_fail;
26436 if (arg2 == NULL) {
26437 SWIG_null_ref("wxDataFormat");
26438 }
26439 if (SWIG_arg_fail(2)) SWIG_fail;
26440 }
26441 {
26442 PyThreadState* __tstate = wxPyBeginAllowThreads();
26443 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26444
26445 wxPyEndAllowThreads(__tstate);
26446 if (PyErr_Occurred()) SWIG_fail;
26447 }
26448 {
26449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26450 }
26451 return resultobj;
26452 fail:
26453 return NULL;
26454 }
26455
26456
26457 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26458 int argc;
26459 PyObject *argv[3];
26460 int ii;
26461
26462 argc = PyObject_Length(args);
26463 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26464 argv[ii] = PyTuple_GetItem(args,ii);
26465 }
26466 if (argc == 2) {
26467 int _v;
26468 {
26469 void *ptr;
26470 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26471 _v = 0;
26472 PyErr_Clear();
26473 } else {
26474 _v = 1;
26475 }
26476 }
26477 if (_v) {
26478 {
26479 void *ptr = 0;
26480 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26481 _v = 0;
26482 PyErr_Clear();
26483 } else {
26484 _v = (ptr != 0);
26485 }
26486 }
26487 if (_v) {
26488 return _wrap_DataFormat___eq____SWIG_1(self,args);
26489 }
26490 }
26491 }
26492 if (argc == 2) {
26493 int _v;
26494 {
26495 void *ptr;
26496 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26497 _v = 0;
26498 PyErr_Clear();
26499 } else {
26500 _v = 1;
26501 }
26502 }
26503 if (_v) {
26504 _v = SWIG_Check_int(argv[1]);
26505 if (_v) {
26506 return _wrap_DataFormat___eq____SWIG_0(self,args);
26507 }
26508 }
26509 }
26510
26511 Py_INCREF(Py_NotImplemented);
26512 return Py_NotImplemented;
26513 }
26514
26515
26516 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26517 PyObject *resultobj;
26518 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26519 wxDataFormat *arg2 = 0 ;
26520 bool result;
26521 PyObject * obj0 = 0 ;
26522 PyObject * obj1 = 0 ;
26523
26524 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26526 if (SWIG_arg_fail(1)) SWIG_fail;
26527 {
26528 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26529 if (SWIG_arg_fail(2)) SWIG_fail;
26530 if (arg2 == NULL) {
26531 SWIG_null_ref("wxDataFormat");
26532 }
26533 if (SWIG_arg_fail(2)) SWIG_fail;
26534 }
26535 {
26536 PyThreadState* __tstate = wxPyBeginAllowThreads();
26537 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26538
26539 wxPyEndAllowThreads(__tstate);
26540 if (PyErr_Occurred()) SWIG_fail;
26541 }
26542 {
26543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26544 }
26545 return resultobj;
26546 fail:
26547 return NULL;
26548 }
26549
26550
26551 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26552 int argc;
26553 PyObject *argv[3];
26554 int ii;
26555
26556 argc = PyObject_Length(args);
26557 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26558 argv[ii] = PyTuple_GetItem(args,ii);
26559 }
26560 if (argc == 2) {
26561 int _v;
26562 {
26563 void *ptr;
26564 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26565 _v = 0;
26566 PyErr_Clear();
26567 } else {
26568 _v = 1;
26569 }
26570 }
26571 if (_v) {
26572 {
26573 void *ptr = 0;
26574 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26575 _v = 0;
26576 PyErr_Clear();
26577 } else {
26578 _v = (ptr != 0);
26579 }
26580 }
26581 if (_v) {
26582 return _wrap_DataFormat___ne____SWIG_1(self,args);
26583 }
26584 }
26585 }
26586 if (argc == 2) {
26587 int _v;
26588 {
26589 void *ptr;
26590 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26591 _v = 0;
26592 PyErr_Clear();
26593 } else {
26594 _v = 1;
26595 }
26596 }
26597 if (_v) {
26598 _v = SWIG_Check_int(argv[1]);
26599 if (_v) {
26600 return _wrap_DataFormat___ne____SWIG_0(self,args);
26601 }
26602 }
26603 }
26604
26605 Py_INCREF(Py_NotImplemented);
26606 return Py_NotImplemented;
26607 }
26608
26609
26610 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26611 PyObject *resultobj;
26612 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26613 wxDataFormatId arg2 ;
26614 PyObject * obj0 = 0 ;
26615 PyObject * obj1 = 0 ;
26616 char *kwnames[] = {
26617 (char *) "self",(char *) "format", NULL
26618 };
26619
26620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26622 if (SWIG_arg_fail(1)) SWIG_fail;
26623 {
26624 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26625 if (SWIG_arg_fail(2)) SWIG_fail;
26626 }
26627 {
26628 PyThreadState* __tstate = wxPyBeginAllowThreads();
26629 (arg1)->SetType((wxDataFormatId )arg2);
26630
26631 wxPyEndAllowThreads(__tstate);
26632 if (PyErr_Occurred()) SWIG_fail;
26633 }
26634 Py_INCREF(Py_None); resultobj = Py_None;
26635 return resultobj;
26636 fail:
26637 return NULL;
26638 }
26639
26640
26641 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26642 PyObject *resultobj;
26643 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26644 wxDataFormatId result;
26645 PyObject * obj0 = 0 ;
26646 char *kwnames[] = {
26647 (char *) "self", NULL
26648 };
26649
26650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26652 if (SWIG_arg_fail(1)) SWIG_fail;
26653 {
26654 PyThreadState* __tstate = wxPyBeginAllowThreads();
26655 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26656
26657 wxPyEndAllowThreads(__tstate);
26658 if (PyErr_Occurred()) SWIG_fail;
26659 }
26660 resultobj = SWIG_From_int((result));
26661 return resultobj;
26662 fail:
26663 return NULL;
26664 }
26665
26666
26667 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26668 PyObject *resultobj;
26669 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26670 wxString result;
26671 PyObject * obj0 = 0 ;
26672 char *kwnames[] = {
26673 (char *) "self", NULL
26674 };
26675
26676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26678 if (SWIG_arg_fail(1)) SWIG_fail;
26679 {
26680 PyThreadState* __tstate = wxPyBeginAllowThreads();
26681 result = ((wxDataFormat const *)arg1)->GetId();
26682
26683 wxPyEndAllowThreads(__tstate);
26684 if (PyErr_Occurred()) SWIG_fail;
26685 }
26686 {
26687 #if wxUSE_UNICODE
26688 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26689 #else
26690 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26691 #endif
26692 }
26693 return resultobj;
26694 fail:
26695 return NULL;
26696 }
26697
26698
26699 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26700 PyObject *resultobj;
26701 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26702 wxString *arg2 = 0 ;
26703 bool temp2 = false ;
26704 PyObject * obj0 = 0 ;
26705 PyObject * obj1 = 0 ;
26706 char *kwnames[] = {
26707 (char *) "self",(char *) "format", NULL
26708 };
26709
26710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26712 if (SWIG_arg_fail(1)) SWIG_fail;
26713 {
26714 arg2 = wxString_in_helper(obj1);
26715 if (arg2 == NULL) SWIG_fail;
26716 temp2 = true;
26717 }
26718 {
26719 PyThreadState* __tstate = wxPyBeginAllowThreads();
26720 (arg1)->SetId((wxString const &)*arg2);
26721
26722 wxPyEndAllowThreads(__tstate);
26723 if (PyErr_Occurred()) SWIG_fail;
26724 }
26725 Py_INCREF(Py_None); resultobj = Py_None;
26726 {
26727 if (temp2)
26728 delete arg2;
26729 }
26730 return resultobj;
26731 fail:
26732 {
26733 if (temp2)
26734 delete arg2;
26735 }
26736 return NULL;
26737 }
26738
26739
26740 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26741 PyObject *obj;
26742 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26743 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26744 Py_INCREF(obj);
26745 return Py_BuildValue((char *)"");
26746 }
26747 static int _wrap_FormatInvalid_set(PyObject *) {
26748 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26749 return 1;
26750 }
26751
26752
26753 static PyObject *_wrap_FormatInvalid_get(void) {
26754 PyObject *pyobj;
26755
26756 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26757 return pyobj;
26758 }
26759
26760
26761 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26762 PyObject *resultobj;
26763 wxDataObject *arg1 = (wxDataObject *) 0 ;
26764 PyObject * obj0 = 0 ;
26765 char *kwnames[] = {
26766 (char *) "self", NULL
26767 };
26768
26769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26771 if (SWIG_arg_fail(1)) SWIG_fail;
26772 {
26773 PyThreadState* __tstate = wxPyBeginAllowThreads();
26774 delete arg1;
26775
26776 wxPyEndAllowThreads(__tstate);
26777 if (PyErr_Occurred()) SWIG_fail;
26778 }
26779 Py_INCREF(Py_None); resultobj = Py_None;
26780 return resultobj;
26781 fail:
26782 return NULL;
26783 }
26784
26785
26786 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26787 PyObject *resultobj;
26788 wxDataObject *arg1 = (wxDataObject *) 0 ;
26789 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26790 SwigValueWrapper<wxDataFormat > result;
26791 PyObject * obj0 = 0 ;
26792 PyObject * obj1 = 0 ;
26793 char *kwnames[] = {
26794 (char *) "self",(char *) "dir", NULL
26795 };
26796
26797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26799 if (SWIG_arg_fail(1)) SWIG_fail;
26800 if (obj1) {
26801 {
26802 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26803 if (SWIG_arg_fail(2)) SWIG_fail;
26804 }
26805 }
26806 {
26807 PyThreadState* __tstate = wxPyBeginAllowThreads();
26808 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26809
26810 wxPyEndAllowThreads(__tstate);
26811 if (PyErr_Occurred()) SWIG_fail;
26812 }
26813 {
26814 wxDataFormat * resultptr;
26815 resultptr = new wxDataFormat((wxDataFormat &)(result));
26816 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26817 }
26818 return resultobj;
26819 fail:
26820 return NULL;
26821 }
26822
26823
26824 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26825 PyObject *resultobj;
26826 wxDataObject *arg1 = (wxDataObject *) 0 ;
26827 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26828 size_t result;
26829 PyObject * obj0 = 0 ;
26830 PyObject * obj1 = 0 ;
26831 char *kwnames[] = {
26832 (char *) "self",(char *) "dir", NULL
26833 };
26834
26835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26837 if (SWIG_arg_fail(1)) SWIG_fail;
26838 if (obj1) {
26839 {
26840 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26841 if (SWIG_arg_fail(2)) SWIG_fail;
26842 }
26843 }
26844 {
26845 PyThreadState* __tstate = wxPyBeginAllowThreads();
26846 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
26847
26848 wxPyEndAllowThreads(__tstate);
26849 if (PyErr_Occurred()) SWIG_fail;
26850 }
26851 {
26852 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26853 }
26854 return resultobj;
26855 fail:
26856 return NULL;
26857 }
26858
26859
26860 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
26861 PyObject *resultobj;
26862 wxDataObject *arg1 = (wxDataObject *) 0 ;
26863 wxDataFormat *arg2 = 0 ;
26864 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
26865 bool result;
26866 PyObject * obj0 = 0 ;
26867 PyObject * obj1 = 0 ;
26868 PyObject * obj2 = 0 ;
26869 char *kwnames[] = {
26870 (char *) "self",(char *) "format",(char *) "dir", NULL
26871 };
26872
26873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
26874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26875 if (SWIG_arg_fail(1)) SWIG_fail;
26876 {
26877 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26878 if (SWIG_arg_fail(2)) SWIG_fail;
26879 if (arg2 == NULL) {
26880 SWIG_null_ref("wxDataFormat");
26881 }
26882 if (SWIG_arg_fail(2)) SWIG_fail;
26883 }
26884 if (obj2) {
26885 {
26886 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
26887 if (SWIG_arg_fail(3)) SWIG_fail;
26888 }
26889 }
26890 {
26891 PyThreadState* __tstate = wxPyBeginAllowThreads();
26892 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
26893
26894 wxPyEndAllowThreads(__tstate);
26895 if (PyErr_Occurred()) SWIG_fail;
26896 }
26897 {
26898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26899 }
26900 return resultobj;
26901 fail:
26902 return NULL;
26903 }
26904
26905
26906 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26907 PyObject *resultobj;
26908 wxDataObject *arg1 = (wxDataObject *) 0 ;
26909 wxDataFormat *arg2 = 0 ;
26910 size_t result;
26911 PyObject * obj0 = 0 ;
26912 PyObject * obj1 = 0 ;
26913 char *kwnames[] = {
26914 (char *) "self",(char *) "format", NULL
26915 };
26916
26917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
26918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26919 if (SWIG_arg_fail(1)) SWIG_fail;
26920 {
26921 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26922 if (SWIG_arg_fail(2)) SWIG_fail;
26923 if (arg2 == NULL) {
26924 SWIG_null_ref("wxDataFormat");
26925 }
26926 if (SWIG_arg_fail(2)) SWIG_fail;
26927 }
26928 {
26929 PyThreadState* __tstate = wxPyBeginAllowThreads();
26930 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
26931
26932 wxPyEndAllowThreads(__tstate);
26933 if (PyErr_Occurred()) SWIG_fail;
26934 }
26935 {
26936 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26937 }
26938 return resultobj;
26939 fail:
26940 return NULL;
26941 }
26942
26943
26944 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
26945 PyObject *resultobj;
26946 wxDataObject *arg1 = (wxDataObject *) 0 ;
26947 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26948 PyObject *result;
26949 PyObject * obj0 = 0 ;
26950 PyObject * obj1 = 0 ;
26951 char *kwnames[] = {
26952 (char *) "self",(char *) "dir", NULL
26953 };
26954
26955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
26956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26957 if (SWIG_arg_fail(1)) SWIG_fail;
26958 if (obj1) {
26959 {
26960 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26961 if (SWIG_arg_fail(2)) SWIG_fail;
26962 }
26963 }
26964 {
26965 PyThreadState* __tstate = wxPyBeginAllowThreads();
26966 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
26967
26968 wxPyEndAllowThreads(__tstate);
26969 if (PyErr_Occurred()) SWIG_fail;
26970 }
26971 resultobj = result;
26972 return resultobj;
26973 fail:
26974 return NULL;
26975 }
26976
26977
26978 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
26979 PyObject *resultobj;
26980 wxDataObject *arg1 = (wxDataObject *) 0 ;
26981 wxDataFormat *arg2 = 0 ;
26982 PyObject *result;
26983 PyObject * obj0 = 0 ;
26984 PyObject * obj1 = 0 ;
26985 char *kwnames[] = {
26986 (char *) "self",(char *) "format", NULL
26987 };
26988
26989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
26990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26991 if (SWIG_arg_fail(1)) SWIG_fail;
26992 {
26993 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26994 if (SWIG_arg_fail(2)) SWIG_fail;
26995 if (arg2 == NULL) {
26996 SWIG_null_ref("wxDataFormat");
26997 }
26998 if (SWIG_arg_fail(2)) SWIG_fail;
26999 }
27000 {
27001 PyThreadState* __tstate = wxPyBeginAllowThreads();
27002 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27003
27004 wxPyEndAllowThreads(__tstate);
27005 if (PyErr_Occurred()) SWIG_fail;
27006 }
27007 resultobj = result;
27008 return resultobj;
27009 fail:
27010 return NULL;
27011 }
27012
27013
27014 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27015 PyObject *resultobj;
27016 wxDataObject *arg1 = (wxDataObject *) 0 ;
27017 wxDataFormat *arg2 = 0 ;
27018 PyObject *arg3 = (PyObject *) 0 ;
27019 bool result;
27020 PyObject * obj0 = 0 ;
27021 PyObject * obj1 = 0 ;
27022 PyObject * obj2 = 0 ;
27023 char *kwnames[] = {
27024 (char *) "self",(char *) "format",(char *) "data", NULL
27025 };
27026
27027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27029 if (SWIG_arg_fail(1)) SWIG_fail;
27030 {
27031 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27032 if (SWIG_arg_fail(2)) SWIG_fail;
27033 if (arg2 == NULL) {
27034 SWIG_null_ref("wxDataFormat");
27035 }
27036 if (SWIG_arg_fail(2)) SWIG_fail;
27037 }
27038 arg3 = obj2;
27039 {
27040 PyThreadState* __tstate = wxPyBeginAllowThreads();
27041 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27042
27043 wxPyEndAllowThreads(__tstate);
27044 if (PyErr_Occurred()) SWIG_fail;
27045 }
27046 {
27047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27048 }
27049 return resultobj;
27050 fail:
27051 return NULL;
27052 }
27053
27054
27055 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27056 PyObject *obj;
27057 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27058 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27059 Py_INCREF(obj);
27060 return Py_BuildValue((char *)"");
27061 }
27062 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27063 PyObject *resultobj;
27064 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27065 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27066 wxDataObjectSimple *result;
27067 PyObject * obj0 = 0 ;
27068 char *kwnames[] = {
27069 (char *) "format", NULL
27070 };
27071
27072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27073 if (obj0) {
27074 {
27075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27076 if (SWIG_arg_fail(1)) SWIG_fail;
27077 if (arg1 == NULL) {
27078 SWIG_null_ref("wxDataFormat");
27079 }
27080 if (SWIG_arg_fail(1)) SWIG_fail;
27081 }
27082 }
27083 {
27084 PyThreadState* __tstate = wxPyBeginAllowThreads();
27085 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27086
27087 wxPyEndAllowThreads(__tstate);
27088 if (PyErr_Occurred()) SWIG_fail;
27089 }
27090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27091 return resultobj;
27092 fail:
27093 return NULL;
27094 }
27095
27096
27097 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27098 PyObject *resultobj;
27099 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27100 wxDataFormat *result;
27101 PyObject * obj0 = 0 ;
27102 char *kwnames[] = {
27103 (char *) "self", NULL
27104 };
27105
27106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27108 if (SWIG_arg_fail(1)) SWIG_fail;
27109 {
27110 PyThreadState* __tstate = wxPyBeginAllowThreads();
27111 {
27112 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27113 result = (wxDataFormat *) &_result_ref;
27114 }
27115
27116 wxPyEndAllowThreads(__tstate);
27117 if (PyErr_Occurred()) SWIG_fail;
27118 }
27119 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27120 return resultobj;
27121 fail:
27122 return NULL;
27123 }
27124
27125
27126 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27127 PyObject *resultobj;
27128 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27129 wxDataFormat *arg2 = 0 ;
27130 PyObject * obj0 = 0 ;
27131 PyObject * obj1 = 0 ;
27132 char *kwnames[] = {
27133 (char *) "self",(char *) "format", NULL
27134 };
27135
27136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27138 if (SWIG_arg_fail(1)) SWIG_fail;
27139 {
27140 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27141 if (SWIG_arg_fail(2)) SWIG_fail;
27142 if (arg2 == NULL) {
27143 SWIG_null_ref("wxDataFormat");
27144 }
27145 if (SWIG_arg_fail(2)) SWIG_fail;
27146 }
27147 {
27148 PyThreadState* __tstate = wxPyBeginAllowThreads();
27149 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27150
27151 wxPyEndAllowThreads(__tstate);
27152 if (PyErr_Occurred()) SWIG_fail;
27153 }
27154 Py_INCREF(Py_None); resultobj = Py_None;
27155 return resultobj;
27156 fail:
27157 return NULL;
27158 }
27159
27160
27161 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27162 PyObject *resultobj;
27163 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27164 size_t result;
27165 PyObject * obj0 = 0 ;
27166 char *kwnames[] = {
27167 (char *) "self", NULL
27168 };
27169
27170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27172 if (SWIG_arg_fail(1)) SWIG_fail;
27173 {
27174 PyThreadState* __tstate = wxPyBeginAllowThreads();
27175 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27176
27177 wxPyEndAllowThreads(__tstate);
27178 if (PyErr_Occurred()) SWIG_fail;
27179 }
27180 {
27181 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27182 }
27183 return resultobj;
27184 fail:
27185 return NULL;
27186 }
27187
27188
27189 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27190 PyObject *resultobj;
27191 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27192 PyObject *result;
27193 PyObject * obj0 = 0 ;
27194 char *kwnames[] = {
27195 (char *) "self", NULL
27196 };
27197
27198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27200 if (SWIG_arg_fail(1)) SWIG_fail;
27201 {
27202 PyThreadState* __tstate = wxPyBeginAllowThreads();
27203 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27204
27205 wxPyEndAllowThreads(__tstate);
27206 if (PyErr_Occurred()) SWIG_fail;
27207 }
27208 resultobj = result;
27209 return resultobj;
27210 fail:
27211 return NULL;
27212 }
27213
27214
27215 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27216 PyObject *resultobj;
27217 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27218 PyObject *arg2 = (PyObject *) 0 ;
27219 bool result;
27220 PyObject * obj0 = 0 ;
27221 PyObject * obj1 = 0 ;
27222 char *kwnames[] = {
27223 (char *) "self",(char *) "data", NULL
27224 };
27225
27226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27228 if (SWIG_arg_fail(1)) SWIG_fail;
27229 arg2 = obj1;
27230 {
27231 PyThreadState* __tstate = wxPyBeginAllowThreads();
27232 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27233
27234 wxPyEndAllowThreads(__tstate);
27235 if (PyErr_Occurred()) SWIG_fail;
27236 }
27237 {
27238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27239 }
27240 return resultobj;
27241 fail:
27242 return NULL;
27243 }
27244
27245
27246 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27247 PyObject *obj;
27248 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27249 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27250 Py_INCREF(obj);
27251 return Py_BuildValue((char *)"");
27252 }
27253 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27254 PyObject *resultobj;
27255 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27256 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27257 wxPyDataObjectSimple *result;
27258 PyObject * obj0 = 0 ;
27259 char *kwnames[] = {
27260 (char *) "format", NULL
27261 };
27262
27263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27264 if (obj0) {
27265 {
27266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27267 if (SWIG_arg_fail(1)) SWIG_fail;
27268 if (arg1 == NULL) {
27269 SWIG_null_ref("wxDataFormat");
27270 }
27271 if (SWIG_arg_fail(1)) SWIG_fail;
27272 }
27273 }
27274 {
27275 PyThreadState* __tstate = wxPyBeginAllowThreads();
27276 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27277
27278 wxPyEndAllowThreads(__tstate);
27279 if (PyErr_Occurred()) SWIG_fail;
27280 }
27281 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27282 return resultobj;
27283 fail:
27284 return NULL;
27285 }
27286
27287
27288 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27289 PyObject *resultobj;
27290 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27291 PyObject *arg2 = (PyObject *) 0 ;
27292 PyObject *arg3 = (PyObject *) 0 ;
27293 PyObject * obj0 = 0 ;
27294 PyObject * obj1 = 0 ;
27295 PyObject * obj2 = 0 ;
27296 char *kwnames[] = {
27297 (char *) "self",(char *) "self",(char *) "_class", NULL
27298 };
27299
27300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27302 if (SWIG_arg_fail(1)) SWIG_fail;
27303 arg2 = obj1;
27304 arg3 = obj2;
27305 {
27306 PyThreadState* __tstate = wxPyBeginAllowThreads();
27307 (arg1)->_setCallbackInfo(arg2,arg3);
27308
27309 wxPyEndAllowThreads(__tstate);
27310 if (PyErr_Occurred()) SWIG_fail;
27311 }
27312 Py_INCREF(Py_None); resultobj = Py_None;
27313 return resultobj;
27314 fail:
27315 return NULL;
27316 }
27317
27318
27319 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27320 PyObject *obj;
27321 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27322 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27323 Py_INCREF(obj);
27324 return Py_BuildValue((char *)"");
27325 }
27326 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27327 PyObject *resultobj;
27328 wxDataObjectComposite *result;
27329 char *kwnames[] = {
27330 NULL
27331 };
27332
27333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27334 {
27335 PyThreadState* __tstate = wxPyBeginAllowThreads();
27336 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27337
27338 wxPyEndAllowThreads(__tstate);
27339 if (PyErr_Occurred()) SWIG_fail;
27340 }
27341 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27342 return resultobj;
27343 fail:
27344 return NULL;
27345 }
27346
27347
27348 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27349 PyObject *resultobj;
27350 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27351 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27352 bool arg3 = (bool) false ;
27353 PyObject * obj0 = 0 ;
27354 PyObject * obj1 = 0 ;
27355 PyObject * obj2 = 0 ;
27356 char *kwnames[] = {
27357 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27358 };
27359
27360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27362 if (SWIG_arg_fail(1)) SWIG_fail;
27363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27364 if (SWIG_arg_fail(2)) SWIG_fail;
27365 if (obj2) {
27366 {
27367 arg3 = (bool)(SWIG_As_bool(obj2));
27368 if (SWIG_arg_fail(3)) SWIG_fail;
27369 }
27370 }
27371 {
27372 PyThreadState* __tstate = wxPyBeginAllowThreads();
27373 (arg1)->Add(arg2,arg3);
27374
27375 wxPyEndAllowThreads(__tstate);
27376 if (PyErr_Occurred()) SWIG_fail;
27377 }
27378 Py_INCREF(Py_None); resultobj = Py_None;
27379 return resultobj;
27380 fail:
27381 return NULL;
27382 }
27383
27384
27385 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27386 PyObject *obj;
27387 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27388 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27389 Py_INCREF(obj);
27390 return Py_BuildValue((char *)"");
27391 }
27392 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27393 PyObject *resultobj;
27394 wxString const &arg1_defvalue = wxPyEmptyString ;
27395 wxString *arg1 = (wxString *) &arg1_defvalue ;
27396 wxTextDataObject *result;
27397 bool temp1 = false ;
27398 PyObject * obj0 = 0 ;
27399 char *kwnames[] = {
27400 (char *) "text", NULL
27401 };
27402
27403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27404 if (obj0) {
27405 {
27406 arg1 = wxString_in_helper(obj0);
27407 if (arg1 == NULL) SWIG_fail;
27408 temp1 = true;
27409 }
27410 }
27411 {
27412 PyThreadState* __tstate = wxPyBeginAllowThreads();
27413 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27414
27415 wxPyEndAllowThreads(__tstate);
27416 if (PyErr_Occurred()) SWIG_fail;
27417 }
27418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27419 {
27420 if (temp1)
27421 delete arg1;
27422 }
27423 return resultobj;
27424 fail:
27425 {
27426 if (temp1)
27427 delete arg1;
27428 }
27429 return NULL;
27430 }
27431
27432
27433 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27434 PyObject *resultobj;
27435 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27436 size_t result;
27437 PyObject * obj0 = 0 ;
27438 char *kwnames[] = {
27439 (char *) "self", NULL
27440 };
27441
27442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27444 if (SWIG_arg_fail(1)) SWIG_fail;
27445 {
27446 PyThreadState* __tstate = wxPyBeginAllowThreads();
27447 result = (size_t)(arg1)->GetTextLength();
27448
27449 wxPyEndAllowThreads(__tstate);
27450 if (PyErr_Occurred()) SWIG_fail;
27451 }
27452 {
27453 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27454 }
27455 return resultobj;
27456 fail:
27457 return NULL;
27458 }
27459
27460
27461 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27462 PyObject *resultobj;
27463 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27464 wxString result;
27465 PyObject * obj0 = 0 ;
27466 char *kwnames[] = {
27467 (char *) "self", NULL
27468 };
27469
27470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27472 if (SWIG_arg_fail(1)) SWIG_fail;
27473 {
27474 PyThreadState* __tstate = wxPyBeginAllowThreads();
27475 result = (arg1)->GetText();
27476
27477 wxPyEndAllowThreads(__tstate);
27478 if (PyErr_Occurred()) SWIG_fail;
27479 }
27480 {
27481 #if wxUSE_UNICODE
27482 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27483 #else
27484 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27485 #endif
27486 }
27487 return resultobj;
27488 fail:
27489 return NULL;
27490 }
27491
27492
27493 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27494 PyObject *resultobj;
27495 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27496 wxString *arg2 = 0 ;
27497 bool temp2 = false ;
27498 PyObject * obj0 = 0 ;
27499 PyObject * obj1 = 0 ;
27500 char *kwnames[] = {
27501 (char *) "self",(char *) "text", NULL
27502 };
27503
27504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27506 if (SWIG_arg_fail(1)) SWIG_fail;
27507 {
27508 arg2 = wxString_in_helper(obj1);
27509 if (arg2 == NULL) SWIG_fail;
27510 temp2 = true;
27511 }
27512 {
27513 PyThreadState* __tstate = wxPyBeginAllowThreads();
27514 (arg1)->SetText((wxString const &)*arg2);
27515
27516 wxPyEndAllowThreads(__tstate);
27517 if (PyErr_Occurred()) SWIG_fail;
27518 }
27519 Py_INCREF(Py_None); resultobj = Py_None;
27520 {
27521 if (temp2)
27522 delete arg2;
27523 }
27524 return resultobj;
27525 fail:
27526 {
27527 if (temp2)
27528 delete arg2;
27529 }
27530 return NULL;
27531 }
27532
27533
27534 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27535 PyObject *obj;
27536 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27537 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27538 Py_INCREF(obj);
27539 return Py_BuildValue((char *)"");
27540 }
27541 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27542 PyObject *resultobj;
27543 wxString const &arg1_defvalue = wxPyEmptyString ;
27544 wxString *arg1 = (wxString *) &arg1_defvalue ;
27545 wxPyTextDataObject *result;
27546 bool temp1 = false ;
27547 PyObject * obj0 = 0 ;
27548 char *kwnames[] = {
27549 (char *) "text", NULL
27550 };
27551
27552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27553 if (obj0) {
27554 {
27555 arg1 = wxString_in_helper(obj0);
27556 if (arg1 == NULL) SWIG_fail;
27557 temp1 = true;
27558 }
27559 }
27560 {
27561 PyThreadState* __tstate = wxPyBeginAllowThreads();
27562 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27563
27564 wxPyEndAllowThreads(__tstate);
27565 if (PyErr_Occurred()) SWIG_fail;
27566 }
27567 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27568 {
27569 if (temp1)
27570 delete arg1;
27571 }
27572 return resultobj;
27573 fail:
27574 {
27575 if (temp1)
27576 delete arg1;
27577 }
27578 return NULL;
27579 }
27580
27581
27582 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27583 PyObject *resultobj;
27584 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27585 PyObject *arg2 = (PyObject *) 0 ;
27586 PyObject *arg3 = (PyObject *) 0 ;
27587 PyObject * obj0 = 0 ;
27588 PyObject * obj1 = 0 ;
27589 PyObject * obj2 = 0 ;
27590 char *kwnames[] = {
27591 (char *) "self",(char *) "self",(char *) "_class", NULL
27592 };
27593
27594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27596 if (SWIG_arg_fail(1)) SWIG_fail;
27597 arg2 = obj1;
27598 arg3 = obj2;
27599 {
27600 PyThreadState* __tstate = wxPyBeginAllowThreads();
27601 (arg1)->_setCallbackInfo(arg2,arg3);
27602
27603 wxPyEndAllowThreads(__tstate);
27604 if (PyErr_Occurred()) SWIG_fail;
27605 }
27606 Py_INCREF(Py_None); resultobj = Py_None;
27607 return resultobj;
27608 fail:
27609 return NULL;
27610 }
27611
27612
27613 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27614 PyObject *obj;
27615 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27616 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27617 Py_INCREF(obj);
27618 return Py_BuildValue((char *)"");
27619 }
27620 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27621 PyObject *resultobj;
27622 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27623 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27624 wxBitmapDataObject *result;
27625 PyObject * obj0 = 0 ;
27626 char *kwnames[] = {
27627 (char *) "bitmap", NULL
27628 };
27629
27630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27631 if (obj0) {
27632 {
27633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27634 if (SWIG_arg_fail(1)) SWIG_fail;
27635 if (arg1 == NULL) {
27636 SWIG_null_ref("wxBitmap");
27637 }
27638 if (SWIG_arg_fail(1)) SWIG_fail;
27639 }
27640 }
27641 {
27642 PyThreadState* __tstate = wxPyBeginAllowThreads();
27643 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27644
27645 wxPyEndAllowThreads(__tstate);
27646 if (PyErr_Occurred()) SWIG_fail;
27647 }
27648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27649 return resultobj;
27650 fail:
27651 return NULL;
27652 }
27653
27654
27655 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27656 PyObject *resultobj;
27657 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27658 wxBitmap result;
27659 PyObject * obj0 = 0 ;
27660 char *kwnames[] = {
27661 (char *) "self", NULL
27662 };
27663
27664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27666 if (SWIG_arg_fail(1)) SWIG_fail;
27667 {
27668 PyThreadState* __tstate = wxPyBeginAllowThreads();
27669 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27670
27671 wxPyEndAllowThreads(__tstate);
27672 if (PyErr_Occurred()) SWIG_fail;
27673 }
27674 {
27675 wxBitmap * resultptr;
27676 resultptr = new wxBitmap((wxBitmap &)(result));
27677 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27678 }
27679 return resultobj;
27680 fail:
27681 return NULL;
27682 }
27683
27684
27685 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27686 PyObject *resultobj;
27687 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27688 wxBitmap *arg2 = 0 ;
27689 PyObject * obj0 = 0 ;
27690 PyObject * obj1 = 0 ;
27691 char *kwnames[] = {
27692 (char *) "self",(char *) "bitmap", NULL
27693 };
27694
27695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27697 if (SWIG_arg_fail(1)) SWIG_fail;
27698 {
27699 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27700 if (SWIG_arg_fail(2)) SWIG_fail;
27701 if (arg2 == NULL) {
27702 SWIG_null_ref("wxBitmap");
27703 }
27704 if (SWIG_arg_fail(2)) SWIG_fail;
27705 }
27706 {
27707 PyThreadState* __tstate = wxPyBeginAllowThreads();
27708 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27709
27710 wxPyEndAllowThreads(__tstate);
27711 if (PyErr_Occurred()) SWIG_fail;
27712 }
27713 Py_INCREF(Py_None); resultobj = Py_None;
27714 return resultobj;
27715 fail:
27716 return NULL;
27717 }
27718
27719
27720 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27721 PyObject *obj;
27722 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27723 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27724 Py_INCREF(obj);
27725 return Py_BuildValue((char *)"");
27726 }
27727 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27728 PyObject *resultobj;
27729 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27730 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27731 wxPyBitmapDataObject *result;
27732 PyObject * obj0 = 0 ;
27733 char *kwnames[] = {
27734 (char *) "bitmap", NULL
27735 };
27736
27737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27738 if (obj0) {
27739 {
27740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27741 if (SWIG_arg_fail(1)) SWIG_fail;
27742 if (arg1 == NULL) {
27743 SWIG_null_ref("wxBitmap");
27744 }
27745 if (SWIG_arg_fail(1)) SWIG_fail;
27746 }
27747 }
27748 {
27749 PyThreadState* __tstate = wxPyBeginAllowThreads();
27750 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27751
27752 wxPyEndAllowThreads(__tstate);
27753 if (PyErr_Occurred()) SWIG_fail;
27754 }
27755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27756 return resultobj;
27757 fail:
27758 return NULL;
27759 }
27760
27761
27762 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27763 PyObject *resultobj;
27764 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27765 PyObject *arg2 = (PyObject *) 0 ;
27766 PyObject *arg3 = (PyObject *) 0 ;
27767 PyObject * obj0 = 0 ;
27768 PyObject * obj1 = 0 ;
27769 PyObject * obj2 = 0 ;
27770 char *kwnames[] = {
27771 (char *) "self",(char *) "self",(char *) "_class", NULL
27772 };
27773
27774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27776 if (SWIG_arg_fail(1)) SWIG_fail;
27777 arg2 = obj1;
27778 arg3 = obj2;
27779 {
27780 PyThreadState* __tstate = wxPyBeginAllowThreads();
27781 (arg1)->_setCallbackInfo(arg2,arg3);
27782
27783 wxPyEndAllowThreads(__tstate);
27784 if (PyErr_Occurred()) SWIG_fail;
27785 }
27786 Py_INCREF(Py_None); resultobj = Py_None;
27787 return resultobj;
27788 fail:
27789 return NULL;
27790 }
27791
27792
27793 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27794 PyObject *obj;
27795 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27796 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27797 Py_INCREF(obj);
27798 return Py_BuildValue((char *)"");
27799 }
27800 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27801 PyObject *resultobj;
27802 wxFileDataObject *result;
27803 char *kwnames[] = {
27804 NULL
27805 };
27806
27807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27808 {
27809 PyThreadState* __tstate = wxPyBeginAllowThreads();
27810 result = (wxFileDataObject *)new wxFileDataObject();
27811
27812 wxPyEndAllowThreads(__tstate);
27813 if (PyErr_Occurred()) SWIG_fail;
27814 }
27815 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27816 return resultobj;
27817 fail:
27818 return NULL;
27819 }
27820
27821
27822 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27823 PyObject *resultobj;
27824 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27825 wxArrayString *result;
27826 PyObject * obj0 = 0 ;
27827 char *kwnames[] = {
27828 (char *) "self", NULL
27829 };
27830
27831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27833 if (SWIG_arg_fail(1)) SWIG_fail;
27834 {
27835 PyThreadState* __tstate = wxPyBeginAllowThreads();
27836 {
27837 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27838 result = (wxArrayString *) &_result_ref;
27839 }
27840
27841 wxPyEndAllowThreads(__tstate);
27842 if (PyErr_Occurred()) SWIG_fail;
27843 }
27844 {
27845 resultobj = wxArrayString2PyList_helper(*result);
27846 }
27847 return resultobj;
27848 fail:
27849 return NULL;
27850 }
27851
27852
27853 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
27854 PyObject *resultobj;
27855 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27856 wxString *arg2 = 0 ;
27857 bool temp2 = false ;
27858 PyObject * obj0 = 0 ;
27859 PyObject * obj1 = 0 ;
27860 char *kwnames[] = {
27861 (char *) "self",(char *) "filename", NULL
27862 };
27863
27864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
27865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27866 if (SWIG_arg_fail(1)) SWIG_fail;
27867 {
27868 arg2 = wxString_in_helper(obj1);
27869 if (arg2 == NULL) SWIG_fail;
27870 temp2 = true;
27871 }
27872 {
27873 PyThreadState* __tstate = wxPyBeginAllowThreads();
27874 (arg1)->AddFile((wxString const &)*arg2);
27875
27876 wxPyEndAllowThreads(__tstate);
27877 if (PyErr_Occurred()) SWIG_fail;
27878 }
27879 Py_INCREF(Py_None); resultobj = Py_None;
27880 {
27881 if (temp2)
27882 delete arg2;
27883 }
27884 return resultobj;
27885 fail:
27886 {
27887 if (temp2)
27888 delete arg2;
27889 }
27890 return NULL;
27891 }
27892
27893
27894 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
27895 PyObject *obj;
27896 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27897 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
27898 Py_INCREF(obj);
27899 return Py_BuildValue((char *)"");
27900 }
27901 static PyObject *_wrap_new_CustomDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27902 PyObject *resultobj;
27903 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27904 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27905 wxCustomDataObject *result;
27906 PyObject * obj0 = 0 ;
27907 char *kwnames[] = {
27908 (char *) "format", NULL
27909 };
27910
27911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_CustomDataObject",kwnames,&obj0)) goto fail;
27912 if (obj0) {
27913 {
27914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27915 if (SWIG_arg_fail(1)) SWIG_fail;
27916 if (arg1 == NULL) {
27917 SWIG_null_ref("wxDataFormat");
27918 }
27919 if (SWIG_arg_fail(1)) SWIG_fail;
27920 }
27921 }
27922 {
27923 PyThreadState* __tstate = wxPyBeginAllowThreads();
27924 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
27925
27926 wxPyEndAllowThreads(__tstate);
27927 if (PyErr_Occurred()) SWIG_fail;
27928 }
27929 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27930 return resultobj;
27931 fail:
27932 return NULL;
27933 }
27934
27935
27936 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27937 PyObject *resultobj;
27938 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27939 PyObject *arg2 = (PyObject *) 0 ;
27940 bool result;
27941 PyObject * obj0 = 0 ;
27942 PyObject * obj1 = 0 ;
27943 char *kwnames[] = {
27944 (char *) "self",(char *) "data", NULL
27945 };
27946
27947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
27948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27949 if (SWIG_arg_fail(1)) SWIG_fail;
27950 arg2 = obj1;
27951 {
27952 PyThreadState* __tstate = wxPyBeginAllowThreads();
27953 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
27954
27955 wxPyEndAllowThreads(__tstate);
27956 if (PyErr_Occurred()) SWIG_fail;
27957 }
27958 {
27959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27960 }
27961 return resultobj;
27962 fail:
27963 return NULL;
27964 }
27965
27966
27967 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
27968 PyObject *resultobj;
27969 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27970 size_t result;
27971 PyObject * obj0 = 0 ;
27972 char *kwnames[] = {
27973 (char *) "self", NULL
27974 };
27975
27976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
27977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27978 if (SWIG_arg_fail(1)) SWIG_fail;
27979 {
27980 PyThreadState* __tstate = wxPyBeginAllowThreads();
27981 result = (size_t)(arg1)->GetSize();
27982
27983 wxPyEndAllowThreads(__tstate);
27984 if (PyErr_Occurred()) SWIG_fail;
27985 }
27986 {
27987 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27988 }
27989 return resultobj;
27990 fail:
27991 return NULL;
27992 }
27993
27994
27995 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
27996 PyObject *resultobj;
27997 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27998 PyObject *result;
27999 PyObject * obj0 = 0 ;
28000 char *kwnames[] = {
28001 (char *) "self", NULL
28002 };
28003
28004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28006 if (SWIG_arg_fail(1)) SWIG_fail;
28007 {
28008 PyThreadState* __tstate = wxPyBeginAllowThreads();
28009 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28010
28011 wxPyEndAllowThreads(__tstate);
28012 if (PyErr_Occurred()) SWIG_fail;
28013 }
28014 resultobj = result;
28015 return resultobj;
28016 fail:
28017 return NULL;
28018 }
28019
28020
28021 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28022 PyObject *obj;
28023 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28024 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28025 Py_INCREF(obj);
28026 return Py_BuildValue((char *)"");
28027 }
28028 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28029 PyObject *resultobj;
28030 wxURLDataObject *result;
28031 char *kwnames[] = {
28032 NULL
28033 };
28034
28035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28036 {
28037 PyThreadState* __tstate = wxPyBeginAllowThreads();
28038 result = (wxURLDataObject *)new wxURLDataObject();
28039
28040 wxPyEndAllowThreads(__tstate);
28041 if (PyErr_Occurred()) SWIG_fail;
28042 }
28043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28044 return resultobj;
28045 fail:
28046 return NULL;
28047 }
28048
28049
28050 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28051 PyObject *resultobj;
28052 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28053 wxString result;
28054 PyObject * obj0 = 0 ;
28055 char *kwnames[] = {
28056 (char *) "self", NULL
28057 };
28058
28059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28061 if (SWIG_arg_fail(1)) SWIG_fail;
28062 {
28063 PyThreadState* __tstate = wxPyBeginAllowThreads();
28064 result = (arg1)->GetURL();
28065
28066 wxPyEndAllowThreads(__tstate);
28067 if (PyErr_Occurred()) SWIG_fail;
28068 }
28069 {
28070 #if wxUSE_UNICODE
28071 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28072 #else
28073 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28074 #endif
28075 }
28076 return resultobj;
28077 fail:
28078 return NULL;
28079 }
28080
28081
28082 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28083 PyObject *resultobj;
28084 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28085 wxString *arg2 = 0 ;
28086 bool temp2 = false ;
28087 PyObject * obj0 = 0 ;
28088 PyObject * obj1 = 0 ;
28089 char *kwnames[] = {
28090 (char *) "self",(char *) "url", NULL
28091 };
28092
28093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28095 if (SWIG_arg_fail(1)) SWIG_fail;
28096 {
28097 arg2 = wxString_in_helper(obj1);
28098 if (arg2 == NULL) SWIG_fail;
28099 temp2 = true;
28100 }
28101 {
28102 PyThreadState* __tstate = wxPyBeginAllowThreads();
28103 (arg1)->SetURL((wxString const &)*arg2);
28104
28105 wxPyEndAllowThreads(__tstate);
28106 if (PyErr_Occurred()) SWIG_fail;
28107 }
28108 Py_INCREF(Py_None); resultobj = Py_None;
28109 {
28110 if (temp2)
28111 delete arg2;
28112 }
28113 return resultobj;
28114 fail:
28115 {
28116 if (temp2)
28117 delete arg2;
28118 }
28119 return NULL;
28120 }
28121
28122
28123 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28124 PyObject *obj;
28125 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28126 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28127 Py_INCREF(obj);
28128 return Py_BuildValue((char *)"");
28129 }
28130 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28131 PyObject *resultobj;
28132 wxMetafileDataObject *result;
28133 char *kwnames[] = {
28134 NULL
28135 };
28136
28137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28138 {
28139 PyThreadState* __tstate = wxPyBeginAllowThreads();
28140 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28141
28142 wxPyEndAllowThreads(__tstate);
28143 if (PyErr_Occurred()) SWIG_fail;
28144 }
28145 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28146 return resultobj;
28147 fail:
28148 return NULL;
28149 }
28150
28151
28152 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28153 PyObject *resultobj;
28154 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28155 wxMetafile *arg2 = 0 ;
28156 PyObject * obj0 = 0 ;
28157 PyObject * obj1 = 0 ;
28158 char *kwnames[] = {
28159 (char *) "self",(char *) "metafile", NULL
28160 };
28161
28162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28164 if (SWIG_arg_fail(1)) SWIG_fail;
28165 {
28166 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28167 if (SWIG_arg_fail(2)) SWIG_fail;
28168 if (arg2 == NULL) {
28169 SWIG_null_ref("wxMetafile");
28170 }
28171 if (SWIG_arg_fail(2)) SWIG_fail;
28172 }
28173 {
28174 PyThreadState* __tstate = wxPyBeginAllowThreads();
28175 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28176
28177 wxPyEndAllowThreads(__tstate);
28178 if (PyErr_Occurred()) SWIG_fail;
28179 }
28180 Py_INCREF(Py_None); resultobj = Py_None;
28181 return resultobj;
28182 fail:
28183 return NULL;
28184 }
28185
28186
28187 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28188 PyObject *resultobj;
28189 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28190 wxMetafile result;
28191 PyObject * obj0 = 0 ;
28192 char *kwnames[] = {
28193 (char *) "self", NULL
28194 };
28195
28196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28198 if (SWIG_arg_fail(1)) SWIG_fail;
28199 {
28200 PyThreadState* __tstate = wxPyBeginAllowThreads();
28201 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28202
28203 wxPyEndAllowThreads(__tstate);
28204 if (PyErr_Occurred()) SWIG_fail;
28205 }
28206 {
28207 wxMetafile * resultptr;
28208 resultptr = new wxMetafile((wxMetafile &)(result));
28209 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28210 }
28211 return resultobj;
28212 fail:
28213 return NULL;
28214 }
28215
28216
28217 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28218 PyObject *obj;
28219 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28220 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28221 Py_INCREF(obj);
28222 return Py_BuildValue((char *)"");
28223 }
28224 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28225 PyObject *resultobj;
28226 wxDragResult arg1 ;
28227 bool result;
28228 PyObject * obj0 = 0 ;
28229 char *kwnames[] = {
28230 (char *) "res", NULL
28231 };
28232
28233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28234 {
28235 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28236 if (SWIG_arg_fail(1)) SWIG_fail;
28237 }
28238 {
28239 PyThreadState* __tstate = wxPyBeginAllowThreads();
28240 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28241
28242 wxPyEndAllowThreads(__tstate);
28243 if (PyErr_Occurred()) SWIG_fail;
28244 }
28245 {
28246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28247 }
28248 return resultobj;
28249 fail:
28250 return NULL;
28251 }
28252
28253
28254 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28255 PyObject *resultobj;
28256 wxWindow *arg1 = (wxWindow *) 0 ;
28257 wxCursor const &arg2_defvalue = wxNullCursor ;
28258 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28259 wxCursor const &arg3_defvalue = wxNullCursor ;
28260 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28261 wxCursor const &arg4_defvalue = wxNullCursor ;
28262 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28263 wxPyDropSource *result;
28264 PyObject * obj0 = 0 ;
28265 PyObject * obj1 = 0 ;
28266 PyObject * obj2 = 0 ;
28267 PyObject * obj3 = 0 ;
28268 char *kwnames[] = {
28269 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28270 };
28271
28272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28274 if (SWIG_arg_fail(1)) SWIG_fail;
28275 if (obj1) {
28276 {
28277 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28278 if (SWIG_arg_fail(2)) SWIG_fail;
28279 if (arg2 == NULL) {
28280 SWIG_null_ref("wxCursor");
28281 }
28282 if (SWIG_arg_fail(2)) SWIG_fail;
28283 }
28284 }
28285 if (obj2) {
28286 {
28287 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28288 if (SWIG_arg_fail(3)) SWIG_fail;
28289 if (arg3 == NULL) {
28290 SWIG_null_ref("wxCursor");
28291 }
28292 if (SWIG_arg_fail(3)) SWIG_fail;
28293 }
28294 }
28295 if (obj3) {
28296 {
28297 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28298 if (SWIG_arg_fail(4)) SWIG_fail;
28299 if (arg4 == NULL) {
28300 SWIG_null_ref("wxCursor");
28301 }
28302 if (SWIG_arg_fail(4)) SWIG_fail;
28303 }
28304 }
28305 {
28306 PyThreadState* __tstate = wxPyBeginAllowThreads();
28307 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28308
28309 wxPyEndAllowThreads(__tstate);
28310 if (PyErr_Occurred()) SWIG_fail;
28311 }
28312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28313 return resultobj;
28314 fail:
28315 return NULL;
28316 }
28317
28318
28319 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28320 PyObject *resultobj;
28321 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28322 PyObject *arg2 = (PyObject *) 0 ;
28323 PyObject *arg3 = (PyObject *) 0 ;
28324 int arg4 ;
28325 PyObject * obj0 = 0 ;
28326 PyObject * obj1 = 0 ;
28327 PyObject * obj2 = 0 ;
28328 PyObject * obj3 = 0 ;
28329 char *kwnames[] = {
28330 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28331 };
28332
28333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28335 if (SWIG_arg_fail(1)) SWIG_fail;
28336 arg2 = obj1;
28337 arg3 = obj2;
28338 {
28339 arg4 = (int)(SWIG_As_int(obj3));
28340 if (SWIG_arg_fail(4)) SWIG_fail;
28341 }
28342 {
28343 PyThreadState* __tstate = wxPyBeginAllowThreads();
28344 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28345
28346 wxPyEndAllowThreads(__tstate);
28347 if (PyErr_Occurred()) SWIG_fail;
28348 }
28349 Py_INCREF(Py_None); resultobj = Py_None;
28350 return resultobj;
28351 fail:
28352 return NULL;
28353 }
28354
28355
28356 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28357 PyObject *resultobj;
28358 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28359 PyObject * obj0 = 0 ;
28360 char *kwnames[] = {
28361 (char *) "self", NULL
28362 };
28363
28364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28366 if (SWIG_arg_fail(1)) SWIG_fail;
28367 {
28368 PyThreadState* __tstate = wxPyBeginAllowThreads();
28369 delete arg1;
28370
28371 wxPyEndAllowThreads(__tstate);
28372 if (PyErr_Occurred()) SWIG_fail;
28373 }
28374 Py_INCREF(Py_None); resultobj = Py_None;
28375 return resultobj;
28376 fail:
28377 return NULL;
28378 }
28379
28380
28381 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28382 PyObject *resultobj;
28383 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28384 wxDataObject *arg2 = 0 ;
28385 PyObject * obj0 = 0 ;
28386 PyObject * obj1 = 0 ;
28387 char *kwnames[] = {
28388 (char *) "self",(char *) "data", NULL
28389 };
28390
28391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28393 if (SWIG_arg_fail(1)) SWIG_fail;
28394 {
28395 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28396 if (SWIG_arg_fail(2)) SWIG_fail;
28397 if (arg2 == NULL) {
28398 SWIG_null_ref("wxDataObject");
28399 }
28400 if (SWIG_arg_fail(2)) SWIG_fail;
28401 }
28402 {
28403 PyThreadState* __tstate = wxPyBeginAllowThreads();
28404 (arg1)->SetData(*arg2);
28405
28406 wxPyEndAllowThreads(__tstate);
28407 if (PyErr_Occurred()) SWIG_fail;
28408 }
28409 Py_INCREF(Py_None); resultobj = Py_None;
28410 return resultobj;
28411 fail:
28412 return NULL;
28413 }
28414
28415
28416 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28417 PyObject *resultobj;
28418 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28419 wxDataObject *result;
28420 PyObject * obj0 = 0 ;
28421 char *kwnames[] = {
28422 (char *) "self", NULL
28423 };
28424
28425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28427 if (SWIG_arg_fail(1)) SWIG_fail;
28428 {
28429 PyThreadState* __tstate = wxPyBeginAllowThreads();
28430 result = (wxDataObject *)(arg1)->GetDataObject();
28431
28432 wxPyEndAllowThreads(__tstate);
28433 if (PyErr_Occurred()) SWIG_fail;
28434 }
28435 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28436 return resultobj;
28437 fail:
28438 return NULL;
28439 }
28440
28441
28442 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28443 PyObject *resultobj;
28444 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28445 wxDragResult arg2 ;
28446 wxCursor *arg3 = 0 ;
28447 PyObject * obj0 = 0 ;
28448 PyObject * obj1 = 0 ;
28449 PyObject * obj2 = 0 ;
28450 char *kwnames[] = {
28451 (char *) "self",(char *) "res",(char *) "cursor", NULL
28452 };
28453
28454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28456 if (SWIG_arg_fail(1)) SWIG_fail;
28457 {
28458 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28459 if (SWIG_arg_fail(2)) SWIG_fail;
28460 }
28461 {
28462 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28463 if (SWIG_arg_fail(3)) SWIG_fail;
28464 if (arg3 == NULL) {
28465 SWIG_null_ref("wxCursor");
28466 }
28467 if (SWIG_arg_fail(3)) SWIG_fail;
28468 }
28469 {
28470 PyThreadState* __tstate = wxPyBeginAllowThreads();
28471 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28472
28473 wxPyEndAllowThreads(__tstate);
28474 if (PyErr_Occurred()) SWIG_fail;
28475 }
28476 Py_INCREF(Py_None); resultobj = Py_None;
28477 return resultobj;
28478 fail:
28479 return NULL;
28480 }
28481
28482
28483 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28484 PyObject *resultobj;
28485 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28486 int arg2 = (int) wxDrag_CopyOnly ;
28487 wxDragResult result;
28488 PyObject * obj0 = 0 ;
28489 PyObject * obj1 = 0 ;
28490 char *kwnames[] = {
28491 (char *) "self",(char *) "flags", NULL
28492 };
28493
28494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28496 if (SWIG_arg_fail(1)) SWIG_fail;
28497 if (obj1) {
28498 {
28499 arg2 = (int)(SWIG_As_int(obj1));
28500 if (SWIG_arg_fail(2)) SWIG_fail;
28501 }
28502 }
28503 {
28504 PyThreadState* __tstate = wxPyBeginAllowThreads();
28505 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28506
28507 wxPyEndAllowThreads(__tstate);
28508 if (PyErr_Occurred()) SWIG_fail;
28509 }
28510 resultobj = SWIG_From_int((result));
28511 return resultobj;
28512 fail:
28513 return NULL;
28514 }
28515
28516
28517 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28518 PyObject *resultobj;
28519 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28520 wxDragResult arg2 ;
28521 bool result;
28522 PyObject * obj0 = 0 ;
28523 PyObject * obj1 = 0 ;
28524 char *kwnames[] = {
28525 (char *) "self",(char *) "effect", NULL
28526 };
28527
28528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28530 if (SWIG_arg_fail(1)) SWIG_fail;
28531 {
28532 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28533 if (SWIG_arg_fail(2)) SWIG_fail;
28534 }
28535 {
28536 PyThreadState* __tstate = wxPyBeginAllowThreads();
28537 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28538
28539 wxPyEndAllowThreads(__tstate);
28540 if (PyErr_Occurred()) SWIG_fail;
28541 }
28542 {
28543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28544 }
28545 return resultobj;
28546 fail:
28547 return NULL;
28548 }
28549
28550
28551 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28552 PyObject *obj;
28553 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28554 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28555 Py_INCREF(obj);
28556 return Py_BuildValue((char *)"");
28557 }
28558 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28559 PyObject *resultobj;
28560 wxDataObject *arg1 = (wxDataObject *) NULL ;
28561 wxPyDropTarget *result;
28562 PyObject * obj0 = 0 ;
28563 char *kwnames[] = {
28564 (char *) "dataObject", NULL
28565 };
28566
28567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28568 if (obj0) {
28569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28570 if (SWIG_arg_fail(1)) SWIG_fail;
28571 }
28572 {
28573 PyThreadState* __tstate = wxPyBeginAllowThreads();
28574 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28575
28576 wxPyEndAllowThreads(__tstate);
28577 if (PyErr_Occurred()) SWIG_fail;
28578 }
28579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28580 return resultobj;
28581 fail:
28582 return NULL;
28583 }
28584
28585
28586 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28587 PyObject *resultobj;
28588 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28589 PyObject *arg2 = (PyObject *) 0 ;
28590 PyObject *arg3 = (PyObject *) 0 ;
28591 PyObject * obj0 = 0 ;
28592 PyObject * obj1 = 0 ;
28593 PyObject * obj2 = 0 ;
28594 char *kwnames[] = {
28595 (char *) "self",(char *) "self",(char *) "_class", NULL
28596 };
28597
28598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28600 if (SWIG_arg_fail(1)) SWIG_fail;
28601 arg2 = obj1;
28602 arg3 = obj2;
28603 {
28604 PyThreadState* __tstate = wxPyBeginAllowThreads();
28605 (arg1)->_setCallbackInfo(arg2,arg3);
28606
28607 wxPyEndAllowThreads(__tstate);
28608 if (PyErr_Occurred()) SWIG_fail;
28609 }
28610 Py_INCREF(Py_None); resultobj = Py_None;
28611 return resultobj;
28612 fail:
28613 return NULL;
28614 }
28615
28616
28617 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28618 PyObject *resultobj;
28619 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28620 PyObject * obj0 = 0 ;
28621 char *kwnames[] = {
28622 (char *) "self", NULL
28623 };
28624
28625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28627 if (SWIG_arg_fail(1)) SWIG_fail;
28628 {
28629 PyThreadState* __tstate = wxPyBeginAllowThreads();
28630 delete arg1;
28631
28632 wxPyEndAllowThreads(__tstate);
28633 if (PyErr_Occurred()) SWIG_fail;
28634 }
28635 Py_INCREF(Py_None); resultobj = Py_None;
28636 return resultobj;
28637 fail:
28638 return NULL;
28639 }
28640
28641
28642 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28643 PyObject *resultobj;
28644 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28645 wxDataObject *result;
28646 PyObject * obj0 = 0 ;
28647 char *kwnames[] = {
28648 (char *) "self", NULL
28649 };
28650
28651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28653 if (SWIG_arg_fail(1)) SWIG_fail;
28654 {
28655 PyThreadState* __tstate = wxPyBeginAllowThreads();
28656 result = (wxDataObject *)(arg1)->GetDataObject();
28657
28658 wxPyEndAllowThreads(__tstate);
28659 if (PyErr_Occurred()) SWIG_fail;
28660 }
28661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28662 return resultobj;
28663 fail:
28664 return NULL;
28665 }
28666
28667
28668 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28669 PyObject *resultobj;
28670 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28671 wxDataObject *arg2 = (wxDataObject *) 0 ;
28672 PyObject * obj0 = 0 ;
28673 PyObject * obj1 = 0 ;
28674 char *kwnames[] = {
28675 (char *) "self",(char *) "dataObject", NULL
28676 };
28677
28678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28680 if (SWIG_arg_fail(1)) SWIG_fail;
28681 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28682 if (SWIG_arg_fail(2)) SWIG_fail;
28683 {
28684 PyThreadState* __tstate = wxPyBeginAllowThreads();
28685 (arg1)->SetDataObject(arg2);
28686
28687 wxPyEndAllowThreads(__tstate);
28688 if (PyErr_Occurred()) SWIG_fail;
28689 }
28690 Py_INCREF(Py_None); resultobj = Py_None;
28691 return resultobj;
28692 fail:
28693 return NULL;
28694 }
28695
28696
28697 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28698 PyObject *resultobj;
28699 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28700 int arg2 ;
28701 int arg3 ;
28702 wxDragResult arg4 ;
28703 wxDragResult result;
28704 PyObject * obj0 = 0 ;
28705 PyObject * obj1 = 0 ;
28706 PyObject * obj2 = 0 ;
28707 PyObject * obj3 = 0 ;
28708 char *kwnames[] = {
28709 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28710 };
28711
28712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28714 if (SWIG_arg_fail(1)) SWIG_fail;
28715 {
28716 arg2 = (int)(SWIG_As_int(obj1));
28717 if (SWIG_arg_fail(2)) SWIG_fail;
28718 }
28719 {
28720 arg3 = (int)(SWIG_As_int(obj2));
28721 if (SWIG_arg_fail(3)) SWIG_fail;
28722 }
28723 {
28724 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28725 if (SWIG_arg_fail(4)) SWIG_fail;
28726 }
28727 {
28728 PyThreadState* __tstate = wxPyBeginAllowThreads();
28729 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28730
28731 wxPyEndAllowThreads(__tstate);
28732 if (PyErr_Occurred()) SWIG_fail;
28733 }
28734 resultobj = SWIG_From_int((result));
28735 return resultobj;
28736 fail:
28737 return NULL;
28738 }
28739
28740
28741 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28742 PyObject *resultobj;
28743 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28744 int arg2 ;
28745 int arg3 ;
28746 wxDragResult arg4 ;
28747 wxDragResult result;
28748 PyObject * obj0 = 0 ;
28749 PyObject * obj1 = 0 ;
28750 PyObject * obj2 = 0 ;
28751 PyObject * obj3 = 0 ;
28752 char *kwnames[] = {
28753 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28754 };
28755
28756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28758 if (SWIG_arg_fail(1)) SWIG_fail;
28759 {
28760 arg2 = (int)(SWIG_As_int(obj1));
28761 if (SWIG_arg_fail(2)) SWIG_fail;
28762 }
28763 {
28764 arg3 = (int)(SWIG_As_int(obj2));
28765 if (SWIG_arg_fail(3)) SWIG_fail;
28766 }
28767 {
28768 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28769 if (SWIG_arg_fail(4)) SWIG_fail;
28770 }
28771 {
28772 PyThreadState* __tstate = wxPyBeginAllowThreads();
28773 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28774
28775 wxPyEndAllowThreads(__tstate);
28776 if (PyErr_Occurred()) SWIG_fail;
28777 }
28778 resultobj = SWIG_From_int((result));
28779 return resultobj;
28780 fail:
28781 return NULL;
28782 }
28783
28784
28785 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28786 PyObject *resultobj;
28787 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28788 PyObject * obj0 = 0 ;
28789 char *kwnames[] = {
28790 (char *) "self", NULL
28791 };
28792
28793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28795 if (SWIG_arg_fail(1)) SWIG_fail;
28796 {
28797 PyThreadState* __tstate = wxPyBeginAllowThreads();
28798 (arg1)->base_OnLeave();
28799
28800 wxPyEndAllowThreads(__tstate);
28801 if (PyErr_Occurred()) SWIG_fail;
28802 }
28803 Py_INCREF(Py_None); resultobj = Py_None;
28804 return resultobj;
28805 fail:
28806 return NULL;
28807 }
28808
28809
28810 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28811 PyObject *resultobj;
28812 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28813 int arg2 ;
28814 int arg3 ;
28815 bool result;
28816 PyObject * obj0 = 0 ;
28817 PyObject * obj1 = 0 ;
28818 PyObject * obj2 = 0 ;
28819 char *kwnames[] = {
28820 (char *) "self",(char *) "x",(char *) "y", NULL
28821 };
28822
28823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28825 if (SWIG_arg_fail(1)) SWIG_fail;
28826 {
28827 arg2 = (int)(SWIG_As_int(obj1));
28828 if (SWIG_arg_fail(2)) SWIG_fail;
28829 }
28830 {
28831 arg3 = (int)(SWIG_As_int(obj2));
28832 if (SWIG_arg_fail(3)) SWIG_fail;
28833 }
28834 {
28835 PyThreadState* __tstate = wxPyBeginAllowThreads();
28836 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28837
28838 wxPyEndAllowThreads(__tstate);
28839 if (PyErr_Occurred()) SWIG_fail;
28840 }
28841 {
28842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28843 }
28844 return resultobj;
28845 fail:
28846 return NULL;
28847 }
28848
28849
28850 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28851 PyObject *resultobj;
28852 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28853 bool result;
28854 PyObject * obj0 = 0 ;
28855 char *kwnames[] = {
28856 (char *) "self", NULL
28857 };
28858
28859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
28860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28861 if (SWIG_arg_fail(1)) SWIG_fail;
28862 {
28863 PyThreadState* __tstate = wxPyBeginAllowThreads();
28864 result = (bool)(arg1)->GetData();
28865
28866 wxPyEndAllowThreads(__tstate);
28867 if (PyErr_Occurred()) SWIG_fail;
28868 }
28869 {
28870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28871 }
28872 return resultobj;
28873 fail:
28874 return NULL;
28875 }
28876
28877
28878 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
28879 PyObject *obj;
28880 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28881 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
28882 Py_INCREF(obj);
28883 return Py_BuildValue((char *)"");
28884 }
28885 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28886 PyObject *resultobj;
28887 wxPyTextDropTarget *result;
28888 char *kwnames[] = {
28889 NULL
28890 };
28891
28892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
28893 {
28894 PyThreadState* __tstate = wxPyBeginAllowThreads();
28895 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
28896
28897 wxPyEndAllowThreads(__tstate);
28898 if (PyErr_Occurred()) SWIG_fail;
28899 }
28900 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
28901 return resultobj;
28902 fail:
28903 return NULL;
28904 }
28905
28906
28907 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28908 PyObject *resultobj;
28909 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28910 PyObject *arg2 = (PyObject *) 0 ;
28911 PyObject *arg3 = (PyObject *) 0 ;
28912 PyObject * obj0 = 0 ;
28913 PyObject * obj1 = 0 ;
28914 PyObject * obj2 = 0 ;
28915 char *kwnames[] = {
28916 (char *) "self",(char *) "self",(char *) "_class", NULL
28917 };
28918
28919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28921 if (SWIG_arg_fail(1)) SWIG_fail;
28922 arg2 = obj1;
28923 arg3 = obj2;
28924 {
28925 PyThreadState* __tstate = wxPyBeginAllowThreads();
28926 (arg1)->_setCallbackInfo(arg2,arg3);
28927
28928 wxPyEndAllowThreads(__tstate);
28929 if (PyErr_Occurred()) SWIG_fail;
28930 }
28931 Py_INCREF(Py_None); resultobj = Py_None;
28932 return resultobj;
28933 fail:
28934 return NULL;
28935 }
28936
28937
28938 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28939 PyObject *resultobj;
28940 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28941 int arg2 ;
28942 int arg3 ;
28943 wxDragResult arg4 ;
28944 wxDragResult result;
28945 PyObject * obj0 = 0 ;
28946 PyObject * obj1 = 0 ;
28947 PyObject * obj2 = 0 ;
28948 PyObject * obj3 = 0 ;
28949 char *kwnames[] = {
28950 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28951 };
28952
28953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28955 if (SWIG_arg_fail(1)) SWIG_fail;
28956 {
28957 arg2 = (int)(SWIG_As_int(obj1));
28958 if (SWIG_arg_fail(2)) SWIG_fail;
28959 }
28960 {
28961 arg3 = (int)(SWIG_As_int(obj2));
28962 if (SWIG_arg_fail(3)) SWIG_fail;
28963 }
28964 {
28965 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28966 if (SWIG_arg_fail(4)) SWIG_fail;
28967 }
28968 {
28969 PyThreadState* __tstate = wxPyBeginAllowThreads();
28970 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28971
28972 wxPyEndAllowThreads(__tstate);
28973 if (PyErr_Occurred()) SWIG_fail;
28974 }
28975 resultobj = SWIG_From_int((result));
28976 return resultobj;
28977 fail:
28978 return NULL;
28979 }
28980
28981
28982 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28983 PyObject *resultobj;
28984 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28985 int arg2 ;
28986 int arg3 ;
28987 wxDragResult arg4 ;
28988 wxDragResult result;
28989 PyObject * obj0 = 0 ;
28990 PyObject * obj1 = 0 ;
28991 PyObject * obj2 = 0 ;
28992 PyObject * obj3 = 0 ;
28993 char *kwnames[] = {
28994 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28995 };
28996
28997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28999 if (SWIG_arg_fail(1)) SWIG_fail;
29000 {
29001 arg2 = (int)(SWIG_As_int(obj1));
29002 if (SWIG_arg_fail(2)) SWIG_fail;
29003 }
29004 {
29005 arg3 = (int)(SWIG_As_int(obj2));
29006 if (SWIG_arg_fail(3)) SWIG_fail;
29007 }
29008 {
29009 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29010 if (SWIG_arg_fail(4)) SWIG_fail;
29011 }
29012 {
29013 PyThreadState* __tstate = wxPyBeginAllowThreads();
29014 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29015
29016 wxPyEndAllowThreads(__tstate);
29017 if (PyErr_Occurred()) SWIG_fail;
29018 }
29019 resultobj = SWIG_From_int((result));
29020 return resultobj;
29021 fail:
29022 return NULL;
29023 }
29024
29025
29026 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29027 PyObject *resultobj;
29028 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29029 PyObject * obj0 = 0 ;
29030 char *kwnames[] = {
29031 (char *) "self", NULL
29032 };
29033
29034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29036 if (SWIG_arg_fail(1)) SWIG_fail;
29037 {
29038 PyThreadState* __tstate = wxPyBeginAllowThreads();
29039 (arg1)->base_OnLeave();
29040
29041 wxPyEndAllowThreads(__tstate);
29042 if (PyErr_Occurred()) SWIG_fail;
29043 }
29044 Py_INCREF(Py_None); resultobj = Py_None;
29045 return resultobj;
29046 fail:
29047 return NULL;
29048 }
29049
29050
29051 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29052 PyObject *resultobj;
29053 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29054 int arg2 ;
29055 int arg3 ;
29056 bool result;
29057 PyObject * obj0 = 0 ;
29058 PyObject * obj1 = 0 ;
29059 PyObject * obj2 = 0 ;
29060 char *kwnames[] = {
29061 (char *) "self",(char *) "x",(char *) "y", NULL
29062 };
29063
29064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29066 if (SWIG_arg_fail(1)) SWIG_fail;
29067 {
29068 arg2 = (int)(SWIG_As_int(obj1));
29069 if (SWIG_arg_fail(2)) SWIG_fail;
29070 }
29071 {
29072 arg3 = (int)(SWIG_As_int(obj2));
29073 if (SWIG_arg_fail(3)) SWIG_fail;
29074 }
29075 {
29076 PyThreadState* __tstate = wxPyBeginAllowThreads();
29077 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29078
29079 wxPyEndAllowThreads(__tstate);
29080 if (PyErr_Occurred()) SWIG_fail;
29081 }
29082 {
29083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29084 }
29085 return resultobj;
29086 fail:
29087 return NULL;
29088 }
29089
29090
29091 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29092 PyObject *resultobj;
29093 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29094 int arg2 ;
29095 int arg3 ;
29096 wxDragResult arg4 ;
29097 wxDragResult result;
29098 PyObject * obj0 = 0 ;
29099 PyObject * obj1 = 0 ;
29100 PyObject * obj2 = 0 ;
29101 PyObject * obj3 = 0 ;
29102 char *kwnames[] = {
29103 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29104 };
29105
29106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29108 if (SWIG_arg_fail(1)) SWIG_fail;
29109 {
29110 arg2 = (int)(SWIG_As_int(obj1));
29111 if (SWIG_arg_fail(2)) SWIG_fail;
29112 }
29113 {
29114 arg3 = (int)(SWIG_As_int(obj2));
29115 if (SWIG_arg_fail(3)) SWIG_fail;
29116 }
29117 {
29118 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29119 if (SWIG_arg_fail(4)) SWIG_fail;
29120 }
29121 {
29122 PyThreadState* __tstate = wxPyBeginAllowThreads();
29123 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29124
29125 wxPyEndAllowThreads(__tstate);
29126 if (PyErr_Occurred()) SWIG_fail;
29127 }
29128 resultobj = SWIG_From_int((result));
29129 return resultobj;
29130 fail:
29131 return NULL;
29132 }
29133
29134
29135 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29136 PyObject *obj;
29137 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29138 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29139 Py_INCREF(obj);
29140 return Py_BuildValue((char *)"");
29141 }
29142 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29143 PyObject *resultobj;
29144 wxPyFileDropTarget *result;
29145 char *kwnames[] = {
29146 NULL
29147 };
29148
29149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29150 {
29151 PyThreadState* __tstate = wxPyBeginAllowThreads();
29152 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29153
29154 wxPyEndAllowThreads(__tstate);
29155 if (PyErr_Occurred()) SWIG_fail;
29156 }
29157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29158 return resultobj;
29159 fail:
29160 return NULL;
29161 }
29162
29163
29164 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29165 PyObject *resultobj;
29166 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29167 PyObject *arg2 = (PyObject *) 0 ;
29168 PyObject *arg3 = (PyObject *) 0 ;
29169 PyObject * obj0 = 0 ;
29170 PyObject * obj1 = 0 ;
29171 PyObject * obj2 = 0 ;
29172 char *kwnames[] = {
29173 (char *) "self",(char *) "self",(char *) "_class", NULL
29174 };
29175
29176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29178 if (SWIG_arg_fail(1)) SWIG_fail;
29179 arg2 = obj1;
29180 arg3 = obj2;
29181 {
29182 PyThreadState* __tstate = wxPyBeginAllowThreads();
29183 (arg1)->_setCallbackInfo(arg2,arg3);
29184
29185 wxPyEndAllowThreads(__tstate);
29186 if (PyErr_Occurred()) SWIG_fail;
29187 }
29188 Py_INCREF(Py_None); resultobj = Py_None;
29189 return resultobj;
29190 fail:
29191 return NULL;
29192 }
29193
29194
29195 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29196 PyObject *resultobj;
29197 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29198 int arg2 ;
29199 int arg3 ;
29200 wxDragResult arg4 ;
29201 wxDragResult result;
29202 PyObject * obj0 = 0 ;
29203 PyObject * obj1 = 0 ;
29204 PyObject * obj2 = 0 ;
29205 PyObject * obj3 = 0 ;
29206 char *kwnames[] = {
29207 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29208 };
29209
29210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29212 if (SWIG_arg_fail(1)) SWIG_fail;
29213 {
29214 arg2 = (int)(SWIG_As_int(obj1));
29215 if (SWIG_arg_fail(2)) SWIG_fail;
29216 }
29217 {
29218 arg3 = (int)(SWIG_As_int(obj2));
29219 if (SWIG_arg_fail(3)) SWIG_fail;
29220 }
29221 {
29222 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29223 if (SWIG_arg_fail(4)) SWIG_fail;
29224 }
29225 {
29226 PyThreadState* __tstate = wxPyBeginAllowThreads();
29227 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29228
29229 wxPyEndAllowThreads(__tstate);
29230 if (PyErr_Occurred()) SWIG_fail;
29231 }
29232 resultobj = SWIG_From_int((result));
29233 return resultobj;
29234 fail:
29235 return NULL;
29236 }
29237
29238
29239 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29240 PyObject *resultobj;
29241 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29242 int arg2 ;
29243 int arg3 ;
29244 wxDragResult arg4 ;
29245 wxDragResult result;
29246 PyObject * obj0 = 0 ;
29247 PyObject * obj1 = 0 ;
29248 PyObject * obj2 = 0 ;
29249 PyObject * obj3 = 0 ;
29250 char *kwnames[] = {
29251 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29252 };
29253
29254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29256 if (SWIG_arg_fail(1)) SWIG_fail;
29257 {
29258 arg2 = (int)(SWIG_As_int(obj1));
29259 if (SWIG_arg_fail(2)) SWIG_fail;
29260 }
29261 {
29262 arg3 = (int)(SWIG_As_int(obj2));
29263 if (SWIG_arg_fail(3)) SWIG_fail;
29264 }
29265 {
29266 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29267 if (SWIG_arg_fail(4)) SWIG_fail;
29268 }
29269 {
29270 PyThreadState* __tstate = wxPyBeginAllowThreads();
29271 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29272
29273 wxPyEndAllowThreads(__tstate);
29274 if (PyErr_Occurred()) SWIG_fail;
29275 }
29276 resultobj = SWIG_From_int((result));
29277 return resultobj;
29278 fail:
29279 return NULL;
29280 }
29281
29282
29283 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29284 PyObject *resultobj;
29285 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29286 PyObject * obj0 = 0 ;
29287 char *kwnames[] = {
29288 (char *) "self", NULL
29289 };
29290
29291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29293 if (SWIG_arg_fail(1)) SWIG_fail;
29294 {
29295 PyThreadState* __tstate = wxPyBeginAllowThreads();
29296 (arg1)->base_OnLeave();
29297
29298 wxPyEndAllowThreads(__tstate);
29299 if (PyErr_Occurred()) SWIG_fail;
29300 }
29301 Py_INCREF(Py_None); resultobj = Py_None;
29302 return resultobj;
29303 fail:
29304 return NULL;
29305 }
29306
29307
29308 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29309 PyObject *resultobj;
29310 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29311 int arg2 ;
29312 int arg3 ;
29313 bool result;
29314 PyObject * obj0 = 0 ;
29315 PyObject * obj1 = 0 ;
29316 PyObject * obj2 = 0 ;
29317 char *kwnames[] = {
29318 (char *) "self",(char *) "x",(char *) "y", NULL
29319 };
29320
29321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29323 if (SWIG_arg_fail(1)) SWIG_fail;
29324 {
29325 arg2 = (int)(SWIG_As_int(obj1));
29326 if (SWIG_arg_fail(2)) SWIG_fail;
29327 }
29328 {
29329 arg3 = (int)(SWIG_As_int(obj2));
29330 if (SWIG_arg_fail(3)) SWIG_fail;
29331 }
29332 {
29333 PyThreadState* __tstate = wxPyBeginAllowThreads();
29334 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29335
29336 wxPyEndAllowThreads(__tstate);
29337 if (PyErr_Occurred()) SWIG_fail;
29338 }
29339 {
29340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29341 }
29342 return resultobj;
29343 fail:
29344 return NULL;
29345 }
29346
29347
29348 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29349 PyObject *resultobj;
29350 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29351 int arg2 ;
29352 int arg3 ;
29353 wxDragResult arg4 ;
29354 wxDragResult result;
29355 PyObject * obj0 = 0 ;
29356 PyObject * obj1 = 0 ;
29357 PyObject * obj2 = 0 ;
29358 PyObject * obj3 = 0 ;
29359 char *kwnames[] = {
29360 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29361 };
29362
29363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29365 if (SWIG_arg_fail(1)) SWIG_fail;
29366 {
29367 arg2 = (int)(SWIG_As_int(obj1));
29368 if (SWIG_arg_fail(2)) SWIG_fail;
29369 }
29370 {
29371 arg3 = (int)(SWIG_As_int(obj2));
29372 if (SWIG_arg_fail(3)) SWIG_fail;
29373 }
29374 {
29375 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29376 if (SWIG_arg_fail(4)) SWIG_fail;
29377 }
29378 {
29379 PyThreadState* __tstate = wxPyBeginAllowThreads();
29380 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29381
29382 wxPyEndAllowThreads(__tstate);
29383 if (PyErr_Occurred()) SWIG_fail;
29384 }
29385 resultobj = SWIG_From_int((result));
29386 return resultobj;
29387 fail:
29388 return NULL;
29389 }
29390
29391
29392 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29393 PyObject *obj;
29394 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29395 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29396 Py_INCREF(obj);
29397 return Py_BuildValue((char *)"");
29398 }
29399 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29400 PyObject *resultobj;
29401 wxClipboard *result;
29402 char *kwnames[] = {
29403 NULL
29404 };
29405
29406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29407 {
29408 PyThreadState* __tstate = wxPyBeginAllowThreads();
29409 result = (wxClipboard *)new wxClipboard();
29410
29411 wxPyEndAllowThreads(__tstate);
29412 if (PyErr_Occurred()) SWIG_fail;
29413 }
29414 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29415 return resultobj;
29416 fail:
29417 return NULL;
29418 }
29419
29420
29421 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29422 PyObject *resultobj;
29423 wxClipboard *arg1 = (wxClipboard *) 0 ;
29424 PyObject * obj0 = 0 ;
29425 char *kwnames[] = {
29426 (char *) "self", NULL
29427 };
29428
29429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29431 if (SWIG_arg_fail(1)) SWIG_fail;
29432 {
29433 PyThreadState* __tstate = wxPyBeginAllowThreads();
29434 delete arg1;
29435
29436 wxPyEndAllowThreads(__tstate);
29437 if (PyErr_Occurred()) SWIG_fail;
29438 }
29439 Py_INCREF(Py_None); resultobj = Py_None;
29440 return resultobj;
29441 fail:
29442 return NULL;
29443 }
29444
29445
29446 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29447 PyObject *resultobj;
29448 wxClipboard *arg1 = (wxClipboard *) 0 ;
29449 bool result;
29450 PyObject * obj0 = 0 ;
29451 char *kwnames[] = {
29452 (char *) "self", NULL
29453 };
29454
29455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29457 if (SWIG_arg_fail(1)) SWIG_fail;
29458 {
29459 PyThreadState* __tstate = wxPyBeginAllowThreads();
29460 result = (bool)(arg1)->Open();
29461
29462 wxPyEndAllowThreads(__tstate);
29463 if (PyErr_Occurred()) SWIG_fail;
29464 }
29465 {
29466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29467 }
29468 return resultobj;
29469 fail:
29470 return NULL;
29471 }
29472
29473
29474 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29475 PyObject *resultobj;
29476 wxClipboard *arg1 = (wxClipboard *) 0 ;
29477 PyObject * obj0 = 0 ;
29478 char *kwnames[] = {
29479 (char *) "self", NULL
29480 };
29481
29482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29484 if (SWIG_arg_fail(1)) SWIG_fail;
29485 {
29486 PyThreadState* __tstate = wxPyBeginAllowThreads();
29487 (arg1)->Close();
29488
29489 wxPyEndAllowThreads(__tstate);
29490 if (PyErr_Occurred()) SWIG_fail;
29491 }
29492 Py_INCREF(Py_None); resultobj = Py_None;
29493 return resultobj;
29494 fail:
29495 return NULL;
29496 }
29497
29498
29499 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29500 PyObject *resultobj;
29501 wxClipboard *arg1 = (wxClipboard *) 0 ;
29502 bool result;
29503 PyObject * obj0 = 0 ;
29504 char *kwnames[] = {
29505 (char *) "self", NULL
29506 };
29507
29508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29510 if (SWIG_arg_fail(1)) SWIG_fail;
29511 {
29512 PyThreadState* __tstate = wxPyBeginAllowThreads();
29513 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29514
29515 wxPyEndAllowThreads(__tstate);
29516 if (PyErr_Occurred()) SWIG_fail;
29517 }
29518 {
29519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29520 }
29521 return resultobj;
29522 fail:
29523 return NULL;
29524 }
29525
29526
29527 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29528 PyObject *resultobj;
29529 wxClipboard *arg1 = (wxClipboard *) 0 ;
29530 wxDataObject *arg2 = (wxDataObject *) 0 ;
29531 bool result;
29532 PyObject * obj0 = 0 ;
29533 PyObject * obj1 = 0 ;
29534 char *kwnames[] = {
29535 (char *) "self",(char *) "data", NULL
29536 };
29537
29538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29540 if (SWIG_arg_fail(1)) SWIG_fail;
29541 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29542 if (SWIG_arg_fail(2)) SWIG_fail;
29543 {
29544 PyThreadState* __tstate = wxPyBeginAllowThreads();
29545 result = (bool)(arg1)->AddData(arg2);
29546
29547 wxPyEndAllowThreads(__tstate);
29548 if (PyErr_Occurred()) SWIG_fail;
29549 }
29550 {
29551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29552 }
29553 return resultobj;
29554 fail:
29555 return NULL;
29556 }
29557
29558
29559 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29560 PyObject *resultobj;
29561 wxClipboard *arg1 = (wxClipboard *) 0 ;
29562 wxDataObject *arg2 = (wxDataObject *) 0 ;
29563 bool result;
29564 PyObject * obj0 = 0 ;
29565 PyObject * obj1 = 0 ;
29566 char *kwnames[] = {
29567 (char *) "self",(char *) "data", NULL
29568 };
29569
29570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29572 if (SWIG_arg_fail(1)) SWIG_fail;
29573 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29574 if (SWIG_arg_fail(2)) SWIG_fail;
29575 {
29576 PyThreadState* __tstate = wxPyBeginAllowThreads();
29577 result = (bool)(arg1)->SetData(arg2);
29578
29579 wxPyEndAllowThreads(__tstate);
29580 if (PyErr_Occurred()) SWIG_fail;
29581 }
29582 {
29583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29584 }
29585 return resultobj;
29586 fail:
29587 return NULL;
29588 }
29589
29590
29591 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29592 PyObject *resultobj;
29593 wxClipboard *arg1 = (wxClipboard *) 0 ;
29594 wxDataFormat *arg2 = 0 ;
29595 bool result;
29596 PyObject * obj0 = 0 ;
29597 PyObject * obj1 = 0 ;
29598 char *kwnames[] = {
29599 (char *) "self",(char *) "format", NULL
29600 };
29601
29602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29604 if (SWIG_arg_fail(1)) SWIG_fail;
29605 {
29606 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29607 if (SWIG_arg_fail(2)) SWIG_fail;
29608 if (arg2 == NULL) {
29609 SWIG_null_ref("wxDataFormat");
29610 }
29611 if (SWIG_arg_fail(2)) SWIG_fail;
29612 }
29613 {
29614 PyThreadState* __tstate = wxPyBeginAllowThreads();
29615 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29616
29617 wxPyEndAllowThreads(__tstate);
29618 if (PyErr_Occurred()) SWIG_fail;
29619 }
29620 {
29621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29622 }
29623 return resultobj;
29624 fail:
29625 return NULL;
29626 }
29627
29628
29629 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29630 PyObject *resultobj;
29631 wxClipboard *arg1 = (wxClipboard *) 0 ;
29632 wxDataObject *arg2 = 0 ;
29633 bool result;
29634 PyObject * obj0 = 0 ;
29635 PyObject * obj1 = 0 ;
29636 char *kwnames[] = {
29637 (char *) "self",(char *) "data", NULL
29638 };
29639
29640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29642 if (SWIG_arg_fail(1)) SWIG_fail;
29643 {
29644 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29645 if (SWIG_arg_fail(2)) SWIG_fail;
29646 if (arg2 == NULL) {
29647 SWIG_null_ref("wxDataObject");
29648 }
29649 if (SWIG_arg_fail(2)) SWIG_fail;
29650 }
29651 {
29652 PyThreadState* __tstate = wxPyBeginAllowThreads();
29653 result = (bool)(arg1)->GetData(*arg2);
29654
29655 wxPyEndAllowThreads(__tstate);
29656 if (PyErr_Occurred()) SWIG_fail;
29657 }
29658 {
29659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29660 }
29661 return resultobj;
29662 fail:
29663 return NULL;
29664 }
29665
29666
29667 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29668 PyObject *resultobj;
29669 wxClipboard *arg1 = (wxClipboard *) 0 ;
29670 PyObject * obj0 = 0 ;
29671 char *kwnames[] = {
29672 (char *) "self", NULL
29673 };
29674
29675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29677 if (SWIG_arg_fail(1)) SWIG_fail;
29678 {
29679 PyThreadState* __tstate = wxPyBeginAllowThreads();
29680 (arg1)->Clear();
29681
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 Py_INCREF(Py_None); resultobj = Py_None;
29686 return resultobj;
29687 fail:
29688 return NULL;
29689 }
29690
29691
29692 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29693 PyObject *resultobj;
29694 wxClipboard *arg1 = (wxClipboard *) 0 ;
29695 bool result;
29696 PyObject * obj0 = 0 ;
29697 char *kwnames[] = {
29698 (char *) "self", NULL
29699 };
29700
29701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29703 if (SWIG_arg_fail(1)) SWIG_fail;
29704 {
29705 PyThreadState* __tstate = wxPyBeginAllowThreads();
29706 result = (bool)(arg1)->Flush();
29707
29708 wxPyEndAllowThreads(__tstate);
29709 if (PyErr_Occurred()) SWIG_fail;
29710 }
29711 {
29712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29713 }
29714 return resultobj;
29715 fail:
29716 return NULL;
29717 }
29718
29719
29720 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29721 PyObject *resultobj;
29722 wxClipboard *arg1 = (wxClipboard *) 0 ;
29723 bool arg2 = (bool) true ;
29724 PyObject * obj0 = 0 ;
29725 PyObject * obj1 = 0 ;
29726 char *kwnames[] = {
29727 (char *) "self",(char *) "primary", NULL
29728 };
29729
29730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29732 if (SWIG_arg_fail(1)) SWIG_fail;
29733 if (obj1) {
29734 {
29735 arg2 = (bool)(SWIG_As_bool(obj1));
29736 if (SWIG_arg_fail(2)) SWIG_fail;
29737 }
29738 }
29739 {
29740 PyThreadState* __tstate = wxPyBeginAllowThreads();
29741 (arg1)->UsePrimarySelection(arg2);
29742
29743 wxPyEndAllowThreads(__tstate);
29744 if (PyErr_Occurred()) SWIG_fail;
29745 }
29746 Py_INCREF(Py_None); resultobj = Py_None;
29747 return resultobj;
29748 fail:
29749 return NULL;
29750 }
29751
29752
29753 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29754 PyObject *resultobj;
29755 wxClipboard *result;
29756 char *kwnames[] = {
29757 NULL
29758 };
29759
29760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29761 {
29762 PyThreadState* __tstate = wxPyBeginAllowThreads();
29763 result = (wxClipboard *)wxClipboard::Get();
29764
29765 wxPyEndAllowThreads(__tstate);
29766 if (PyErr_Occurred()) SWIG_fail;
29767 }
29768 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29769 return resultobj;
29770 fail:
29771 return NULL;
29772 }
29773
29774
29775 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
29776 PyObject *obj;
29777 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29778 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
29779 Py_INCREF(obj);
29780 return Py_BuildValue((char *)"");
29781 }
29782 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29783 PyObject *resultobj;
29784 wxClipboard *arg1 = (wxClipboard *) NULL ;
29785 wxClipboardLocker *result;
29786 PyObject * obj0 = 0 ;
29787 char *kwnames[] = {
29788 (char *) "clipboard", NULL
29789 };
29790
29791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
29792 if (obj0) {
29793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29794 if (SWIG_arg_fail(1)) SWIG_fail;
29795 }
29796 {
29797 PyThreadState* __tstate = wxPyBeginAllowThreads();
29798 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
29799
29800 wxPyEndAllowThreads(__tstate);
29801 if (PyErr_Occurred()) SWIG_fail;
29802 }
29803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
29804 return resultobj;
29805 fail:
29806 return NULL;
29807 }
29808
29809
29810 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29811 PyObject *resultobj;
29812 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29813 PyObject * obj0 = 0 ;
29814 char *kwnames[] = {
29815 (char *) "self", NULL
29816 };
29817
29818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
29819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29820 if (SWIG_arg_fail(1)) SWIG_fail;
29821 {
29822 PyThreadState* __tstate = wxPyBeginAllowThreads();
29823 delete arg1;
29824
29825 wxPyEndAllowThreads(__tstate);
29826 if (PyErr_Occurred()) SWIG_fail;
29827 }
29828 Py_INCREF(Py_None); resultobj = Py_None;
29829 return resultobj;
29830 fail:
29831 return NULL;
29832 }
29833
29834
29835 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
29836 PyObject *resultobj;
29837 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29838 bool result;
29839 PyObject * obj0 = 0 ;
29840 char *kwnames[] = {
29841 (char *) "self", NULL
29842 };
29843
29844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
29845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29846 if (SWIG_arg_fail(1)) SWIG_fail;
29847 {
29848 PyThreadState* __tstate = wxPyBeginAllowThreads();
29849 result = (bool)wxClipboardLocker___nonzero__(arg1);
29850
29851 wxPyEndAllowThreads(__tstate);
29852 if (PyErr_Occurred()) SWIG_fail;
29853 }
29854 {
29855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29856 }
29857 return resultobj;
29858 fail:
29859 return NULL;
29860 }
29861
29862
29863 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
29864 PyObject *obj;
29865 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29866 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
29867 Py_INCREF(obj);
29868 return Py_BuildValue((char *)"");
29869 }
29870 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29871 PyObject *resultobj;
29872 int arg1 = (int) 0 ;
29873 int arg2 = (int) 0 ;
29874 int arg3 = (int) 0 ;
29875 int arg4 = (int) 0 ;
29876 wxVideoMode *result;
29877 PyObject * obj0 = 0 ;
29878 PyObject * obj1 = 0 ;
29879 PyObject * obj2 = 0 ;
29880 PyObject * obj3 = 0 ;
29881 char *kwnames[] = {
29882 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
29883 };
29884
29885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29886 if (obj0) {
29887 {
29888 arg1 = (int)(SWIG_As_int(obj0));
29889 if (SWIG_arg_fail(1)) SWIG_fail;
29890 }
29891 }
29892 if (obj1) {
29893 {
29894 arg2 = (int)(SWIG_As_int(obj1));
29895 if (SWIG_arg_fail(2)) SWIG_fail;
29896 }
29897 }
29898 if (obj2) {
29899 {
29900 arg3 = (int)(SWIG_As_int(obj2));
29901 if (SWIG_arg_fail(3)) SWIG_fail;
29902 }
29903 }
29904 if (obj3) {
29905 {
29906 arg4 = (int)(SWIG_As_int(obj3));
29907 if (SWIG_arg_fail(4)) SWIG_fail;
29908 }
29909 }
29910 {
29911 PyThreadState* __tstate = wxPyBeginAllowThreads();
29912 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
29913
29914 wxPyEndAllowThreads(__tstate);
29915 if (PyErr_Occurred()) SWIG_fail;
29916 }
29917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
29918 return resultobj;
29919 fail:
29920 return NULL;
29921 }
29922
29923
29924 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29925 PyObject *resultobj;
29926 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29927 PyObject * obj0 = 0 ;
29928 char *kwnames[] = {
29929 (char *) "self", NULL
29930 };
29931
29932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
29933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29934 if (SWIG_arg_fail(1)) SWIG_fail;
29935 {
29936 PyThreadState* __tstate = wxPyBeginAllowThreads();
29937 delete arg1;
29938
29939 wxPyEndAllowThreads(__tstate);
29940 if (PyErr_Occurred()) SWIG_fail;
29941 }
29942 Py_INCREF(Py_None); resultobj = Py_None;
29943 return resultobj;
29944 fail:
29945 return NULL;
29946 }
29947
29948
29949 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
29950 PyObject *resultobj;
29951 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29952 wxVideoMode *arg2 = 0 ;
29953 bool result;
29954 PyObject * obj0 = 0 ;
29955 PyObject * obj1 = 0 ;
29956 char *kwnames[] = {
29957 (char *) "self",(char *) "other", NULL
29958 };
29959
29960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
29961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29962 if (SWIG_arg_fail(1)) SWIG_fail;
29963 {
29964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29965 if (SWIG_arg_fail(2)) SWIG_fail;
29966 if (arg2 == NULL) {
29967 SWIG_null_ref("wxVideoMode");
29968 }
29969 if (SWIG_arg_fail(2)) SWIG_fail;
29970 }
29971 {
29972 PyThreadState* __tstate = wxPyBeginAllowThreads();
29973 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
29974
29975 wxPyEndAllowThreads(__tstate);
29976 if (PyErr_Occurred()) SWIG_fail;
29977 }
29978 {
29979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29980 }
29981 return resultobj;
29982 fail:
29983 return NULL;
29984 }
29985
29986
29987 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29988 PyObject *resultobj;
29989 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29990 int result;
29991 PyObject * obj0 = 0 ;
29992 char *kwnames[] = {
29993 (char *) "self", NULL
29994 };
29995
29996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
29997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29998 if (SWIG_arg_fail(1)) SWIG_fail;
29999 {
30000 PyThreadState* __tstate = wxPyBeginAllowThreads();
30001 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30002
30003 wxPyEndAllowThreads(__tstate);
30004 if (PyErr_Occurred()) SWIG_fail;
30005 }
30006 {
30007 resultobj = SWIG_From_int((int)(result));
30008 }
30009 return resultobj;
30010 fail:
30011 return NULL;
30012 }
30013
30014
30015 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30016 PyObject *resultobj;
30017 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30018 int result;
30019 PyObject * obj0 = 0 ;
30020 char *kwnames[] = {
30021 (char *) "self", NULL
30022 };
30023
30024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30026 if (SWIG_arg_fail(1)) SWIG_fail;
30027 {
30028 PyThreadState* __tstate = wxPyBeginAllowThreads();
30029 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30030
30031 wxPyEndAllowThreads(__tstate);
30032 if (PyErr_Occurred()) SWIG_fail;
30033 }
30034 {
30035 resultobj = SWIG_From_int((int)(result));
30036 }
30037 return resultobj;
30038 fail:
30039 return NULL;
30040 }
30041
30042
30043 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30044 PyObject *resultobj;
30045 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30046 int result;
30047 PyObject * obj0 = 0 ;
30048 char *kwnames[] = {
30049 (char *) "self", NULL
30050 };
30051
30052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30054 if (SWIG_arg_fail(1)) SWIG_fail;
30055 {
30056 PyThreadState* __tstate = wxPyBeginAllowThreads();
30057 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30058
30059 wxPyEndAllowThreads(__tstate);
30060 if (PyErr_Occurred()) SWIG_fail;
30061 }
30062 {
30063 resultobj = SWIG_From_int((int)(result));
30064 }
30065 return resultobj;
30066 fail:
30067 return NULL;
30068 }
30069
30070
30071 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30072 PyObject *resultobj;
30073 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30074 bool result;
30075 PyObject * obj0 = 0 ;
30076 char *kwnames[] = {
30077 (char *) "self", NULL
30078 };
30079
30080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30082 if (SWIG_arg_fail(1)) SWIG_fail;
30083 {
30084 PyThreadState* __tstate = wxPyBeginAllowThreads();
30085 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30086
30087 wxPyEndAllowThreads(__tstate);
30088 if (PyErr_Occurred()) SWIG_fail;
30089 }
30090 {
30091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30092 }
30093 return resultobj;
30094 fail:
30095 return NULL;
30096 }
30097
30098
30099 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30100 PyObject *resultobj;
30101 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30102 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30103 bool result;
30104 PyObject * obj0 = 0 ;
30105 PyObject * obj1 = 0 ;
30106 char *kwnames[] = {
30107 (char *) "self",(char *) "other", NULL
30108 };
30109
30110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30112 if (SWIG_arg_fail(1)) SWIG_fail;
30113 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30114 if (SWIG_arg_fail(2)) SWIG_fail;
30115 {
30116 PyThreadState* __tstate = wxPyBeginAllowThreads();
30117 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30118
30119 wxPyEndAllowThreads(__tstate);
30120 if (PyErr_Occurred()) SWIG_fail;
30121 }
30122 {
30123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30124 }
30125 return resultobj;
30126 fail:
30127 return NULL;
30128 }
30129
30130
30131 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30132 PyObject *resultobj;
30133 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30134 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30135 bool result;
30136 PyObject * obj0 = 0 ;
30137 PyObject * obj1 = 0 ;
30138 char *kwnames[] = {
30139 (char *) "self",(char *) "other", NULL
30140 };
30141
30142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30144 if (SWIG_arg_fail(1)) SWIG_fail;
30145 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30146 if (SWIG_arg_fail(2)) SWIG_fail;
30147 {
30148 PyThreadState* __tstate = wxPyBeginAllowThreads();
30149 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30150
30151 wxPyEndAllowThreads(__tstate);
30152 if (PyErr_Occurred()) SWIG_fail;
30153 }
30154 {
30155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30156 }
30157 return resultobj;
30158 fail:
30159 return NULL;
30160 }
30161
30162
30163 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30164 PyObject *resultobj;
30165 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30166 int arg2 ;
30167 PyObject * obj0 = 0 ;
30168 PyObject * obj1 = 0 ;
30169 char *kwnames[] = {
30170 (char *) "self",(char *) "w", NULL
30171 };
30172
30173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30175 if (SWIG_arg_fail(1)) SWIG_fail;
30176 {
30177 arg2 = (int)(SWIG_As_int(obj1));
30178 if (SWIG_arg_fail(2)) SWIG_fail;
30179 }
30180 if (arg1) (arg1)->w = arg2;
30181
30182 Py_INCREF(Py_None); resultobj = Py_None;
30183 return resultobj;
30184 fail:
30185 return NULL;
30186 }
30187
30188
30189 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30190 PyObject *resultobj;
30191 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30192 int result;
30193 PyObject * obj0 = 0 ;
30194 char *kwnames[] = {
30195 (char *) "self", NULL
30196 };
30197
30198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30200 if (SWIG_arg_fail(1)) SWIG_fail;
30201 result = (int) ((arg1)->w);
30202
30203 {
30204 resultobj = SWIG_From_int((int)(result));
30205 }
30206 return resultobj;
30207 fail:
30208 return NULL;
30209 }
30210
30211
30212 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30213 PyObject *resultobj;
30214 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30215 int arg2 ;
30216 PyObject * obj0 = 0 ;
30217 PyObject * obj1 = 0 ;
30218 char *kwnames[] = {
30219 (char *) "self",(char *) "h", NULL
30220 };
30221
30222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30224 if (SWIG_arg_fail(1)) SWIG_fail;
30225 {
30226 arg2 = (int)(SWIG_As_int(obj1));
30227 if (SWIG_arg_fail(2)) SWIG_fail;
30228 }
30229 if (arg1) (arg1)->h = arg2;
30230
30231 Py_INCREF(Py_None); resultobj = Py_None;
30232 return resultobj;
30233 fail:
30234 return NULL;
30235 }
30236
30237
30238 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30239 PyObject *resultobj;
30240 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30241 int result;
30242 PyObject * obj0 = 0 ;
30243 char *kwnames[] = {
30244 (char *) "self", NULL
30245 };
30246
30247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30249 if (SWIG_arg_fail(1)) SWIG_fail;
30250 result = (int) ((arg1)->h);
30251
30252 {
30253 resultobj = SWIG_From_int((int)(result));
30254 }
30255 return resultobj;
30256 fail:
30257 return NULL;
30258 }
30259
30260
30261 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30262 PyObject *resultobj;
30263 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30264 int arg2 ;
30265 PyObject * obj0 = 0 ;
30266 PyObject * obj1 = 0 ;
30267 char *kwnames[] = {
30268 (char *) "self",(char *) "bpp", NULL
30269 };
30270
30271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30273 if (SWIG_arg_fail(1)) SWIG_fail;
30274 {
30275 arg2 = (int)(SWIG_As_int(obj1));
30276 if (SWIG_arg_fail(2)) SWIG_fail;
30277 }
30278 if (arg1) (arg1)->bpp = arg2;
30279
30280 Py_INCREF(Py_None); resultobj = Py_None;
30281 return resultobj;
30282 fail:
30283 return NULL;
30284 }
30285
30286
30287 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30288 PyObject *resultobj;
30289 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30290 int result;
30291 PyObject * obj0 = 0 ;
30292 char *kwnames[] = {
30293 (char *) "self", NULL
30294 };
30295
30296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30298 if (SWIG_arg_fail(1)) SWIG_fail;
30299 result = (int) ((arg1)->bpp);
30300
30301 {
30302 resultobj = SWIG_From_int((int)(result));
30303 }
30304 return resultobj;
30305 fail:
30306 return NULL;
30307 }
30308
30309
30310 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30311 PyObject *resultobj;
30312 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30313 int arg2 ;
30314 PyObject * obj0 = 0 ;
30315 PyObject * obj1 = 0 ;
30316 char *kwnames[] = {
30317 (char *) "self",(char *) "refresh", NULL
30318 };
30319
30320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30322 if (SWIG_arg_fail(1)) SWIG_fail;
30323 {
30324 arg2 = (int)(SWIG_As_int(obj1));
30325 if (SWIG_arg_fail(2)) SWIG_fail;
30326 }
30327 if (arg1) (arg1)->refresh = arg2;
30328
30329 Py_INCREF(Py_None); resultobj = Py_None;
30330 return resultobj;
30331 fail:
30332 return NULL;
30333 }
30334
30335
30336 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30337 PyObject *resultobj;
30338 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30339 int result;
30340 PyObject * obj0 = 0 ;
30341 char *kwnames[] = {
30342 (char *) "self", NULL
30343 };
30344
30345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30347 if (SWIG_arg_fail(1)) SWIG_fail;
30348 result = (int) ((arg1)->refresh);
30349
30350 {
30351 resultobj = SWIG_From_int((int)(result));
30352 }
30353 return resultobj;
30354 fail:
30355 return NULL;
30356 }
30357
30358
30359 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30360 PyObject *obj;
30361 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30362 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30363 Py_INCREF(obj);
30364 return Py_BuildValue((char *)"");
30365 }
30366 static int _wrap_DefaultVideoMode_set(PyObject *) {
30367 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30368 return 1;
30369 }
30370
30371
30372 static PyObject *_wrap_DefaultVideoMode_get(void) {
30373 PyObject *pyobj;
30374
30375 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30376 return pyobj;
30377 }
30378
30379
30380 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30381 PyObject *resultobj;
30382 size_t arg1 = (size_t) 0 ;
30383 wxDisplay *result;
30384 PyObject * obj0 = 0 ;
30385 char *kwnames[] = {
30386 (char *) "index", NULL
30387 };
30388
30389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30390 if (obj0) {
30391 {
30392 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30393 if (SWIG_arg_fail(1)) SWIG_fail;
30394 }
30395 }
30396 {
30397 PyThreadState* __tstate = wxPyBeginAllowThreads();
30398 result = (wxDisplay *)new wxDisplay(arg1);
30399
30400 wxPyEndAllowThreads(__tstate);
30401 if (PyErr_Occurred()) SWIG_fail;
30402 }
30403 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30404 return resultobj;
30405 fail:
30406 return NULL;
30407 }
30408
30409
30410 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30411 PyObject *resultobj;
30412 wxDisplay *arg1 = (wxDisplay *) 0 ;
30413 PyObject * obj0 = 0 ;
30414 char *kwnames[] = {
30415 (char *) "self", NULL
30416 };
30417
30418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30420 if (SWIG_arg_fail(1)) SWIG_fail;
30421 {
30422 PyThreadState* __tstate = wxPyBeginAllowThreads();
30423 delete arg1;
30424
30425 wxPyEndAllowThreads(__tstate);
30426 if (PyErr_Occurred()) SWIG_fail;
30427 }
30428 Py_INCREF(Py_None); resultobj = Py_None;
30429 return resultobj;
30430 fail:
30431 return NULL;
30432 }
30433
30434
30435 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30436 PyObject *resultobj;
30437 size_t result;
30438 char *kwnames[] = {
30439 NULL
30440 };
30441
30442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30443 {
30444 PyThreadState* __tstate = wxPyBeginAllowThreads();
30445 result = (size_t)wxDisplay::GetCount();
30446
30447 wxPyEndAllowThreads(__tstate);
30448 if (PyErr_Occurred()) SWIG_fail;
30449 }
30450 {
30451 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30452 }
30453 return resultobj;
30454 fail:
30455 return NULL;
30456 }
30457
30458
30459 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30460 PyObject *resultobj;
30461 wxPoint *arg1 = 0 ;
30462 int result;
30463 wxPoint temp1 ;
30464 PyObject * obj0 = 0 ;
30465 char *kwnames[] = {
30466 (char *) "pt", NULL
30467 };
30468
30469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30470 {
30471 arg1 = &temp1;
30472 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30473 }
30474 {
30475 PyThreadState* __tstate = wxPyBeginAllowThreads();
30476 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30477
30478 wxPyEndAllowThreads(__tstate);
30479 if (PyErr_Occurred()) SWIG_fail;
30480 }
30481 {
30482 resultobj = SWIG_From_int((int)(result));
30483 }
30484 return resultobj;
30485 fail:
30486 return NULL;
30487 }
30488
30489
30490 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30491 PyObject *resultobj;
30492 wxWindow *arg1 = (wxWindow *) 0 ;
30493 int result;
30494 PyObject * obj0 = 0 ;
30495 char *kwnames[] = {
30496 (char *) "window", NULL
30497 };
30498
30499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30501 if (SWIG_arg_fail(1)) SWIG_fail;
30502 {
30503 PyThreadState* __tstate = wxPyBeginAllowThreads();
30504 result = (int)wxDisplay::GetFromWindow(arg1);
30505
30506 wxPyEndAllowThreads(__tstate);
30507 if (PyErr_Occurred()) SWIG_fail;
30508 }
30509 {
30510 resultobj = SWIG_From_int((int)(result));
30511 }
30512 return resultobj;
30513 fail:
30514 return NULL;
30515 }
30516
30517
30518 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30519 PyObject *resultobj;
30520 wxDisplay *arg1 = (wxDisplay *) 0 ;
30521 bool result;
30522 PyObject * obj0 = 0 ;
30523 char *kwnames[] = {
30524 (char *) "self", NULL
30525 };
30526
30527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30529 if (SWIG_arg_fail(1)) SWIG_fail;
30530 {
30531 PyThreadState* __tstate = wxPyBeginAllowThreads();
30532 result = (bool)((wxDisplay const *)arg1)->IsOk();
30533
30534 wxPyEndAllowThreads(__tstate);
30535 if (PyErr_Occurred()) SWIG_fail;
30536 }
30537 {
30538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30539 }
30540 return resultobj;
30541 fail:
30542 return NULL;
30543 }
30544
30545
30546 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30547 PyObject *resultobj;
30548 wxDisplay *arg1 = (wxDisplay *) 0 ;
30549 wxRect result;
30550 PyObject * obj0 = 0 ;
30551 char *kwnames[] = {
30552 (char *) "self", NULL
30553 };
30554
30555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30557 if (SWIG_arg_fail(1)) SWIG_fail;
30558 {
30559 PyThreadState* __tstate = wxPyBeginAllowThreads();
30560 result = ((wxDisplay const *)arg1)->GetGeometry();
30561
30562 wxPyEndAllowThreads(__tstate);
30563 if (PyErr_Occurred()) SWIG_fail;
30564 }
30565 {
30566 wxRect * resultptr;
30567 resultptr = new wxRect((wxRect &)(result));
30568 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30569 }
30570 return resultobj;
30571 fail:
30572 return NULL;
30573 }
30574
30575
30576 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30577 PyObject *resultobj;
30578 wxDisplay *arg1 = (wxDisplay *) 0 ;
30579 wxString result;
30580 PyObject * obj0 = 0 ;
30581 char *kwnames[] = {
30582 (char *) "self", NULL
30583 };
30584
30585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30587 if (SWIG_arg_fail(1)) SWIG_fail;
30588 {
30589 PyThreadState* __tstate = wxPyBeginAllowThreads();
30590 result = ((wxDisplay const *)arg1)->GetName();
30591
30592 wxPyEndAllowThreads(__tstate);
30593 if (PyErr_Occurred()) SWIG_fail;
30594 }
30595 {
30596 #if wxUSE_UNICODE
30597 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30598 #else
30599 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30600 #endif
30601 }
30602 return resultobj;
30603 fail:
30604 return NULL;
30605 }
30606
30607
30608 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30609 PyObject *resultobj;
30610 wxDisplay *arg1 = (wxDisplay *) 0 ;
30611 bool result;
30612 PyObject * obj0 = 0 ;
30613 char *kwnames[] = {
30614 (char *) "self", NULL
30615 };
30616
30617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30619 if (SWIG_arg_fail(1)) SWIG_fail;
30620 {
30621 PyThreadState* __tstate = wxPyBeginAllowThreads();
30622 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30623
30624 wxPyEndAllowThreads(__tstate);
30625 if (PyErr_Occurred()) SWIG_fail;
30626 }
30627 {
30628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30629 }
30630 return resultobj;
30631 fail:
30632 return NULL;
30633 }
30634
30635
30636 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30637 PyObject *resultobj;
30638 wxDisplay *arg1 = (wxDisplay *) 0 ;
30639 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30640 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30641 PyObject *result;
30642 PyObject * obj0 = 0 ;
30643 PyObject * obj1 = 0 ;
30644 char *kwnames[] = {
30645 (char *) "self",(char *) "mode", NULL
30646 };
30647
30648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30650 if (SWIG_arg_fail(1)) SWIG_fail;
30651 if (obj1) {
30652 {
30653 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30654 if (SWIG_arg_fail(2)) SWIG_fail;
30655 if (arg2 == NULL) {
30656 SWIG_null_ref("wxVideoMode");
30657 }
30658 if (SWIG_arg_fail(2)) SWIG_fail;
30659 }
30660 }
30661 {
30662 PyThreadState* __tstate = wxPyBeginAllowThreads();
30663 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30664
30665 wxPyEndAllowThreads(__tstate);
30666 if (PyErr_Occurred()) SWIG_fail;
30667 }
30668 resultobj = result;
30669 return resultobj;
30670 fail:
30671 return NULL;
30672 }
30673
30674
30675 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30676 PyObject *resultobj;
30677 wxDisplay *arg1 = (wxDisplay *) 0 ;
30678 wxVideoMode result;
30679 PyObject * obj0 = 0 ;
30680 char *kwnames[] = {
30681 (char *) "self", NULL
30682 };
30683
30684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30686 if (SWIG_arg_fail(1)) SWIG_fail;
30687 {
30688 PyThreadState* __tstate = wxPyBeginAllowThreads();
30689 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30690
30691 wxPyEndAllowThreads(__tstate);
30692 if (PyErr_Occurred()) SWIG_fail;
30693 }
30694 {
30695 wxVideoMode * resultptr;
30696 resultptr = new wxVideoMode((wxVideoMode &)(result));
30697 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30698 }
30699 return resultobj;
30700 fail:
30701 return NULL;
30702 }
30703
30704
30705 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30706 PyObject *resultobj;
30707 wxDisplay *arg1 = (wxDisplay *) 0 ;
30708 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30709 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30710 bool result;
30711 PyObject * obj0 = 0 ;
30712 PyObject * obj1 = 0 ;
30713 char *kwnames[] = {
30714 (char *) "self",(char *) "mode", NULL
30715 };
30716
30717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30719 if (SWIG_arg_fail(1)) SWIG_fail;
30720 if (obj1) {
30721 {
30722 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30723 if (SWIG_arg_fail(2)) SWIG_fail;
30724 if (arg2 == NULL) {
30725 SWIG_null_ref("wxVideoMode");
30726 }
30727 if (SWIG_arg_fail(2)) SWIG_fail;
30728 }
30729 }
30730 {
30731 PyThreadState* __tstate = wxPyBeginAllowThreads();
30732 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30733
30734 wxPyEndAllowThreads(__tstate);
30735 if (PyErr_Occurred()) SWIG_fail;
30736 }
30737 {
30738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30739 }
30740 return resultobj;
30741 fail:
30742 return NULL;
30743 }
30744
30745
30746 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30747 PyObject *resultobj;
30748 wxDisplay *arg1 = (wxDisplay *) 0 ;
30749 PyObject * obj0 = 0 ;
30750 char *kwnames[] = {
30751 (char *) "self", NULL
30752 };
30753
30754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30756 if (SWIG_arg_fail(1)) SWIG_fail;
30757 {
30758 PyThreadState* __tstate = wxPyBeginAllowThreads();
30759 (arg1)->ResetMode();
30760
30761 wxPyEndAllowThreads(__tstate);
30762 if (PyErr_Occurred()) SWIG_fail;
30763 }
30764 Py_INCREF(Py_None); resultobj = Py_None;
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30772 PyObject *obj;
30773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30774 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
30775 Py_INCREF(obj);
30776 return Py_BuildValue((char *)"");
30777 }
30778 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30779 PyObject *resultobj;
30780 wxStandardPaths *result;
30781 char *kwnames[] = {
30782 NULL
30783 };
30784
30785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
30786 {
30787 PyThreadState* __tstate = wxPyBeginAllowThreads();
30788 result = (wxStandardPaths *)StandardPaths_Get();
30789
30790 wxPyEndAllowThreads(__tstate);
30791 if (PyErr_Occurred()) SWIG_fail;
30792 }
30793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
30794 return resultobj;
30795 fail:
30796 return NULL;
30797 }
30798
30799
30800 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30801 PyObject *resultobj;
30802 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30803 wxString result;
30804 PyObject * obj0 = 0 ;
30805 char *kwnames[] = {
30806 (char *) "self", NULL
30807 };
30808
30809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
30810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30811 if (SWIG_arg_fail(1)) SWIG_fail;
30812 {
30813 PyThreadState* __tstate = wxPyBeginAllowThreads();
30814 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
30815
30816 wxPyEndAllowThreads(__tstate);
30817 if (PyErr_Occurred()) SWIG_fail;
30818 }
30819 {
30820 #if wxUSE_UNICODE
30821 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30822 #else
30823 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30824 #endif
30825 }
30826 return resultobj;
30827 fail:
30828 return NULL;
30829 }
30830
30831
30832 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30833 PyObject *resultobj;
30834 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30835 wxString result;
30836 PyObject * obj0 = 0 ;
30837 char *kwnames[] = {
30838 (char *) "self", NULL
30839 };
30840
30841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
30842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30843 if (SWIG_arg_fail(1)) SWIG_fail;
30844 {
30845 PyThreadState* __tstate = wxPyBeginAllowThreads();
30846 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
30847
30848 wxPyEndAllowThreads(__tstate);
30849 if (PyErr_Occurred()) SWIG_fail;
30850 }
30851 {
30852 #if wxUSE_UNICODE
30853 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30854 #else
30855 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30856 #endif
30857 }
30858 return resultobj;
30859 fail:
30860 return NULL;
30861 }
30862
30863
30864 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30865 PyObject *resultobj;
30866 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30867 wxString result;
30868 PyObject * obj0 = 0 ;
30869 char *kwnames[] = {
30870 (char *) "self", NULL
30871 };
30872
30873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
30874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30875 if (SWIG_arg_fail(1)) SWIG_fail;
30876 {
30877 PyThreadState* __tstate = wxPyBeginAllowThreads();
30878 result = ((wxStandardPaths const *)arg1)->GetDataDir();
30879
30880 wxPyEndAllowThreads(__tstate);
30881 if (PyErr_Occurred()) SWIG_fail;
30882 }
30883 {
30884 #if wxUSE_UNICODE
30885 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30886 #else
30887 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30888 #endif
30889 }
30890 return resultobj;
30891 fail:
30892 return NULL;
30893 }
30894
30895
30896 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30897 PyObject *resultobj;
30898 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30899 wxString result;
30900 PyObject * obj0 = 0 ;
30901 char *kwnames[] = {
30902 (char *) "self", NULL
30903 };
30904
30905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
30906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30907 if (SWIG_arg_fail(1)) SWIG_fail;
30908 {
30909 PyThreadState* __tstate = wxPyBeginAllowThreads();
30910 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
30911
30912 wxPyEndAllowThreads(__tstate);
30913 if (PyErr_Occurred()) SWIG_fail;
30914 }
30915 {
30916 #if wxUSE_UNICODE
30917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30918 #else
30919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30920 #endif
30921 }
30922 return resultobj;
30923 fail:
30924 return NULL;
30925 }
30926
30927
30928 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30929 PyObject *resultobj;
30930 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30931 wxString result;
30932 PyObject * obj0 = 0 ;
30933 char *kwnames[] = {
30934 (char *) "self", NULL
30935 };
30936
30937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
30938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30939 if (SWIG_arg_fail(1)) SWIG_fail;
30940 {
30941 PyThreadState* __tstate = wxPyBeginAllowThreads();
30942 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
30943
30944 wxPyEndAllowThreads(__tstate);
30945 if (PyErr_Occurred()) SWIG_fail;
30946 }
30947 {
30948 #if wxUSE_UNICODE
30949 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30950 #else
30951 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30952 #endif
30953 }
30954 return resultobj;
30955 fail:
30956 return NULL;
30957 }
30958
30959
30960 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30961 PyObject *resultobj;
30962 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30963 wxString result;
30964 PyObject * obj0 = 0 ;
30965 char *kwnames[] = {
30966 (char *) "self", NULL
30967 };
30968
30969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
30970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30971 if (SWIG_arg_fail(1)) SWIG_fail;
30972 {
30973 PyThreadState* __tstate = wxPyBeginAllowThreads();
30974 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
30975
30976 wxPyEndAllowThreads(__tstate);
30977 if (PyErr_Occurred()) SWIG_fail;
30978 }
30979 {
30980 #if wxUSE_UNICODE
30981 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30982 #else
30983 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30984 #endif
30985 }
30986 return resultobj;
30987 fail:
30988 return NULL;
30989 }
30990
30991
30992 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
30993 PyObject *resultobj;
30994 wxStandardPaths *arg1 = (wxStandardPaths *) 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:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31003 if (SWIG_arg_fail(1)) SWIG_fail;
31004 {
31005 PyThreadState* __tstate = wxPyBeginAllowThreads();
31006 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
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_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31025 PyObject *resultobj;
31026 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31027 wxString *arg2 = 0 ;
31028 bool temp2 = false ;
31029 PyObject * obj0 = 0 ;
31030 PyObject * obj1 = 0 ;
31031 char *kwnames[] = {
31032 (char *) "self",(char *) "prefix", NULL
31033 };
31034
31035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31037 if (SWIG_arg_fail(1)) SWIG_fail;
31038 {
31039 arg2 = wxString_in_helper(obj1);
31040 if (arg2 == NULL) SWIG_fail;
31041 temp2 = true;
31042 }
31043 {
31044 PyThreadState* __tstate = wxPyBeginAllowThreads();
31045 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31046
31047 wxPyEndAllowThreads(__tstate);
31048 if (PyErr_Occurred()) SWIG_fail;
31049 }
31050 Py_INCREF(Py_None); resultobj = Py_None;
31051 {
31052 if (temp2)
31053 delete arg2;
31054 }
31055 return resultobj;
31056 fail:
31057 {
31058 if (temp2)
31059 delete arg2;
31060 }
31061 return NULL;
31062 }
31063
31064
31065 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31066 PyObject *resultobj;
31067 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31068 wxString result;
31069 PyObject * obj0 = 0 ;
31070 char *kwnames[] = {
31071 (char *) "self", NULL
31072 };
31073
31074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31076 if (SWIG_arg_fail(1)) SWIG_fail;
31077 {
31078 PyThreadState* __tstate = wxPyBeginAllowThreads();
31079 result = wxStandardPaths_GetInstallPrefix(arg1);
31080
31081 wxPyEndAllowThreads(__tstate);
31082 if (PyErr_Occurred()) SWIG_fail;
31083 }
31084 {
31085 #if wxUSE_UNICODE
31086 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31087 #else
31088 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31089 #endif
31090 }
31091 return resultobj;
31092 fail:
31093 return NULL;
31094 }
31095
31096
31097 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31098 PyObject *obj;
31099 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31100 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31101 Py_INCREF(obj);
31102 return Py_BuildValue((char *)"");
31103 }
31104 static PyMethodDef SwigMethods[] = {
31105 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31106 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31107 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31108 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31109 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31110 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31111 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31112 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31113 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31114 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31115 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31116 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31117 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31118 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31119 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31120 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31121 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31122 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31123 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31124 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31125 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31126 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31127 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31128 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31129 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31130 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31131 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31132 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31133 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31134 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31135 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31136 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31137 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31138 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31139 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31140 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31141 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31142 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31143 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31144 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31145 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31146 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31147 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31148 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31149 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31150 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31151 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31152 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31153 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31154 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31155 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31156 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31157 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31158 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31159 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31160 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31161 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31162 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31163 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31164 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31165 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31166 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31167 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31168 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31169 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31170 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31171 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31172 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31173 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31174 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31175 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31176 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31177 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31178 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31179 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31180 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31181 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31182 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31183 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31184 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31185 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31186 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31187 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31188 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31189 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31190 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31191 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31192 { (char *)"delete_Caret", (PyCFunction) _wrap_delete_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31193 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31194 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31195 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31196 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31197 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31198 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31199 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31200 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31201 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31202 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31203 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31204 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31205 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31206 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31207 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31208 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31209 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31210 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31211 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31212 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31213 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31214 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31215 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31216 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31217 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31218 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31219 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31220 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31221 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31222 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31223 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31224 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31225 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31226 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31227 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31228 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31229 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31230 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31231 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31232 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31233 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31234 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31235 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31236 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31237 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31238 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31239 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31240 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31241 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31242 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31243 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31244 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31245 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31246 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31247 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31248 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31249 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31250 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31251 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31252 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31253 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31254 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31255 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31256 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31257 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31258 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31259 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31260 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31261 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31262 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31263 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31264 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31265 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31266 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31267 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31268 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31269 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31270 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31271 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31272 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31273 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31274 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31275 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31276 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31277 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31278 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31279 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31280 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31281 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31282 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31283 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31284 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31285 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31286 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31287 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31288 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31289 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31290 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31291 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31292 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31293 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31294 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31295 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31296 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31297 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31298 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31299 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31300 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31301 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31302 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31303 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31304 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31305 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31306 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31307 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31308 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31309 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31310 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31311 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31312 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31313 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31314 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31315 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31316 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31317 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31318 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31319 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31320 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31321 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31322 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31323 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31324 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31325 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31326 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31327 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31328 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31329 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31330 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31331 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31332 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31333 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31337 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31338 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31339 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31340 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31342 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31357 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31365 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31373 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31412 { (char *)"JoystickEvent_m_pos_set", (PyCFunction) _wrap_JoystickEvent_m_pos_set, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"JoystickEvent_m_pos_get", (PyCFunction) _wrap_JoystickEvent_m_pos_get, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"JoystickEvent_m_zPosition_set", (PyCFunction) _wrap_JoystickEvent_m_zPosition_set, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"JoystickEvent_m_zPosition_get", (PyCFunction) _wrap_JoystickEvent_m_zPosition_get, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"JoystickEvent_m_buttonChange_set", (PyCFunction) _wrap_JoystickEvent_m_buttonChange_set, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"JoystickEvent_m_buttonChange_get", (PyCFunction) _wrap_JoystickEvent_m_buttonChange_get, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"JoystickEvent_m_buttonState_set", (PyCFunction) _wrap_JoystickEvent_m_buttonState_set, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"JoystickEvent_m_buttonState_get", (PyCFunction) _wrap_JoystickEvent_m_buttonState_get, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"JoystickEvent_m_joyStick_set", (PyCFunction) _wrap_JoystickEvent_m_joyStick_set, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"JoystickEvent_m_joyStick_get", (PyCFunction) _wrap_JoystickEvent_m_joyStick_get, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31440 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31450 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31466 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31482 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31496 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31505 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31548 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31551 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31554 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31558 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31651 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31652 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31653 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31654 { (char *)"DateTime___lt__", _wrap_DateTime___lt__, METH_VARARGS, NULL},
31655 { (char *)"DateTime___le__", _wrap_DateTime___le__, METH_VARARGS, NULL},
31656 { (char *)"DateTime___gt__", _wrap_DateTime___gt__, METH_VARARGS, NULL},
31657 { (char *)"DateTime___ge__", _wrap_DateTime___ge__, METH_VARARGS, NULL},
31658 { (char *)"DateTime___eq__", _wrap_DateTime___eq__, METH_VARARGS, NULL},
31659 { (char *)"DateTime___ne__", _wrap_DateTime___ne__, METH_VARARGS, NULL},
31660 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31671 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31716 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31750 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31758 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31759 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31764 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31773 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31780 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
31783 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
31786 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
31791 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
31794 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
31798 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
31801 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
31805 { (char *)"new_CustomDataObject", (PyCFunction) _wrap_new_CustomDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
31810 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
31814 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
31818 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
31828 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
31839 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
31847 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
31855 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
31869 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
31873 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
31891 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
31905 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
31916 { NULL, NULL, 0, NULL }
31917 };
31918
31919
31920 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
31921
31922 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
31923 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
31924 }
31925 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
31926 return (void *)((wxEvent *) ((wxMenuEvent *) x));
31927 }
31928 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
31929 return (void *)((wxEvent *) ((wxCloseEvent *) x));
31930 }
31931 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
31932 return (void *)((wxEvent *) ((wxMouseEvent *) x));
31933 }
31934 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
31935 return (void *)((wxEvent *) ((wxEraseEvent *) x));
31936 }
31937 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
31938 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
31939 }
31940 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
31941 return (void *)((wxEvent *) ((wxTimerEvent *) x));
31942 }
31943 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
31944 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
31945 }
31946 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
31947 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
31948 }
31949 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
31950 return (void *)((wxEvent *) ((wxPyEvent *) x));
31951 }
31952 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
31953 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
31954 }
31955 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
31956 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
31957 }
31958 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
31959 return (void *)((wxEvent *) ((wxIdleEvent *) x));
31960 }
31961 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
31962 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
31963 }
31964 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
31965 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
31966 }
31967 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
31968 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
31969 }
31970 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
31971 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
31972 }
31973 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
31974 return (void *)((wxEvent *) ((wxActivateEvent *) x));
31975 }
31976 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
31977 return (void *)((wxEvent *) ((wxSizeEvent *) x));
31978 }
31979 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
31980 return (void *)((wxEvent *) ((wxMoveEvent *) x));
31981 }
31982 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
31983 return (void *)((wxEvent *) ((wxPaintEvent *) x));
31984 }
31985 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
31986 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
31987 }
31988 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
31989 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
31990 }
31991 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
31992 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
31993 }
31994 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
31995 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
31996 }
31997 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
31998 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
31999 }
32000 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32001 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32002 }
32003 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32004 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32005 }
32006 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32007 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32008 }
32009 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32010 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32011 }
32012 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32013 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32014 }
32015 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32016 return (void *)((wxEvent *) ((wxShowEvent *) x));
32017 }
32018 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32019 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32020 }
32021 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32022 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32023 }
32024 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32025 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32026 }
32027 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32028 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32029 }
32030 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32031 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32032 }
32033 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32034 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32035 }
32036 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32037 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32038 }
32039 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32040 return (void *)((wxConfigBase *) ((wxConfig *) x));
32041 }
32042 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32043 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32044 }
32045 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32046 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32047 }
32048 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32049 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32050 }
32051 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32052 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32053 }
32054 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32055 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32056 }
32057 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32058 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32059 }
32060 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32061 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32062 }
32063 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32064 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32065 }
32066 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32067 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32068 }
32069 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32070 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32071 }
32072 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32073 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32074 }
32075 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32076 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32077 }
32078 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32079 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32080 }
32081 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32082 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32083 }
32084 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32085 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32086 }
32087 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32088 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32089 }
32090 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32091 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32092 }
32093 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32094 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32095 }
32096 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32097 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32098 }
32099 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32100 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32101 }
32102 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32103 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32104 }
32105 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32106 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32107 }
32108 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32109 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32110 }
32111 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32112 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32113 }
32114 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32115 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32116 }
32117 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32118 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32119 }
32120 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32121 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32122 }
32123 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32124 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32125 }
32126 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32127 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32128 }
32129 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32130 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32131 }
32132 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32133 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32134 }
32135 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32136 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32137 }
32138 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32139 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32140 }
32141 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32142 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32143 }
32144 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32145 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32146 }
32147 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32148 return (void *)((wxObject *) ((wxSizerItem *) x));
32149 }
32150 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32151 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32152 }
32153 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32154 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32155 }
32156 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32157 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32158 }
32159 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32160 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32161 }
32162 static void *_p_wxSizerTo_p_wxObject(void *x) {
32163 return (void *)((wxObject *) ((wxSizer *) x));
32164 }
32165 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32166 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32167 }
32168 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32169 return (void *)((wxObject *) ((wxFileHistory *) x));
32170 }
32171 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32172 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32173 }
32174 static void *_p_wxEventTo_p_wxObject(void *x) {
32175 return (void *)((wxObject *) ((wxEvent *) x));
32176 }
32177 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32178 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32179 }
32180 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32181 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32182 }
32183 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32184 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32185 }
32186 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32187 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32188 }
32189 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32190 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32191 }
32192 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32193 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32194 }
32195 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32196 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32197 }
32198 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32199 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32200 }
32201 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32202 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32203 }
32204 static void *_p_wxControlTo_p_wxObject(void *x) {
32205 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32206 }
32207 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32208 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32209 }
32210 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32211 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32212 }
32213 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32214 return (void *)((wxObject *) ((wxFSFile *) x));
32215 }
32216 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32217 return (void *)((wxObject *) ((wxClipboard *) x));
32218 }
32219 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32220 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32221 }
32222 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32223 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32224 }
32225 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32226 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32227 }
32228 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32229 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32230 }
32231 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32232 return (void *)((wxObject *) ((wxToolTip *) x));
32233 }
32234 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32235 return (void *)((wxObject *) ((wxMenuItem *) x));
32236 }
32237 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32238 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32239 }
32240 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32241 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32242 }
32243 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32244 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32245 }
32246 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32247 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32248 }
32249 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32250 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32251 }
32252 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32253 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32254 }
32255 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32256 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32257 }
32258 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32259 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32260 }
32261 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32262 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32263 }
32264 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32265 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32266 }
32267 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32268 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32269 }
32270 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32271 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32272 }
32273 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32274 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32275 }
32276 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32277 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32278 }
32279 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32280 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32281 }
32282 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32283 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32284 }
32285 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32286 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32287 }
32288 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32289 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32290 }
32291 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32292 return (void *)((wxObject *) ((wxImageHandler *) x));
32293 }
32294 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32295 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32296 }
32297 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32298 return (void *)((wxObject *) ((wxEvtHandler *) x));
32299 }
32300 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32301 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32302 }
32303 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32304 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32305 }
32306 static void *_p_wxImageTo_p_wxObject(void *x) {
32307 return (void *)((wxObject *) ((wxImage *) x));
32308 }
32309 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32310 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32311 }
32312 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32313 return (void *)((wxObject *) ((wxSystemOptions *) x));
32314 }
32315 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32316 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32317 }
32318 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32319 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32320 }
32321 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32322 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32323 }
32324 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32325 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32326 }
32327 static void *_p_wxWindowTo_p_wxObject(void *x) {
32328 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32329 }
32330 static void *_p_wxMenuTo_p_wxObject(void *x) {
32331 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32332 }
32333 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32334 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32335 }
32336 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32337 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32338 }
32339 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32340 return (void *)((wxObject *) ((wxFileSystem *) x));
32341 }
32342 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32343 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32344 }
32345 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32346 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32347 }
32348 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32349 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32350 }
32351 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32352 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32353 }
32354 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32355 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32356 }
32357 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32358 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32359 }
32360 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32361 return (void *)((wxObject *) ((wxBusyInfo *) x));
32362 }
32363 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32364 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32365 }
32366 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32367 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32368 }
32369 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32370 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32371 }
32372 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32373 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32374 }
32375 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32376 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32377 }
32378 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32379 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32380 }
32381 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32382 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32383 }
32384 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32385 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32386 }
32387 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32388 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32389 }
32390 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32391 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32392 }
32393 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32394 return (void *)((wxLog *) ((wxLogStderr *) x));
32395 }
32396 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32397 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32398 }
32399 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32400 return (void *)((wxLog *) ((wxLogWindow *) x));
32401 }
32402 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32403 return (void *)((wxLog *) ((wxLogChain *) x));
32404 }
32405 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32406 return (void *)((wxLog *) ((wxLogGui *) x));
32407 }
32408 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32409 return (void *)((wxLog *) ((wxPyLog *) x));
32410 }
32411 static void *_p_wxControlTo_p_wxWindow(void *x) {
32412 return (void *)((wxWindow *) ((wxControl *) x));
32413 }
32414 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32415 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32416 }
32417 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32418 return (void *)((wxWindow *) ((wxMenuBar *) x));
32419 }
32420 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32421 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32422 }
32423 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32424 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32425 }
32426 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}};
32427 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}};
32428 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}};
32429 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}};
32430 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}};
32431 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}};
32432 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32433 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}};
32434 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}};
32435 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}};
32436 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}};
32437 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}};
32438 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}};
32439 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}};
32440 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}};
32441 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}};
32442 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}};
32443 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}};
32444 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}};
32445 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}};
32446 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}};
32447 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}};
32448 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}};
32449 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}};
32450 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}};
32451 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}};
32452 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}};
32453 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}};
32454 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}};
32455 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}};
32456 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}};
32457 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}};
32458 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}};
32459 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}};
32460 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}};
32461 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}};
32462 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}};
32463 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}};
32464 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}};
32465 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}};
32466 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}};
32467 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}};
32468 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}};
32469 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}};
32470 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}};
32471 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}};
32472 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}};
32473 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}};
32474 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}};
32475 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}};
32476 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}};
32477 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}};
32478 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}};
32479 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}};
32480 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}};
32481 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}};
32482 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}};
32483 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}};
32484 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}};
32485 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}};
32486 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}};
32487 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}};
32488 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}};
32489 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}};
32490 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}};
32491 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}};
32492 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}};
32493 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}};
32494 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}};
32495 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}};
32496 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileHistory", _p_wxFileHistoryTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClipboard", _p_wxClipboardTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToolTip", _p_wxToolTipTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSystemOptions", _p_wxSystemOptionsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyProcess", _p_wxPyProcessTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBusyInfo", _p_wxBusyInfoTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyTimer", _p_wxPyTimerTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32497 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}};
32498 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}};
32499 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}};
32500 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}};
32501 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}};
32502 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}};
32503 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}};
32504 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}};
32505 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}};
32506 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}};
32507 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}};
32508 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}};
32509 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}};
32510 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}};
32511 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}};
32512 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}};
32513 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}};
32514 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}};
32515 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}};
32516 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}};
32517 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}};
32518 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}};
32519 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}};
32520 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}};
32521 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}};
32522
32523 static swig_type_info *swig_types_initial[] = {
32524 _swigt__p_wxLogChain,
32525 _swigt__p_wxMutexGuiLocker,
32526 _swigt__p_wxMetafile,
32527 _swigt__p_wxFileHistory,
32528 _swigt__p_wxLog,
32529 _swigt__p_wxMenu,
32530 _swigt__p_wxEvent,
32531 _swigt__p_wxDateTime__TimeZone,
32532 _swigt__p_wxConfigBase,
32533 _swigt__p_wxDisplay,
32534 _swigt__p_wxFileType,
32535 _swigt__p_wxLogGui,
32536 _swigt__p_wxFont,
32537 _swigt__p_wxDataFormat,
32538 _swigt__p_wxTimerEvent,
32539 _swigt__p_wxCaret,
32540 _swigt__ptrdiff_t,
32541 _swigt__std__ptrdiff_t,
32542 _swigt__p_int,
32543 _swigt__p_wxSize,
32544 _swigt__p_wxClipboard,
32545 _swigt__p_wxStopWatch,
32546 _swigt__p_wxClipboardLocker,
32547 _swigt__p_wxIcon,
32548 _swigt__p_wxLogStderr,
32549 _swigt__p_wxLogTextCtrl,
32550 _swigt__p_wxTextCtrl,
32551 _swigt__p_wxBusyCursor,
32552 _swigt__p_wxBitmapDataObject,
32553 _swigt__p_wxTextDataObject,
32554 _swigt__p_wxDataObject,
32555 _swigt__p_wxPyTextDataObject,
32556 _swigt__p_wxPyBitmapDataObject,
32557 _swigt__p_wxFileDataObject,
32558 _swigt__p_wxCustomDataObject,
32559 _swigt__p_wxURLDataObject,
32560 _swigt__p_wxMetafileDataObject,
32561 _swigt__p_wxSound,
32562 _swigt__p_wxTimerRunner,
32563 _swigt__p_wxLogWindow,
32564 _swigt__p_wxTimeSpan,
32565 _swigt__p_wxArrayString,
32566 _swigt__p_wxWindowDisabler,
32567 _swigt__p_form_ops_t,
32568 _swigt__p_wxToolTip,
32569 _swigt__p_wxDataObjectComposite,
32570 _swigt__p_wxFileConfig,
32571 _swigt__p_wxSystemSettings,
32572 _swigt__p_wxVideoMode,
32573 _swigt__p_wxDataObjectSimple,
32574 _swigt__p_wxPyDataObjectSimple,
32575 _swigt__p_wxDuplexMode,
32576 _swigt__p_wxEvtHandler,
32577 _swigt__p_wxRect,
32578 _swigt__p_char,
32579 _swigt__p_wxSingleInstanceChecker,
32580 _swigt__p_wxStandardPaths,
32581 _swigt__p_wxFileTypeInfo,
32582 _swigt__p_wxFrame,
32583 _swigt__p_wxTimer,
32584 _swigt__p_wxPaperSize,
32585 _swigt__p_wxMimeTypesManager,
32586 _swigt__p_wxPyArtProvider,
32587 _swigt__p_wxPyTipProvider,
32588 _swigt__p_wxTipProvider,
32589 _swigt__p_wxJoystick,
32590 _swigt__p_wxSystemOptions,
32591 _swigt__p_wxPoint,
32592 _swigt__p_wxJoystickEvent,
32593 _swigt__p_wxCursor,
32594 _swigt__p_wxObject,
32595 _swigt__p_wxOutputStream,
32596 _swigt__p_wxDateTime,
32597 _swigt__p_wxPyDropSource,
32598 _swigt__p_unsigned_long,
32599 _swigt__p_wxKillError,
32600 _swigt__p_wxWindow,
32601 _swigt__p_wxString,
32602 _swigt__p_wxPyProcess,
32603 _swigt__p_wxBitmap,
32604 _swigt__p_wxConfig,
32605 _swigt__unsigned_int,
32606 _swigt__p_unsigned_int,
32607 _swigt__p_unsigned_char,
32608 _swigt__p_wxChar,
32609 _swigt__p_wxBusyInfo,
32610 _swigt__p_wxPyDropTarget,
32611 _swigt__p_wxPyTextDropTarget,
32612 _swigt__p_wxPyFileDropTarget,
32613 _swigt__p_wxProcessEvent,
32614 _swigt__p_wxPyLog,
32615 _swigt__p_wxLogNull,
32616 _swigt__p_wxColour,
32617 _swigt__p_wxPyTimer,
32618 _swigt__p_wxConfigPathChanger,
32619 _swigt__p_wxDateSpan,
32620 0
32621 };
32622
32623
32624 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32625
32626 static swig_const_info swig_const_table[] = {
32627 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32628 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32629 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32630 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32631 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32632 {0, 0, 0, 0.0, 0, 0}};
32633
32634 #ifdef __cplusplus
32635 }
32636 #endif
32637
32638
32639 #ifdef __cplusplus
32640 extern "C" {
32641 #endif
32642
32643 /* Python-specific SWIG API */
32644 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32645 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32646 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32647
32648 /* -----------------------------------------------------------------------------
32649 * global variable support code.
32650 * ----------------------------------------------------------------------------- */
32651
32652 typedef struct swig_globalvar {
32653 char *name; /* Name of global variable */
32654 PyObject *(*get_attr)(); /* Return the current value */
32655 int (*set_attr)(PyObject *); /* Set the value */
32656 struct swig_globalvar *next;
32657 } swig_globalvar;
32658
32659 typedef struct swig_varlinkobject {
32660 PyObject_HEAD
32661 swig_globalvar *vars;
32662 } swig_varlinkobject;
32663
32664 static PyObject *
32665 swig_varlink_repr(swig_varlinkobject *v) {
32666 v = v;
32667 return PyString_FromString("<Swig global variables>");
32668 }
32669
32670 static int
32671 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32672 swig_globalvar *var;
32673 flags = flags;
32674 fprintf(fp,"Swig global variables { ");
32675 for (var = v->vars; var; var=var->next) {
32676 fprintf(fp,"%s", var->name);
32677 if (var->next) fprintf(fp,", ");
32678 }
32679 fprintf(fp," }\n");
32680 return 0;
32681 }
32682
32683 static PyObject *
32684 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32685 swig_globalvar *var = v->vars;
32686 while (var) {
32687 if (strcmp(var->name,n) == 0) {
32688 return (*var->get_attr)();
32689 }
32690 var = var->next;
32691 }
32692 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32693 return NULL;
32694 }
32695
32696 static int
32697 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32698 swig_globalvar *var = v->vars;
32699 while (var) {
32700 if (strcmp(var->name,n) == 0) {
32701 return (*var->set_attr)(p);
32702 }
32703 var = var->next;
32704 }
32705 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32706 return 1;
32707 }
32708
32709 static PyTypeObject varlinktype = {
32710 PyObject_HEAD_INIT(0)
32711 0, /* Number of items in variable part (ob_size) */
32712 (char *)"swigvarlink", /* Type name (tp_name) */
32713 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32714 0, /* Itemsize (tp_itemsize) */
32715 0, /* Deallocator (tp_dealloc) */
32716 (printfunc) swig_varlink_print, /* Print (tp_print) */
32717 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32718 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32719 0, /* tp_compare */
32720 (reprfunc) swig_varlink_repr, /* tp_repr */
32721 0, /* tp_as_number */
32722 0, /* tp_as_sequence */
32723 0, /* tp_as_mapping */
32724 0, /* tp_hash */
32725 0, /* tp_call */
32726 0, /* tp_str */
32727 0, /* tp_getattro */
32728 0, /* tp_setattro */
32729 0, /* tp_as_buffer */
32730 0, /* tp_flags */
32731 0, /* tp_doc */
32732 #if PY_VERSION_HEX >= 0x02000000
32733 0, /* tp_traverse */
32734 0, /* tp_clear */
32735 #endif
32736 #if PY_VERSION_HEX >= 0x02010000
32737 0, /* tp_richcompare */
32738 0, /* tp_weaklistoffset */
32739 #endif
32740 #if PY_VERSION_HEX >= 0x02020000
32741 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32742 #endif
32743 #if PY_VERSION_HEX >= 0x02030000
32744 0, /* tp_del */
32745 #endif
32746 #ifdef COUNT_ALLOCS
32747 0,0,0,0 /* tp_alloc -> tp_next */
32748 #endif
32749 };
32750
32751 /* Create a variable linking object for use later */
32752 static PyObject *
32753 SWIG_Python_newvarlink(void) {
32754 swig_varlinkobject *result = 0;
32755 result = PyMem_NEW(swig_varlinkobject,1);
32756 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32757 result->ob_type = &varlinktype;
32758 result->vars = 0;
32759 result->ob_refcnt = 0;
32760 Py_XINCREF((PyObject *) result);
32761 return ((PyObject*) result);
32762 }
32763
32764 static void
32765 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32766 swig_varlinkobject *v;
32767 swig_globalvar *gv;
32768 v= (swig_varlinkobject *) p;
32769 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32770 gv->name = (char *) malloc(strlen(name)+1);
32771 strcpy(gv->name,name);
32772 gv->get_attr = get_attr;
32773 gv->set_attr = set_attr;
32774 gv->next = v->vars;
32775 v->vars = gv;
32776 }
32777
32778 /* -----------------------------------------------------------------------------
32779 * constants/methods manipulation
32780 * ----------------------------------------------------------------------------- */
32781
32782 /* Install Constants */
32783 static void
32784 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32785 PyObject *obj = 0;
32786 size_t i;
32787 for (i = 0; constants[i].type; i++) {
32788 switch(constants[i].type) {
32789 case SWIG_PY_INT:
32790 obj = PyInt_FromLong(constants[i].lvalue);
32791 break;
32792 case SWIG_PY_FLOAT:
32793 obj = PyFloat_FromDouble(constants[i].dvalue);
32794 break;
32795 case SWIG_PY_STRING:
32796 if (constants[i].pvalue) {
32797 obj = PyString_FromString((char *) constants[i].pvalue);
32798 } else {
32799 Py_INCREF(Py_None);
32800 obj = Py_None;
32801 }
32802 break;
32803 case SWIG_PY_POINTER:
32804 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32805 break;
32806 case SWIG_PY_BINARY:
32807 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32808 break;
32809 default:
32810 obj = 0;
32811 break;
32812 }
32813 if (obj) {
32814 PyDict_SetItemString(d,constants[i].name,obj);
32815 Py_DECREF(obj);
32816 }
32817 }
32818 }
32819
32820 /* -----------------------------------------------------------------------------*/
32821 /* Fix SwigMethods to carry the callback ptrs when needed */
32822 /* -----------------------------------------------------------------------------*/
32823
32824 static void
32825 SWIG_Python_FixMethods(PyMethodDef *methods,
32826 swig_const_info *const_table,
32827 swig_type_info **types,
32828 swig_type_info **types_initial) {
32829 size_t i;
32830 for (i = 0; methods[i].ml_name; ++i) {
32831 char *c = methods[i].ml_doc;
32832 if (c && (c = strstr(c, "swig_ptr: "))) {
32833 int j;
32834 swig_const_info *ci = 0;
32835 char *name = c + 10;
32836 for (j = 0; const_table[j].type; j++) {
32837 if (strncmp(const_table[j].name, name,
32838 strlen(const_table[j].name)) == 0) {
32839 ci = &(const_table[j]);
32840 break;
32841 }
32842 }
32843 if (ci) {
32844 size_t shift = (ci->ptype) - types;
32845 swig_type_info *ty = types_initial[shift];
32846 size_t ldoc = (c - methods[i].ml_doc);
32847 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32848 char *ndoc = (char*)malloc(ldoc + lptr + 10);
32849 char *buff = ndoc;
32850 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
32851 strncpy(buff, methods[i].ml_doc, ldoc);
32852 buff += ldoc;
32853 strncpy(buff, "swig_ptr: ", 10);
32854 buff += 10;
32855 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32856 methods[i].ml_doc = ndoc;
32857 }
32858 }
32859 }
32860 }
32861
32862 /* -----------------------------------------------------------------------------*
32863 * Initialize type list
32864 * -----------------------------------------------------------------------------*/
32865
32866 #if PY_MAJOR_VERSION < 2
32867 /* PyModule_AddObject function was introduced in Python 2.0. The following function
32868 is copied out of Python/modsupport.c in python version 2.3.4 */
32869 static int
32870 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
32871 {
32872 PyObject *dict;
32873 if (!PyModule_Check(m)) {
32874 PyErr_SetString(PyExc_TypeError,
32875 "PyModule_AddObject() needs module as first arg");
32876 return -1;
32877 }
32878 if (!o) {
32879 PyErr_SetString(PyExc_TypeError,
32880 "PyModule_AddObject() needs non-NULL value");
32881 return -1;
32882 }
32883
32884 dict = PyModule_GetDict(m);
32885 if (dict == NULL) {
32886 /* Internal error -- modules must have a dict! */
32887 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
32888 PyModule_GetName(m));
32889 return -1;
32890 }
32891 if (PyDict_SetItemString(dict, name, o))
32892 return -1;
32893 Py_DECREF(o);
32894 return 0;
32895 }
32896 #endif
32897
32898 static swig_type_info **
32899 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
32900 static PyMethodDef swig_empty_runtime_method_table[] = {
32901 {
32902 NULL, NULL, 0, NULL
32903 }
32904 };/* Sentinel */
32905
32906 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
32907 swig_empty_runtime_method_table);
32908 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
32909 if (pointer && module) {
32910 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
32911 }
32912 return type_list_handle;
32913 }
32914
32915 static swig_type_info **
32916 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
32917 swig_type_info **type_pointer;
32918
32919 /* first check if module already created */
32920 type_pointer = SWIG_Python_GetTypeListHandle();
32921 if (type_pointer) {
32922 return type_pointer;
32923 } else {
32924 /* create a new module and variable */
32925 return SWIG_Python_SetTypeListHandle(type_list_handle);
32926 }
32927 }
32928
32929 #ifdef __cplusplus
32930 }
32931 #endif
32932
32933 /* -----------------------------------------------------------------------------*
32934 * Partial Init method
32935 * -----------------------------------------------------------------------------*/
32936
32937 #ifdef SWIG_LINK_RUNTIME
32938 #ifdef __cplusplus
32939 extern "C"
32940 #endif
32941 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
32942 #endif
32943
32944 #ifdef __cplusplus
32945 extern "C"
32946 #endif
32947 SWIGEXPORT(void) SWIG_init(void) {
32948 static PyObject *SWIG_globals = 0;
32949 static int typeinit = 0;
32950 PyObject *m, *d;
32951 int i;
32952 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
32953
32954 /* Fix SwigMethods to carry the callback ptrs when needed */
32955 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
32956
32957 m = Py_InitModule((char *) SWIG_name, SwigMethods);
32958 d = PyModule_GetDict(m);
32959
32960 if (!typeinit) {
32961 #ifdef SWIG_LINK_RUNTIME
32962 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
32963 #else
32964 # ifndef SWIG_STATIC_RUNTIME
32965 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
32966 # endif
32967 #endif
32968 for (i = 0; swig_types_initial[i]; i++) {
32969 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
32970 }
32971 typeinit = 1;
32972 }
32973 SWIG_InstallConstants(d,swig_const_table);
32974
32975 {
32976 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
32977 }
32978 {
32979 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
32980 }
32981 {
32982 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
32983 }
32984 {
32985 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
32986 }
32987 {
32988 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
32989 }
32990 {
32991 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
32992 }
32993 {
32994 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
32995 }
32996 {
32997 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
32998 }
32999 {
33000 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33001 }
33002 {
33003 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33004 }
33005 {
33006 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33007 }
33008 {
33009 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33010 }
33011 {
33012 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33013 }
33014 {
33015 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33016 }
33017 {
33018 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33019 }
33020 {
33021 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33022 }
33023 {
33024 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33025 }
33026 {
33027 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33028 }
33029 {
33030 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33031 }
33032 {
33033 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33034 }
33035 {
33036 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33037 }
33038 {
33039 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33040 }
33041 {
33042 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33043 }
33044 {
33045 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33046 }
33047 {
33048 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33049 }
33050 {
33051 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33052 }
33053 {
33054 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33055 }
33056 {
33057 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33058 }
33059 {
33060 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33061 }
33062 {
33063 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33064 }
33065 {
33066 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33067 }
33068 {
33069 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33070 }
33071 {
33072 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33073 }
33074 {
33075 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33076 }
33077 {
33078 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33079 }
33080 {
33081 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33082 }
33083 {
33084 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33085 }
33086 {
33087 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33088 }
33089 {
33090 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33091 }
33092 {
33093 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33094 }
33095 {
33096 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33097 }
33098 {
33099 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33100 }
33101 {
33102 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33103 }
33104 {
33105 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33106 }
33107 {
33108 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33109 }
33110 {
33111 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33112 }
33113 {
33114 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33115 }
33116 {
33117 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33118 }
33119 {
33120 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33121 }
33122 {
33123 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33124 }
33125 {
33126 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33127 }
33128 {
33129 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33130 }
33131 {
33132 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33133 }
33134 {
33135 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33136 }
33137 {
33138 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33139 }
33140 {
33141 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33142 }
33143 {
33144 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33145 }
33146 {
33147 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33148 }
33149 {
33150 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33151 }
33152 {
33153 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33154 }
33155 {
33156 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33157 }
33158 {
33159 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33160 }
33161 {
33162 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33163 }
33164 {
33165 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33166 }
33167 {
33168 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33169 }
33170 {
33171 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33172 }
33173 {
33174 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33175 }
33176 {
33177 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33178 }
33179 {
33180 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33181 }
33182 {
33183 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33184 }
33185 {
33186 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33187 }
33188 {
33189 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33190 }
33191 {
33192 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33193 }
33194 {
33195 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33196 }
33197 {
33198 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33199 }
33200 {
33201 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33202 }
33203 {
33204 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33205 }
33206 {
33207 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33208 }
33209 {
33210 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33211 }
33212 {
33213 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33214 }
33215 {
33216 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33217 }
33218 {
33219 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33220 }
33221 {
33222 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33223 }
33224 {
33225 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33226 }
33227 {
33228 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33229 }
33230 {
33231 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33232 }
33233 {
33234 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33235 }
33236 {
33237 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33238 }
33239 {
33240 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33241 }
33242 {
33243 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33244 }
33245 {
33246 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33247 }
33248 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33249 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33250 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33251 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33252 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33253 {
33254 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33255 }
33256 {
33257 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33258 }
33259 {
33260 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33261 }
33262 {
33263 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33264 }
33265 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33266
33267 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33268
33269 {
33270 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33271 }
33272 {
33273 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33274 }
33275 {
33276 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33277 }
33278 {
33279 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33280 }
33281 {
33282 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33283 }
33284 {
33285 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33286 }
33287 {
33288 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33289 }
33290 {
33291 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33292 }
33293 {
33294 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33295 }
33296 {
33297 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33298 }
33299 {
33300 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33301 }
33302 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33303 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33304 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33305 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33306 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33307 {
33308 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33309 }
33310 {
33311 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33312 }
33313 {
33314 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33315 }
33316 {
33317 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33318 }
33319 {
33320 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33321 }
33322 {
33323 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33324 }
33325 {
33326 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33327 }
33328 {
33329 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33330 }
33331 {
33332 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33333 }
33334 {
33335 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33336 }
33337 {
33338 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33339 }
33340 {
33341 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33342 }
33343 {
33344 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33345 }
33346 {
33347 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33348 }
33349 {
33350 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33351 }
33352 {
33353 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33354 }
33355 {
33356 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33357 }
33358 {
33359 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33360 }
33361 {
33362 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33363 }
33364 {
33365 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33366 }
33367 {
33368 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33369 }
33370 {
33371 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33372 }
33373 {
33374 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33375 }
33376 {
33377 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33378 }
33379 {
33380 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33381 }
33382 {
33383 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33384 }
33385 {
33386 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33387 }
33388 {
33389 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33390 }
33391 {
33392 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33393 }
33394 {
33395 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33396 }
33397 {
33398 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33399 }
33400 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33401 {
33402 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33403 }
33404 {
33405 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33406 }
33407 {
33408 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33409 }
33410 {
33411 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33412 }
33413 {
33414 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33415 }
33416
33417 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33418
33419 {
33420 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33421 }
33422 {
33423 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33424 }
33425 {
33426 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33427 }
33428 {
33429 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33430 }
33431 {
33432 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33433 }
33434 {
33435 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33436 }
33437 {
33438 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33439 }
33440 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33441 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33442 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33443 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33444 {
33445 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33446 }
33447 {
33448 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33449 }
33450 {
33451 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33452 }
33453 {
33454 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33455 }
33456 {
33457 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33458 }
33459 {
33460 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33461 }
33462 {
33463 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33464 }
33465 {
33466 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33467 }
33468 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33469 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33470 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33471 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33472 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33473 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33474 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33475 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33476 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33477 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33478 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33479 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33480 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33481 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33482 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33483 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33484 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33485 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33486 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33487 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33488 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33489 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33490 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33491 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33492 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33493 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33494 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33495 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33496 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33497 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33498 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33499 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33500 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33501 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33502 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33503 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33504 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33505 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33506 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33507 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33508 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33509 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33510 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33511 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33512 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33513
33514 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33515
33516 {
33517 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33518 }
33519 {
33520 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33521 }
33522 {
33523 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33524 }
33525 {
33526 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33527 }
33528 {
33529 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33530 }
33531 {
33532 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33533 }
33534 {
33535 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33536 }
33537 {
33538 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33539 }
33540 {
33541 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33542 }
33543 SWIG_addvarlink(SWIG_globals,(char*)"DateFormatStr",_wrap_DateFormatStr_get, _wrap_DateFormatStr_set);
33544 SWIG_addvarlink(SWIG_globals,(char*)"TimeSpanFormatStr",_wrap_TimeSpanFormatStr_get, _wrap_TimeSpanFormatStr_set);
33545 {
33546 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33547 }
33548 {
33549 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33550 }
33551 {
33552 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33553 }
33554 {
33555 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33556 }
33557 {
33558 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33559 }
33560 {
33561 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33562 }
33563 {
33564 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33565 }
33566 {
33567 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33568 }
33569 {
33570 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33571 }
33572 {
33573 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33574 }
33575 {
33576 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33577 }
33578 {
33579 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33580 }
33581 {
33582 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33583 }
33584 {
33585 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33586 }
33587 {
33588 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33589 }
33590 {
33591 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33592 }
33593 {
33594 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33595 }
33596 {
33597 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33598 }
33599 {
33600 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33601 }
33602 {
33603 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33604 }
33605 {
33606 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33607 }
33608 {
33609 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33610 }
33611 {
33612 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33613 }
33614 {
33615 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33616 }
33617 {
33618 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33619 }
33620 {
33621 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33622 }
33623 {
33624 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33625 }
33626 {
33627 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33628 }
33629 {
33630 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33631 }
33632 {
33633 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33634 }
33635 {
33636 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33637 }
33638 {
33639 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33640 }
33641 {
33642 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33643 }
33644 {
33645 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33646 }
33647 {
33648 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33649 }
33650 {
33651 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33652 }
33653 {
33654 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33655 }
33656 {
33657 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33658 }
33659 {
33660 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33661 }
33662 {
33663 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33664 }
33665 {
33666 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33667 }
33668 {
33669 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33670 }
33671 {
33672 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33673 }
33674 {
33675 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33676 }
33677 {
33678 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33679 }
33680 {
33681 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33682 }
33683 {
33684 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33685 }
33686 {
33687 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33688 }
33689 {
33690 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33691 }
33692 {
33693 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33694 }
33695 {
33696 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33697 }
33698 {
33699 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33700 }
33701 {
33702 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33703 }
33704 {
33705 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33706 }
33707 {
33708 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33709 }
33710 {
33711 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33712 }
33713 {
33714 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33715 }
33716 {
33717 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33718 }
33719 {
33720 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33721 }
33722 {
33723 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33724 }
33725 {
33726 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33727 }
33728 {
33729 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33730 }
33731 {
33732 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33733 }
33734 {
33735 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33736 }
33737 {
33738 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33739 }
33740 {
33741 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33742 }
33743 {
33744 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33745 }
33746 {
33747 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33748 }
33749 {
33750 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33751 }
33752 {
33753 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33754 }
33755 {
33756 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33757 }
33758 {
33759 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33760 }
33761 {
33762 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33763 }
33764 {
33765 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
33766 }
33767 {
33768 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
33769 }
33770 {
33771 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
33778 }
33779 {
33780 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
33781 }
33782 {
33783 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
33784 }
33785 {
33786 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
33790 }
33791 {
33792 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
33793 }
33794 {
33795 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
33796 }
33797 {
33798 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
33799 }
33800 {
33801 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
33802 }
33803 {
33804 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
33805 }
33806 {
33807 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
33808 }
33809 {
33810 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
33811 }
33812 {
33813 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
33814 }
33815 {
33816 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
33817 }
33818 {
33819 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
33820 }
33821 {
33822 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
33823 }
33824 {
33825 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
33826 }
33827 {
33828 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
33829 }
33830 {
33831 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
33832 }
33833 {
33834 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
33835 }
33836 {
33837 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
33838 }
33839 {
33840 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
33841 }
33842 {
33843 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
33844 }
33845 {
33846 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
33847 }
33848 {
33849 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
33850 }
33851 {
33852 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
33853 }
33854 {
33855 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
33856 }
33857 {
33858 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
33859 }
33860 {
33861 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
33862 }
33863 {
33864 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
33865 }
33866 {
33867 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
33868 }
33869 {
33870 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
33871 }
33872 {
33873 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
33874 }
33875 {
33876 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
33877 }
33878 {
33879 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
33880 }
33881 {
33882 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
33883 }
33884 {
33885 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
33886 }
33887 {
33888 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
33889 }
33890 {
33891 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
33892 }
33893 {
33894 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
33895 }
33896 {
33897 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
33898 }
33899 {
33900 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
33901 }
33902 {
33903 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
33904 }
33905 {
33906 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
33907 }
33908 {
33909 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
33910 }
33911 {
33912 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
33913 }
33914 {
33915 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
33916 }
33917 {
33918 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
33919 }
33920 {
33921 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
33922 }
33923 {
33924 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
33925 }
33926 {
33927 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
33928 }
33929 {
33930 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
33931 }
33932 {
33933 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
33934 }
33935 {
33936 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
33937 }
33938 {
33939 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
33940 }
33941 {
33942 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
33943 }
33944 {
33945 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
33946 }
33947 {
33948 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
33949 }
33950 {
33951 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
33952 }
33953 {
33954 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
33955 }
33956 {
33957 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
33958 }
33959 {
33960 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
33961 }
33962 {
33963 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
33964 }
33965 {
33966 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
33967 }
33968 {
33969 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
33970 }
33971 {
33972 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
33973 }
33974 {
33975 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
33976 }
33977 {
33978 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
33979 }
33980 {
33981 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
33982 }
33983 {
33984 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
33985 }
33986 {
33987 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
33988 }
33989 {
33990 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
33991 }
33992 {
33993 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
33994 }
33995 {
33996 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
33997 }
33998 {
33999 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34000 }
34001 {
34002 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34003 }
34004 {
34005 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34006 }
34007 {
34008 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34009 }
34010 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34011 {
34012 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34013 }
34014 {
34015 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34016 }
34017 {
34018 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34019 }
34020 {
34021 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34022 }
34023 {
34024 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34025 }
34026 {
34027 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34028 }
34029 {
34030 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34031 }
34032 {
34033 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34034 }
34035 {
34036 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34037 }
34038 {
34039 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34040 }
34041 {
34042 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34043 }
34044 {
34045 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34046 }
34047 {
34048 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34049 }
34050 {
34051 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34052 }
34053 {
34054 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34055 }
34056 {
34057 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34058 }
34059 {
34060 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34061 }
34062 {
34063 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34064 }
34065 {
34066 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34067 }
34068 {
34069 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34070 }
34071 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34072 {
34073 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34074 }
34075 {
34076 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34077 }
34078 {
34079 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34080 }
34081 {
34082 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34083 }
34084 {
34085 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34086 }
34087 {
34088 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34089 }
34090 {
34091 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34092 }
34093 {
34094 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34095 }
34096 {
34097 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34098 }
34099 {
34100 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34101 }
34102 {
34103 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34104 }
34105 {
34106 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34107 }
34108
34109 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34110 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34111 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34112 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34113
34114 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34115 }
34116
wxWidgets (Impactor)