]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / gtk / _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_wxFileHistory swig_types[2]
1344 #define SWIGTYPE_p_wxLog swig_types[3]
1345 #define SWIGTYPE_p_wxMenu swig_types[4]
1346 #define SWIGTYPE_p_wxEvent swig_types[5]
1347 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[6]
1348 #define SWIGTYPE_p_wxConfigBase swig_types[7]
1349 #define SWIGTYPE_p_wxDisplay swig_types[8]
1350 #define SWIGTYPE_p_wxFileType swig_types[9]
1351 #define SWIGTYPE_p_wxLogGui swig_types[10]
1352 #define SWIGTYPE_p_wxFont swig_types[11]
1353 #define SWIGTYPE_p_wxDataFormat swig_types[12]
1354 #define SWIGTYPE_p_wxTimerEvent swig_types[13]
1355 #define SWIGTYPE_p_wxCaret swig_types[14]
1356 #define SWIGTYPE_ptrdiff_t swig_types[15]
1357 #define SWIGTYPE_std__ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_p_int swig_types[17]
1359 #define SWIGTYPE_p_wxSize swig_types[18]
1360 #define SWIGTYPE_p_wxClipboard swig_types[19]
1361 #define SWIGTYPE_p_wxStopWatch swig_types[20]
1362 #define SWIGTYPE_p_wxDC 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_wxSystemSettings swig_types[46]
1388 #define SWIGTYPE_p_wxFileConfig 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 /*@/opt/swig/share/swig/1.3.24/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 /*@/opt/swig/share/swig/1.3.24/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 long wxGetFreeMemory()
1661 { wxPyRaiseNotImplemented(); return 0; }
1662
1663
1664 SWIGINTERN int
1665 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1666 {
1667 long v = 0;
1668 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1669 SWIG_type_error("unsigned number", obj);
1670 }
1671 else if (val)
1672 *val = (unsigned long)v;
1673 return 1;
1674 }
1675
1676
1677 SWIGINTERNSHORT unsigned long
1678 SWIG_As_unsigned_SS_long(PyObject* obj)
1679 {
1680 unsigned long v;
1681 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1682 /*
1683 this is needed to make valgrind/purify happier.
1684 */
1685 memset((void*)&v, 0, sizeof(unsigned long));
1686 }
1687 return v;
1688 }
1689
1690
1691 SWIGINTERNSHORT int
1692 SWIG_Check_unsigned_SS_long(PyObject* obj)
1693 {
1694 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1695 }
1696
1697
1698 SWIGINTERNSHORT PyObject*
1699 SWIG_From_unsigned_SS_long(unsigned long value)
1700 {
1701 return (value > LONG_MAX) ?
1702 PyLong_FromUnsignedLong(value)
1703 : PyInt_FromLong((long)(value));
1704 }
1705
1706
1707 void wxWakeUpMainThread() {}
1708
1709
1710 bool wxThread_IsMain() {
1711 #ifdef WXP_WITH_THREAD
1712 return wxThread::IsMain();
1713 #else
1714 return true;
1715 #endif
1716 }
1717
1718
1719 int wxCaret_GetBlinkTime() {
1720 return wxCaret::GetBlinkTime();
1721 }
1722
1723 void wxCaret_SetBlinkTime(int milliseconds) {
1724 wxCaret::SetBlinkTime(milliseconds);
1725 }
1726
1727
1728 #include <wx/snglinst.h>
1729
1730
1731 #ifdef __WXMSW__
1732 #include <wx/msw/private.h>
1733 #include <wx/dynload.h>
1734 #endif
1735
1736
1737
1738 void wxDrawWindowOnDC(wxWindow* window, const wxDC& dc, int method)
1739 {
1740 #ifdef __WXMSW__
1741
1742 switch (method)
1743 {
1744 case 1:
1745 // This one only partially works. Appears to be an undocumented
1746 // "standard" convention that not all widgets adhear to. For
1747 // example, for some widgets backgrounds or non-client areas may
1748 // not be painted.
1749 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1750 break;
1751
1752 case 2:
1753 // This one works much better, except for on XP. On Win2k nearly
1754 // all widgets and their children are captured correctly[**]. On
1755 // XP with Themes activated most native widgets draw only
1756 // partially, if at all. Without themes it works just like on
1757 // Win2k.
1758 //
1759 // ** For example the radio buttons in a wxRadioBox are not its
1760 // children by default, but you can capture it via the panel
1761 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1762 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1763 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1764 PRF_ERASEBKGND | PRF_OWNED );
1765 break;
1766
1767 case 3:
1768 // This one is only defined in the latest SDK and is only
1769 // available on XP. MSDN says it is similar to sending WM_PRINT
1770 // so I expect that it will work similar to the above. Since it
1771 // is avaialble only on XP, it can't be compiled like this and
1772 // will have to be loaded dynamically.
1773 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1774
1775 // fall through
1776
1777 case 4:
1778 // Use PrintWindow if available, or fallback to WM_PRINT
1779 // otherwise. Unfortunately using PrintWindow is even worse than
1780 // WM_PRINT. For most native widgets nothing is drawn to the dc
1781 // at all, with or without Themes.
1782 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1783 static bool s_triedToLoad = false;
1784 static PrintWindow_t pfnPrintWindow = NULL;
1785 if ( !s_triedToLoad )
1786 {
1787
1788 s_triedToLoad = true;
1789 wxDynamicLibrary dllUser32(_T("user32.dll"));
1790 if ( dllUser32.IsLoaded() )
1791 {
1792 wxLogNull nolog; // Don't report errors here
1793 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1794 }
1795 }
1796 if (pfnPrintWindow)
1797 {
1798 printf("Using PrintWindow\n");
1799 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1800 }
1801 else
1802 {
1803 printf("Using WM_PRINT\n");
1804 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1805 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN | PRF_ERASEBKGND | PRF_OWNED );
1806 }
1807 }
1808 #endif
1809 }
1810
1811
1812
1813 #include <wx/tipdlg.h>
1814
1815
1816 class wxPyTipProvider : public wxTipProvider {
1817 public:
1818 wxPyTipProvider(size_t currentTip)
1819 : wxTipProvider(currentTip) {}
1820
1821 DEC_PYCALLBACK_STRING__pure(GetTip);
1822 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1823 PYPRIVATE;
1824 };
1825
1826 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1827 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1828
1829
1830 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1831
1832 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1833
1834 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1835 : wxTimer(owner, id)
1836 {
1837 if (owner == NULL) SetOwner(this);
1838 }
1839
1840
1841 void wxPyTimer::Notify() {
1842 bool found;
1843 bool blocked = wxPyBeginBlockThreads();
1844 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1845 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1846 wxPyEndBlockThreads(blocked);
1847 if (! found)
1848 wxTimer::Notify();
1849 }
1850 void wxPyTimer::base_Notify() {
1851 wxTimer::Notify();
1852 }
1853
1854
1855
1856 SWIGINTERN PyObject *
1857 SWIG_FromCharPtr(const char* cptr)
1858 {
1859 if (cptr) {
1860 size_t size = strlen(cptr);
1861 if (size > INT_MAX) {
1862 return SWIG_NewPointerObj((char*)(cptr),
1863 SWIG_TypeQuery("char *"), 0);
1864 } else {
1865 if (size != 0) {
1866 return PyString_FromStringAndSize(cptr, size);
1867 } else {
1868 return PyString_FromString(cptr);
1869 }
1870 }
1871 }
1872 Py_INCREF(Py_None);
1873 return Py_None;
1874 }
1875
1876
1877 SWIGINTERNSHORT int
1878 SWIG_CheckUnsignedLongInRange(unsigned long value,
1879 unsigned long max_value,
1880 const char *errmsg)
1881 {
1882 if (value > max_value) {
1883 if (errmsg) {
1884 PyErr_Format(PyExc_OverflowError,
1885 "value %lu is greater than '%s' minimum %lu",
1886 value, errmsg, max_value);
1887 }
1888 return 0;
1889 }
1890 return 1;
1891 }
1892
1893
1894 #if UINT_MAX != ULONG_MAX
1895 SWIGINTERN int
1896 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1897 {
1898 const char* errmsg = val ? "unsigned int" : (char*)0;
1899 unsigned long v;
1900 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1901 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1902 if (val) *val = (unsigned int)(v);
1903 return 1;
1904 }
1905 } else {
1906 PyErr_Clear();
1907 }
1908 if (val) {
1909 SWIG_type_error(errmsg, obj);
1910 }
1911 return 0;
1912 }
1913 #else
1914 SWIGINTERNSHORT unsigned int
1915 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1916 {
1917 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1918 }
1919 #endif
1920
1921
1922 SWIGINTERNSHORT unsigned int
1923 SWIG_As_unsigned_SS_int(PyObject* obj)
1924 {
1925 unsigned int v;
1926 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1927 /*
1928 this is needed to make valgrind/purify happier.
1929 */
1930 memset((void*)&v, 0, sizeof(unsigned int));
1931 }
1932 return v;
1933 }
1934
1935
1936 SWIGINTERNSHORT int
1937 SWIG_Check_unsigned_SS_int(PyObject* obj)
1938 {
1939 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1940 }
1941
1942 static wxString Log_TimeStamp(){
1943 wxString msg;
1944 wxLog::TimeStamp(&msg);
1945 return msg;
1946 }
1947 static void wxLog_Destroy(wxLog *self){ delete self; }
1948 // Make somce wrappers that double any % signs so they are 'escaped'
1949 void wxPyLogFatalError(const wxString& msg)
1950 {
1951 wxString m(msg);
1952 m.Replace(wxT("%"), wxT("%%"));
1953 wxLogFatalError(m);
1954 }
1955
1956 void wxPyLogError(const wxString& msg)
1957 {
1958 wxString m(msg);
1959 m.Replace(wxT("%"), wxT("%%"));
1960 wxLogError(m);
1961 }
1962
1963 void wxPyLogWarning(const wxString& msg)
1964 {
1965 wxString m(msg);
1966 m.Replace(wxT("%"), wxT("%%"));
1967 wxLogWarning(m);
1968 }
1969
1970 void wxPyLogMessage(const wxString& msg)
1971 {
1972 wxString m(msg);
1973 m.Replace(wxT("%"), wxT("%%"));
1974 wxLogMessage(m);
1975 }
1976
1977 void wxPyLogInfo(const wxString& msg)
1978 {
1979 wxString m(msg);
1980 m.Replace(wxT("%"), wxT("%%"));
1981 wxLogInfo(m);
1982 }
1983
1984 void wxPyLogDebug(const wxString& msg)
1985 {
1986 wxString m(msg);
1987 m.Replace(wxT("%"), wxT("%%"));
1988 wxLogDebug(m);
1989 }
1990
1991 void wxPyLogVerbose(const wxString& msg)
1992 {
1993 wxString m(msg);
1994 m.Replace(wxT("%"), wxT("%%"));
1995 wxLogVerbose(m);
1996 }
1997
1998 void wxPyLogStatus(const wxString& msg)
1999 {
2000 wxString m(msg);
2001 m.Replace(wxT("%"), wxT("%%"));
2002 wxLogStatus(m);
2003 }
2004
2005 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2006 {
2007 wxString m(msg);
2008 m.Replace(wxT("%"), wxT("%%"));
2009 wxLogStatus(pFrame, m);
2010 }
2011
2012 void wxPyLogSysError(const wxString& msg)
2013 {
2014 wxString m(msg);
2015 m.Replace(wxT("%"), wxT("%%"));
2016 wxLogSysError(m);
2017 }
2018
2019 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2020 {
2021 wxString m(msg);
2022 m.Replace(wxT("%"), wxT("%%"));
2023 wxLogGeneric(level, m);
2024 }
2025
2026 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2027 {
2028 wxString m(msg);
2029 m.Replace(wxT("%"), wxT("%%"));
2030 wxLogTrace(mask, m);
2031 }
2032
2033 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2034 {
2035 wxString m(msg);
2036 m.Replace(wxT("%"), wxT("%%"));
2037 wxLogTrace(mask, m);
2038 }
2039
2040
2041
2042 // A wxLog class that can be derived from in wxPython
2043 class wxPyLog : public wxLog {
2044 public:
2045 wxPyLog() : wxLog() {}
2046
2047 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2048 bool found;
2049 bool blocked = wxPyBeginBlockThreads();
2050 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2051 PyObject* s = wx2PyString(szString);
2052 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2053 Py_DECREF(s);
2054 }
2055 wxPyEndBlockThreads(blocked);
2056 if (! found)
2057 wxLog::DoLog(level, szString, t);
2058 }
2059
2060 virtual void DoLogString(const wxChar *szString, time_t t) {
2061 bool found;
2062 bool blocked = wxPyBeginBlockThreads();
2063 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2064 PyObject* s = wx2PyString(szString);
2065 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2066 Py_DECREF(s);
2067 }
2068 wxPyEndBlockThreads(blocked);
2069 if (! found)
2070 wxLog::DoLogString(szString, t);
2071 }
2072
2073 PYPRIVATE;
2074 };
2075
2076
2077
2078
2079 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2080
2081
2082 #include <wx/joystick.h>
2083
2084
2085 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2086 // A C++ stub class for wxJoystick for platforms that don't have it.
2087 class wxJoystick : public wxObject {
2088 public:
2089 wxJoystick(int joystick = wxJOYSTICK1) {
2090 bool blocked = wxPyBeginBlockThreads();
2091 PyErr_SetString(PyExc_NotImplementedError,
2092 "wxJoystick is not available on this platform.");
2093 wxPyEndBlockThreads(blocked);
2094 }
2095 wxPoint GetPosition() { return wxPoint(-1,-1); }
2096 int GetZPosition() { return -1; }
2097 int GetButtonState() { return -1; }
2098 int GetPOVPosition() { return -1; }
2099 int GetPOVCTSPosition() { return -1; }
2100 int GetRudderPosition() { return -1; }
2101 int GetUPosition() { return -1; }
2102 int GetVPosition() { return -1; }
2103 int GetMovementThreshold() { return -1; }
2104 void SetMovementThreshold(int threshold) {}
2105
2106 bool IsOk(void) { return false; }
2107 int GetNumberJoysticks() { return -1; }
2108 int GetManufacturerId() { return -1; }
2109 int GetProductId() { return -1; }
2110 wxString GetProductName() { return wxEmptyString; }
2111 int GetXMin() { return -1; }
2112 int GetYMin() { return -1; }
2113 int GetZMin() { return -1; }
2114 int GetXMax() { return -1; }
2115 int GetYMax() { return -1; }
2116 int GetZMax() { return -1; }
2117 int GetNumberButtons() { return -1; }
2118 int GetNumberAxes() { return -1; }
2119 int GetMaxButtons() { return -1; }
2120 int GetMaxAxes() { return -1; }
2121 int GetPollingMin() { return -1; }
2122 int GetPollingMax() { return -1; }
2123 int GetRudderMin() { return -1; }
2124 int GetRudderMax() { return -1; }
2125 int GetUMin() { return -1; }
2126 int GetUMax() { return -1; }
2127 int GetVMin() { return -1; }
2128 int GetVMax() { return -1; }
2129
2130 bool HasRudder() { return false; }
2131 bool HasZ() { return false; }
2132 bool HasU() { return false; }
2133 bool HasV() { return false; }
2134 bool HasPOV() { return false; }
2135 bool HasPOV4Dir() { return false; }
2136 bool HasPOVCTS() { return false; }
2137
2138 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2139 bool ReleaseCapture() { return false; }
2140 };
2141 #endif
2142
2143
2144 #include <wx/sound.h>
2145
2146
2147 #if !wxUSE_SOUND
2148 // A C++ stub class for wxWave for platforms that don't have it.
2149 class wxSound : public wxObject
2150 {
2151 public:
2152 wxSound() {
2153 bool blocked = wxPyBeginBlockThreads();
2154 PyErr_SetString(PyExc_NotImplementedError,
2155 "wxSound is not available on this platform.");
2156 wxPyEndBlockThreads(blocked);
2157 }
2158 wxSound(const wxString&/*, bool*/) {
2159 bool blocked = wxPyBeginBlockThreads();
2160 PyErr_SetString(PyExc_NotImplementedError,
2161 "wxSound is not available on this platform.");
2162 wxPyEndBlockThreads(blocked);
2163 }
2164 wxSound(int, const wxByte*) {
2165 bool blocked = wxPyBeginBlockThreads();
2166 PyErr_SetString(PyExc_NotImplementedError,
2167 "wxSound is not available on this platform.");
2168 wxPyEndBlockThreads(blocked);
2169 }
2170
2171 ~wxSound() {};
2172
2173 bool Create(const wxString&/*, bool*/) { return false; }
2174 bool Create(int, const wxByte*) { return false; };
2175 bool IsOk() { return false; };
2176 bool Play(unsigned) const { return false; }
2177 static bool Play(const wxString&, unsigned) { return false; }
2178 static void Stop() {}
2179 };
2180
2181 #endif
2182
2183 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2184 if (fileName.Length() == 0)
2185 return new wxSound;
2186 else
2187 return new wxSound(fileName);
2188 }
2189 static wxSound *new_wxSound(PyObject *data){
2190 unsigned char* buffer; int size;
2191 wxSound *sound = NULL;
2192
2193 bool blocked = wxPyBeginBlockThreads();
2194 if (!PyArg_Parse(data, "t#", &buffer, &size))
2195 goto done;
2196 sound = new wxSound(size, buffer);
2197 done:
2198 wxPyEndBlockThreads(blocked);
2199 return sound;
2200 }
2201 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2202 #ifndef __WXMAC__
2203 unsigned char* buffer;
2204 int size;
2205 bool rv = false;
2206
2207 bool blocked = wxPyBeginBlockThreads();
2208 if (!PyArg_Parse(data, "t#", &buffer, &size))
2209 goto done;
2210 rv = self->Create(size, buffer);
2211 done:
2212 wxPyEndBlockThreads(blocked);
2213 return rv;
2214 #else
2215 bool blocked = wxPyBeginBlockThreads();
2216 PyErr_SetString(PyExc_NotImplementedError,
2217 "Create from data is not available on this platform.");
2218 wxPyEndBlockThreads(blocked);
2219 return false;
2220 #endif
2221 }
2222
2223 #include <wx/mimetype.h>
2224
2225 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2226 wxString str;
2227 if (self->GetMimeType(&str))
2228 return wx2PyString(str);
2229 else
2230 RETURN_NONE();
2231 }
2232 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2233 wxArrayString arr;
2234 if (self->GetMimeTypes(arr))
2235 return wxArrayString2PyList_helper(arr);
2236 else
2237 RETURN_NONE();
2238 }
2239 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2240 wxArrayString arr;
2241 if (self->GetExtensions(arr))
2242 return wxArrayString2PyList_helper(arr);
2243 else
2244 RETURN_NONE();
2245 }
2246 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2247 wxIconLocation loc;
2248 if (self->GetIcon(&loc))
2249 return new wxIcon(loc);
2250 else
2251 return NULL;
2252 }
2253 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2254 wxIconLocation loc;
2255 if (self->GetIcon(&loc)) {
2256 wxString iconFile = loc.GetFileName();
2257 int iconIndex = -1;
2258
2259
2260
2261 // Make a tuple and put the values in it
2262 bool blocked = wxPyBeginBlockThreads();
2263 PyObject* tuple = PyTuple_New(3);
2264 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2265 wxT("wxIcon"), true));
2266 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2267 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2268 wxPyEndBlockThreads(blocked);
2269 return tuple;
2270 }
2271 else
2272 RETURN_NONE();
2273 }
2274 static PyObject *wxFileType_GetDescription(wxFileType *self){
2275 wxString str;
2276 if (self->GetDescription(&str))
2277 return wx2PyString(str);
2278 else
2279 RETURN_NONE();
2280 }
2281 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2282 wxString str;
2283 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2284 return wx2PyString(str);
2285 else
2286 RETURN_NONE();
2287 }
2288 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2289 wxString str;
2290 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2291 return wx2PyString(str);
2292 else
2293 RETURN_NONE();
2294 }
2295 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2296 wxArrayString verbs;
2297 wxArrayString commands;
2298 if (self->GetAllCommands(&verbs, &commands,
2299 wxFileType::MessageParameters(filename, mimetype))) {
2300 bool blocked = wxPyBeginBlockThreads();
2301 PyObject* tuple = PyTuple_New(2);
2302 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2303 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2304 wxPyEndBlockThreads(blocked);
2305 return tuple;
2306 }
2307 else
2308 RETURN_NONE();
2309 }
2310 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2311 return wxFileType::ExpandCommand(command,
2312 wxFileType::MessageParameters(filename, mimetype));
2313 }
2314 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2315 wxArrayString arr;
2316 self->EnumAllFileTypes(arr);
2317 return wxArrayString2PyList_helper(arr);
2318 }
2319
2320 #include <wx/artprov.h>
2321
2322 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2323 static const wxString wxPyART_MENU(wxART_MENU);
2324 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2325 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2326 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2327 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2328 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2329 static const wxString wxPyART_OTHER(wxART_OTHER);
2330 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2331 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2332 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2333 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2334 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2335 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2336 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2337 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2338 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2339 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2340 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2341 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2342 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2343 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2344 static const wxString wxPyART_PRINT(wxART_PRINT);
2345 static const wxString wxPyART_HELP(wxART_HELP);
2346 static const wxString wxPyART_TIP(wxART_TIP);
2347 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2348 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2349 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2350 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2351 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2352 static const wxString wxPyART_CDROM(wxART_CDROM);
2353 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2354 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2355 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2356 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2357 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2358 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2359 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2360 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2361 static const wxString wxPyART_ERROR(wxART_ERROR);
2362 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2363 static const wxString wxPyART_WARNING(wxART_WARNING);
2364 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2365 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2366 // Python aware wxArtProvider
2367 class wxPyArtProvider : public wxArtProvider {
2368 public:
2369
2370 virtual wxBitmap CreateBitmap(const wxArtID& id,
2371 const wxArtClient& client,
2372 const wxSize& size) {
2373 wxBitmap rval = wxNullBitmap;
2374 bool blocked = wxPyBeginBlockThreads();
2375 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2376 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2377 PyObject* ro;
2378 wxBitmap* ptr;
2379 PyObject* s1, *s2;
2380 s1 = wx2PyString(id);
2381 s2 = wx2PyString(client);
2382 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2383 Py_DECREF(so);
2384 Py_DECREF(s1);
2385 Py_DECREF(s2);
2386 if (ro) {
2387 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2388 rval = *ptr;
2389 Py_DECREF(ro);
2390 }
2391 }
2392 wxPyEndBlockThreads(blocked);
2393 return rval;
2394 }
2395
2396 PYPRIVATE;
2397 };
2398
2399 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2400
2401
2402
2403 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2404 PyObject* ret = PyTuple_New(3);
2405 if (ret) {
2406 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2407 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2408 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2409 }
2410 return ret;
2411 }
2412
2413 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2414 bool cont;
2415 long index = 0;
2416 wxString value;
2417
2418 cont = self->GetFirstGroup(value, index);
2419 return __EnumerationHelper(cont, value, index);
2420 }
2421 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2422 bool cont;
2423 wxString value;
2424
2425 cont = self->GetNextGroup(value, index);
2426 return __EnumerationHelper(cont, value, index);
2427 }
2428 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2429 bool cont;
2430 long index = 0;
2431 wxString value;
2432
2433 cont = self->GetFirstEntry(value, index);
2434 return __EnumerationHelper(cont, value, index);
2435 }
2436 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2437 bool cont;
2438 wxString value;
2439
2440 cont = self->GetNextEntry(value, index);
2441 return __EnumerationHelper(cont, value, index);
2442 }
2443 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2444 long rv;
2445 self->Read(key, &rv, defaultVal);
2446 return rv;
2447 }
2448
2449 SWIGINTERN int
2450 SWIG_AsVal_double(PyObject *obj, double* val)
2451 {
2452 if (PyNumber_Check(obj)) {
2453 if (val) *val = PyFloat_AsDouble(obj);
2454 return 1;
2455 }
2456 else {
2457 SWIG_type_error("number", obj);
2458 }
2459 return 0;
2460 }
2461
2462
2463 SWIGINTERNSHORT double
2464 SWIG_As_double(PyObject* obj)
2465 {
2466 double v;
2467 if (!SWIG_AsVal_double(obj, &v)) {
2468 /*
2469 this is needed to make valgrind/purify happier.
2470 */
2471 memset((void*)&v, 0, sizeof(double));
2472 }
2473 return v;
2474 }
2475
2476
2477 SWIGINTERNSHORT int
2478 SWIG_Check_double(PyObject* obj)
2479 {
2480 return SWIG_AsVal_double(obj, (double*)0);
2481 }
2482
2483 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2484 double rv;
2485 self->Read(key, &rv, defaultVal);
2486 return rv;
2487 }
2488
2489 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2490 #define SWIG_From_double PyFloat_FromDouble
2491 /*@@*/
2492
2493 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2494 bool rv;
2495 self->Read(key, &rv, defaultVal);
2496 return rv;
2497 }
2498
2499 #include <wx/datetime.h>
2500
2501
2502 static const wxString wxPyDateFormatStr(wxT("%c"));
2503 static const wxString wxPyTimeSpanFormatStr(wxT("%H:%M:%S"));
2504
2505 #define LOCAL_TZ wxDateTime::Local
2506
2507
2508 #if UINT_MAX < LONG_MAX
2509 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2510 #define SWIG_From_unsigned_SS_int SWIG_From_long
2511 /*@@*/
2512 #else
2513 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2514 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2515 /*@@*/
2516 #endif
2517
2518 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2519 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2520 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2521 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2522 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2523 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2524 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2525 return (*self < *other);
2526 }
2527 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2528 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2529 return (*self <= *other);
2530 }
2531 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2532 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2533 return (*self > *other);
2534 }
2535 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2536 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2537 return (*self >= *other);
2538 }
2539 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2540 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2541 return (*self == *other);
2542 }
2543 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2544 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2545 return (*self != *other);
2546 }
2547 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2548 const wxChar* rv;
2549 const wxChar* _date = date;
2550 rv = self->ParseRfc822Date(_date);
2551 if (rv == NULL) return -1;
2552 return rv - _date;
2553 }
2554 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDateFormatStr,wxDateTime const &dateDef=wxDefaultDateTime){
2555 const wxChar* rv;
2556 const wxChar* _date = date;
2557 rv = self->ParseFormat(_date, format, dateDef);
2558 if (rv == NULL) return -1;
2559 return rv - _date;
2560 }
2561 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2562 const wxChar* rv;
2563 const wxChar* _datetime = datetime;
2564 rv = self->ParseDateTime(_datetime);
2565 if (rv == NULL) return -1;
2566 return rv - _datetime;
2567 }
2568 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2569 const wxChar* rv;
2570 const wxChar* _date = date;
2571 rv = self->ParseDate(_date);
2572 if (rv == NULL) return -1;
2573 return rv - _date;
2574 }
2575 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2576 const wxChar* rv;
2577 const wxChar* _time = time;
2578 rv = self->ParseTime(_time);
2579 if (rv == NULL) return -1;
2580 return rv - _time;
2581 }
2582 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2583 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2584 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2585 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2586 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2587 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2588 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2589 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2590 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2591 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2592 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2593 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2594 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2595 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2596 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2597 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2598
2599 #include <wx/dataobj.h>
2600
2601 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2602 size_t count = self->GetFormatCount(dir);
2603 wxDataFormat* formats = new wxDataFormat[count];
2604 self->GetAllFormats(formats, dir);
2605
2606 bool blocked = wxPyBeginBlockThreads();
2607 PyObject* list = PyList_New(count);
2608 for (size_t i=0; i<count; i++) {
2609 wxDataFormat* format = new wxDataFormat(formats[i]);
2610 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2611 PyList_Append(list, obj);
2612 Py_DECREF(obj);
2613 }
2614 wxPyEndBlockThreads(blocked);
2615 delete [] formats;
2616 return list;
2617 }
2618 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2619 PyObject* rval = NULL;
2620 size_t size = self->GetDataSize(format);
2621 bool blocked = wxPyBeginBlockThreads();
2622 if (size) {
2623 char* buf = new char[size];
2624 if (self->GetDataHere(format, buf))
2625 rval = PyString_FromStringAndSize(buf, size);
2626 delete [] buf;
2627 }
2628 if (! rval) {
2629 rval = Py_None;
2630 Py_INCREF(rval);
2631 }
2632 wxPyEndBlockThreads(blocked);
2633 return rval;
2634 }
2635 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2636 bool rval;
2637 bool blocked = wxPyBeginBlockThreads();
2638 if (PyString_Check(data)) {
2639 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2640 }
2641 else {
2642 // raise a TypeError if not a string
2643 PyErr_SetString(PyExc_TypeError, "String expected.");
2644 rval = false;
2645 }
2646 wxPyEndBlockThreads(blocked);
2647 return rval;
2648 }
2649 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2650 PyObject* rval = NULL;
2651 size_t size = self->GetDataSize();
2652 bool blocked = wxPyBeginBlockThreads();
2653 if (size) {
2654 char* buf = new char[size];
2655 if (self->GetDataHere(buf))
2656 rval = PyString_FromStringAndSize(buf, size);
2657 delete [] buf;
2658 }
2659 if (! rval) {
2660 rval = Py_None;
2661 Py_INCREF(rval);
2662 }
2663 wxPyEndBlockThreads(blocked);
2664 return rval;
2665 }
2666 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2667 bool rval;
2668 bool blocked = wxPyBeginBlockThreads();
2669 if (PyString_Check(data)) {
2670 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2671 }
2672 else {
2673 // raise a TypeError if not a string
2674 PyErr_SetString(PyExc_TypeError, "String expected.");
2675 rval = false;
2676 }
2677 wxPyEndBlockThreads(blocked);
2678 return rval;
2679 }
2680 // Create a new class for wxPython to use
2681 class wxPyDataObjectSimple : public wxDataObjectSimple {
2682 public:
2683 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2684 : wxDataObjectSimple(format) {}
2685
2686 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2687 bool GetDataHere(void *buf) const;
2688 bool SetData(size_t len, const void *buf) const;
2689 PYPRIVATE;
2690 };
2691
2692 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2693
2694 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2695 // We need to get the data for this object and write it to buf. I think
2696 // the best way to do this for wxPython is to have the Python method
2697 // return either a string or None and then act appropriately with the
2698 // C++ version.
2699
2700 bool rval = false;
2701 bool blocked = wxPyBeginBlockThreads();
2702 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2703 PyObject* ro;
2704 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2705 if (ro) {
2706 rval = (ro != Py_None && PyString_Check(ro));
2707 if (rval)
2708 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2709 Py_DECREF(ro);
2710 }
2711 }
2712 wxPyEndBlockThreads(blocked);
2713 return rval;
2714 }
2715
2716 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2717 // For this one we simply need to make a string from buf and len
2718 // and send it to the Python method.
2719 bool rval = false;
2720 bool blocked = wxPyBeginBlockThreads();
2721 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2722 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2723 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2724 Py_DECREF(data);
2725 }
2726 wxPyEndBlockThreads(blocked);
2727 return rval;
2728 }
2729
2730 // Create a new class for wxPython to use
2731 class wxPyTextDataObject : public wxTextDataObject {
2732 public:
2733 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2734 : wxTextDataObject(text) {}
2735
2736 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2737 DEC_PYCALLBACK_STRING__const(GetText);
2738 DEC_PYCALLBACK__STRING(SetText);
2739 PYPRIVATE;
2740 };
2741
2742 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2743 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2744 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2745
2746
2747 // Create a new class for wxPython to use
2748 class wxPyBitmapDataObject : public wxBitmapDataObject {
2749 public:
2750 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2751 : wxBitmapDataObject(bitmap) {}
2752
2753 wxBitmap GetBitmap() const;
2754 void SetBitmap(const wxBitmap& bitmap);
2755 PYPRIVATE;
2756 };
2757
2758 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2759 wxBitmap* rval = &wxNullBitmap;
2760 bool blocked = wxPyBeginBlockThreads();
2761 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2762 PyObject* ro;
2763 wxBitmap* ptr;
2764 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2765 if (ro) {
2766 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2767 rval = ptr;
2768 Py_DECREF(ro);
2769 }
2770 }
2771 wxPyEndBlockThreads(blocked);
2772 return *rval;
2773 }
2774
2775 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2776 bool blocked = wxPyBeginBlockThreads();
2777 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2778 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2779 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2780 Py_DECREF(bo);
2781 }
2782 wxPyEndBlockThreads(blocked);
2783 }
2784
2785 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2786 bool rval;
2787 bool blocked = wxPyBeginBlockThreads();
2788 if (PyString_Check(data)) {
2789 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2790 }
2791 else {
2792 // raise a TypeError if not a string
2793 PyErr_SetString(PyExc_TypeError, "String expected.");
2794 rval = false;
2795 }
2796 wxPyEndBlockThreads(blocked);
2797 return rval;
2798 }
2799 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2800 PyObject* obj;
2801 bool blocked = wxPyBeginBlockThreads();
2802 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2803 wxPyEndBlockThreads(blocked);
2804 return obj;
2805 }
2806
2807 class wxMetafileDataObject : public wxDataObjectSimple
2808 {
2809 public:
2810 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
2811 };
2812
2813
2814 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2815
2816
2817 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2818 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2819 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2820 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2821 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2822
2823
2824 class wxPyTextDropTarget : public wxTextDropTarget {
2825 public:
2826 wxPyTextDropTarget() {}
2827
2828 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2829
2830 DEC_PYCALLBACK__(OnLeave);
2831 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2832 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2833 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2834 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2835
2836 PYPRIVATE;
2837 };
2838
2839 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2840 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2841 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2842 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2843 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2844 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2845
2846
2847
2848 class wxPyFileDropTarget : public wxFileDropTarget {
2849 public:
2850 wxPyFileDropTarget() {}
2851
2852 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2853
2854 DEC_PYCALLBACK__(OnLeave);
2855 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2856 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2857 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2858 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2859
2860 PYPRIVATE;
2861 };
2862
2863 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2864 const wxArrayString& filenames) {
2865 bool rval = false;
2866 bool blocked = wxPyBeginBlockThreads();
2867 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2868 PyObject* list = wxArrayString2PyList_helper(filenames);
2869 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2870 Py_DECREF(list);
2871 }
2872 wxPyEndBlockThreads(blocked);
2873 return rval;
2874 }
2875
2876
2877
2878 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2879 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2880 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2881 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2882 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2883
2884
2885
2886
2887 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2888
2889 #include <wx/display.h>
2890
2891 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2892 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2893
2894 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2895 #if !wxUSE_DISPLAY
2896 #include <wx/dynarray.h>
2897 #include <wx/vidmode.h>
2898
2899 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2900 #include "wx/arrimpl.cpp"
2901 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2902 const wxVideoMode wxDefaultVideoMode;
2903
2904 class wxDisplay
2905 {
2906 public:
2907 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2908 ~wxDisplay() {}
2909
2910 static size_t GetCount()
2911 { wxPyRaiseNotImplemented(); return 0; }
2912
2913 static int GetFromPoint(const wxPoint& pt)
2914 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2915 static int GetFromWindow(wxWindow *window)
2916 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2917
2918 virtual bool IsOk() const { return false; }
2919 virtual wxRect GetGeometry() const { wxRect r; return r; }
2920 virtual wxString GetName() const { return wxEmptyString; }
2921 bool IsPrimary() const { return false; }
2922
2923 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2924 { wxArrayVideoModes a; return a; }
2925
2926 virtual wxVideoMode GetCurrentMode() const
2927 { return wxDefaultVideoMode; }
2928
2929 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2930 { return false; }
2931
2932 void ResetMode() {}
2933 };
2934 #endif
2935
2936 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2937 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2938 PyObject* pyList = NULL;
2939 wxArrayVideoModes arr = self->GetModes(mode);
2940 bool blocked = wxPyBeginBlockThreads();
2941 pyList = PyList_New(0);
2942 for (int i=0; i < arr.GetCount(); i++) {
2943 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2944 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2945 PyList_Append(pyList, pyObj);
2946 Py_DECREF(pyObj);
2947 }
2948 wxPyEndBlockThreads(blocked);
2949 return pyList;
2950 }
2951
2952 #include <wx/stdpaths.h>
2953
2954 static wxStandardPaths *StandardPaths_Get(){
2955 return (wxStandardPaths*) &wxStandardPaths::Get();
2956 }
2957 #ifdef __cplusplus
2958 extern "C" {
2959 #endif
2960 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2961 PyObject *resultobj;
2962 wxSystemColour arg1 ;
2963 wxColour result;
2964 PyObject * obj0 = 0 ;
2965 char *kwnames[] = {
2966 (char *) "index", NULL
2967 };
2968
2969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2970 {
2971 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2972 if (SWIG_arg_fail(1)) SWIG_fail;
2973 }
2974 {
2975 if (!wxPyCheckForApp()) SWIG_fail;
2976 PyThreadState* __tstate = wxPyBeginAllowThreads();
2977 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
2978
2979 wxPyEndAllowThreads(__tstate);
2980 if (PyErr_Occurred()) SWIG_fail;
2981 }
2982 {
2983 wxColour * resultptr;
2984 resultptr = new wxColour((wxColour &)(result));
2985 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
2986 }
2987 return resultobj;
2988 fail:
2989 return NULL;
2990 }
2991
2992
2993 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
2994 PyObject *resultobj;
2995 wxSystemFont arg1 ;
2996 wxFont result;
2997 PyObject * obj0 = 0 ;
2998 char *kwnames[] = {
2999 (char *) "index", NULL
3000 };
3001
3002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3003 {
3004 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3005 if (SWIG_arg_fail(1)) SWIG_fail;
3006 }
3007 {
3008 if (!wxPyCheckForApp()) SWIG_fail;
3009 PyThreadState* __tstate = wxPyBeginAllowThreads();
3010 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3011
3012 wxPyEndAllowThreads(__tstate);
3013 if (PyErr_Occurred()) SWIG_fail;
3014 }
3015 {
3016 wxFont * resultptr;
3017 resultptr = new wxFont((wxFont &)(result));
3018 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3019 }
3020 return resultobj;
3021 fail:
3022 return NULL;
3023 }
3024
3025
3026 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3027 PyObject *resultobj;
3028 wxSystemMetric arg1 ;
3029 int result;
3030 PyObject * obj0 = 0 ;
3031 char *kwnames[] = {
3032 (char *) "index", NULL
3033 };
3034
3035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
3036 {
3037 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3038 if (SWIG_arg_fail(1)) SWIG_fail;
3039 }
3040 {
3041 if (!wxPyCheckForApp()) SWIG_fail;
3042 PyThreadState* __tstate = wxPyBeginAllowThreads();
3043 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
3044
3045 wxPyEndAllowThreads(__tstate);
3046 if (PyErr_Occurred()) SWIG_fail;
3047 }
3048 {
3049 resultobj = SWIG_From_int((int)(result));
3050 }
3051 return resultobj;
3052 fail:
3053 return NULL;
3054 }
3055
3056
3057 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3058 PyObject *resultobj;
3059 wxSystemFeature arg1 ;
3060 bool result;
3061 PyObject * obj0 = 0 ;
3062 char *kwnames[] = {
3063 (char *) "index", NULL
3064 };
3065
3066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3067 {
3068 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3069 if (SWIG_arg_fail(1)) SWIG_fail;
3070 }
3071 {
3072 if (!wxPyCheckForApp()) SWIG_fail;
3073 PyThreadState* __tstate = wxPyBeginAllowThreads();
3074 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3075
3076 wxPyEndAllowThreads(__tstate);
3077 if (PyErr_Occurred()) SWIG_fail;
3078 }
3079 {
3080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3081 }
3082 return resultobj;
3083 fail:
3084 return NULL;
3085 }
3086
3087
3088 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3089 PyObject *resultobj;
3090 wxSystemScreenType result;
3091 char *kwnames[] = {
3092 NULL
3093 };
3094
3095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3096 {
3097 if (!wxPyCheckForApp()) SWIG_fail;
3098 PyThreadState* __tstate = wxPyBeginAllowThreads();
3099 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3100
3101 wxPyEndAllowThreads(__tstate);
3102 if (PyErr_Occurred()) SWIG_fail;
3103 }
3104 resultobj = SWIG_From_int((result));
3105 return resultobj;
3106 fail:
3107 return NULL;
3108 }
3109
3110
3111 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3112 PyObject *resultobj;
3113 wxSystemScreenType arg1 ;
3114 PyObject * obj0 = 0 ;
3115 char *kwnames[] = {
3116 (char *) "screen", NULL
3117 };
3118
3119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3120 {
3121 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3122 if (SWIG_arg_fail(1)) SWIG_fail;
3123 }
3124 {
3125 if (!wxPyCheckForApp()) SWIG_fail;
3126 PyThreadState* __tstate = wxPyBeginAllowThreads();
3127 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3128
3129 wxPyEndAllowThreads(__tstate);
3130 if (PyErr_Occurred()) SWIG_fail;
3131 }
3132 Py_INCREF(Py_None); resultobj = Py_None;
3133 return resultobj;
3134 fail:
3135 return NULL;
3136 }
3137
3138
3139 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3140 PyObject *obj;
3141 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3142 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3143 Py_INCREF(obj);
3144 return Py_BuildValue((char *)"");
3145 }
3146 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3147 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3148 return 1;
3149 }
3150
3151
3152 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3153 PyObject *pyobj;
3154
3155 {
3156 #if wxUSE_UNICODE
3157 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3158 #else
3159 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3160 #endif
3161 }
3162 return pyobj;
3163 }
3164
3165
3166 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3167 PyObject *resultobj;
3168 wxSystemOptions *result;
3169 char *kwnames[] = {
3170 NULL
3171 };
3172
3173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3174 {
3175 PyThreadState* __tstate = wxPyBeginAllowThreads();
3176 result = (wxSystemOptions *)new wxSystemOptions();
3177
3178 wxPyEndAllowThreads(__tstate);
3179 if (PyErr_Occurred()) SWIG_fail;
3180 }
3181 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3182 return resultobj;
3183 fail:
3184 return NULL;
3185 }
3186
3187
3188 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3189 PyObject *resultobj;
3190 wxString *arg1 = 0 ;
3191 wxString *arg2 = 0 ;
3192 bool temp1 = false ;
3193 bool temp2 = false ;
3194 PyObject * obj0 = 0 ;
3195 PyObject * obj1 = 0 ;
3196 char *kwnames[] = {
3197 (char *) "name",(char *) "value", NULL
3198 };
3199
3200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3201 {
3202 arg1 = wxString_in_helper(obj0);
3203 if (arg1 == NULL) SWIG_fail;
3204 temp1 = true;
3205 }
3206 {
3207 arg2 = wxString_in_helper(obj1);
3208 if (arg2 == NULL) SWIG_fail;
3209 temp2 = true;
3210 }
3211 {
3212 PyThreadState* __tstate = wxPyBeginAllowThreads();
3213 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3214
3215 wxPyEndAllowThreads(__tstate);
3216 if (PyErr_Occurred()) SWIG_fail;
3217 }
3218 Py_INCREF(Py_None); resultobj = Py_None;
3219 {
3220 if (temp1)
3221 delete arg1;
3222 }
3223 {
3224 if (temp2)
3225 delete arg2;
3226 }
3227 return resultobj;
3228 fail:
3229 {
3230 if (temp1)
3231 delete arg1;
3232 }
3233 {
3234 if (temp2)
3235 delete arg2;
3236 }
3237 return NULL;
3238 }
3239
3240
3241 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3242 PyObject *resultobj;
3243 wxString *arg1 = 0 ;
3244 int arg2 ;
3245 bool temp1 = false ;
3246 PyObject * obj0 = 0 ;
3247 PyObject * obj1 = 0 ;
3248 char *kwnames[] = {
3249 (char *) "name",(char *) "value", NULL
3250 };
3251
3252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3253 {
3254 arg1 = wxString_in_helper(obj0);
3255 if (arg1 == NULL) SWIG_fail;
3256 temp1 = true;
3257 }
3258 {
3259 arg2 = (int)(SWIG_As_int(obj1));
3260 if (SWIG_arg_fail(2)) SWIG_fail;
3261 }
3262 {
3263 PyThreadState* __tstate = wxPyBeginAllowThreads();
3264 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3265
3266 wxPyEndAllowThreads(__tstate);
3267 if (PyErr_Occurred()) SWIG_fail;
3268 }
3269 Py_INCREF(Py_None); resultobj = Py_None;
3270 {
3271 if (temp1)
3272 delete arg1;
3273 }
3274 return resultobj;
3275 fail:
3276 {
3277 if (temp1)
3278 delete arg1;
3279 }
3280 return NULL;
3281 }
3282
3283
3284 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3285 PyObject *resultobj;
3286 wxString *arg1 = 0 ;
3287 wxString result;
3288 bool temp1 = false ;
3289 PyObject * obj0 = 0 ;
3290 char *kwnames[] = {
3291 (char *) "name", NULL
3292 };
3293
3294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3295 {
3296 arg1 = wxString_in_helper(obj0);
3297 if (arg1 == NULL) SWIG_fail;
3298 temp1 = true;
3299 }
3300 {
3301 PyThreadState* __tstate = wxPyBeginAllowThreads();
3302 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3303
3304 wxPyEndAllowThreads(__tstate);
3305 if (PyErr_Occurred()) SWIG_fail;
3306 }
3307 {
3308 #if wxUSE_UNICODE
3309 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3310 #else
3311 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3312 #endif
3313 }
3314 {
3315 if (temp1)
3316 delete arg1;
3317 }
3318 return resultobj;
3319 fail:
3320 {
3321 if (temp1)
3322 delete arg1;
3323 }
3324 return NULL;
3325 }
3326
3327
3328 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3329 PyObject *resultobj;
3330 wxString *arg1 = 0 ;
3331 int result;
3332 bool temp1 = false ;
3333 PyObject * obj0 = 0 ;
3334 char *kwnames[] = {
3335 (char *) "name", NULL
3336 };
3337
3338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3339 {
3340 arg1 = wxString_in_helper(obj0);
3341 if (arg1 == NULL) SWIG_fail;
3342 temp1 = true;
3343 }
3344 {
3345 PyThreadState* __tstate = wxPyBeginAllowThreads();
3346 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3347
3348 wxPyEndAllowThreads(__tstate);
3349 if (PyErr_Occurred()) SWIG_fail;
3350 }
3351 {
3352 resultobj = SWIG_From_int((int)(result));
3353 }
3354 {
3355 if (temp1)
3356 delete arg1;
3357 }
3358 return resultobj;
3359 fail:
3360 {
3361 if (temp1)
3362 delete arg1;
3363 }
3364 return NULL;
3365 }
3366
3367
3368 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3369 PyObject *resultobj;
3370 wxString *arg1 = 0 ;
3371 bool result;
3372 bool temp1 = false ;
3373 PyObject * obj0 = 0 ;
3374 char *kwnames[] = {
3375 (char *) "name", NULL
3376 };
3377
3378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3379 {
3380 arg1 = wxString_in_helper(obj0);
3381 if (arg1 == NULL) SWIG_fail;
3382 temp1 = true;
3383 }
3384 {
3385 PyThreadState* __tstate = wxPyBeginAllowThreads();
3386 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3387
3388 wxPyEndAllowThreads(__tstate);
3389 if (PyErr_Occurred()) SWIG_fail;
3390 }
3391 {
3392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3393 }
3394 {
3395 if (temp1)
3396 delete arg1;
3397 }
3398 return resultobj;
3399 fail:
3400 {
3401 if (temp1)
3402 delete arg1;
3403 }
3404 return NULL;
3405 }
3406
3407
3408 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3409 PyObject *obj;
3410 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3411 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3412 Py_INCREF(obj);
3413 return Py_BuildValue((char *)"");
3414 }
3415 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3416 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3417 return 1;
3418 }
3419
3420
3421 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3422 PyObject *pyobj;
3423
3424 {
3425 #if wxUSE_UNICODE
3426 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3427 #else
3428 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3429 #endif
3430 }
3431 return pyobj;
3432 }
3433
3434
3435 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3436 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3437 return 1;
3438 }
3439
3440
3441 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3442 PyObject *pyobj;
3443
3444 {
3445 #if wxUSE_UNICODE
3446 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3447 #else
3448 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3449 #endif
3450 }
3451 return pyobj;
3452 }
3453
3454
3455 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3456 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3457 return 1;
3458 }
3459
3460
3461 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3462 PyObject *pyobj;
3463
3464 {
3465 #if wxUSE_UNICODE
3466 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3467 #else
3468 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3469 #endif
3470 }
3471 return pyobj;
3472 }
3473
3474
3475 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3476 PyObject *resultobj;
3477 long result;
3478 char *kwnames[] = {
3479 NULL
3480 };
3481
3482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3483 {
3484 PyThreadState* __tstate = wxPyBeginAllowThreads();
3485 result = (long)wxNewId();
3486
3487 wxPyEndAllowThreads(__tstate);
3488 if (PyErr_Occurred()) SWIG_fail;
3489 }
3490 {
3491 resultobj = SWIG_From_long((long)(result));
3492 }
3493 return resultobj;
3494 fail:
3495 return NULL;
3496 }
3497
3498
3499 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3500 PyObject *resultobj;
3501 long arg1 ;
3502 PyObject * obj0 = 0 ;
3503 char *kwnames[] = {
3504 (char *) "id", NULL
3505 };
3506
3507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3508 {
3509 arg1 = (long)(SWIG_As_long(obj0));
3510 if (SWIG_arg_fail(1)) SWIG_fail;
3511 }
3512 {
3513 PyThreadState* __tstate = wxPyBeginAllowThreads();
3514 wxRegisterId(arg1);
3515
3516 wxPyEndAllowThreads(__tstate);
3517 if (PyErr_Occurred()) SWIG_fail;
3518 }
3519 Py_INCREF(Py_None); resultobj = Py_None;
3520 return resultobj;
3521 fail:
3522 return NULL;
3523 }
3524
3525
3526 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3527 PyObject *resultobj;
3528 long result;
3529 char *kwnames[] = {
3530 NULL
3531 };
3532
3533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3534 {
3535 PyThreadState* __tstate = wxPyBeginAllowThreads();
3536 result = (long)wxGetCurrentId();
3537
3538 wxPyEndAllowThreads(__tstate);
3539 if (PyErr_Occurred()) SWIG_fail;
3540 }
3541 {
3542 resultobj = SWIG_From_long((long)(result));
3543 }
3544 return resultobj;
3545 fail:
3546 return NULL;
3547 }
3548
3549
3550 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3551 PyObject *resultobj;
3552 int arg1 ;
3553 bool result;
3554 PyObject * obj0 = 0 ;
3555 char *kwnames[] = {
3556 (char *) "id", NULL
3557 };
3558
3559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3560 {
3561 arg1 = (int)(SWIG_As_int(obj0));
3562 if (SWIG_arg_fail(1)) SWIG_fail;
3563 }
3564 {
3565 PyThreadState* __tstate = wxPyBeginAllowThreads();
3566 result = (bool)wxIsStockID(arg1);
3567
3568 wxPyEndAllowThreads(__tstate);
3569 if (PyErr_Occurred()) SWIG_fail;
3570 }
3571 {
3572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3573 }
3574 return resultobj;
3575 fail:
3576 return NULL;
3577 }
3578
3579
3580 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3581 PyObject *resultobj;
3582 int arg1 ;
3583 wxString *arg2 = 0 ;
3584 bool result;
3585 bool temp2 = false ;
3586 PyObject * obj0 = 0 ;
3587 PyObject * obj1 = 0 ;
3588 char *kwnames[] = {
3589 (char *) "id",(char *) "label", NULL
3590 };
3591
3592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3593 {
3594 arg1 = (int)(SWIG_As_int(obj0));
3595 if (SWIG_arg_fail(1)) SWIG_fail;
3596 }
3597 {
3598 arg2 = wxString_in_helper(obj1);
3599 if (arg2 == NULL) SWIG_fail;
3600 temp2 = true;
3601 }
3602 {
3603 PyThreadState* __tstate = wxPyBeginAllowThreads();
3604 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3605
3606 wxPyEndAllowThreads(__tstate);
3607 if (PyErr_Occurred()) SWIG_fail;
3608 }
3609 {
3610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3611 }
3612 {
3613 if (temp2)
3614 delete arg2;
3615 }
3616 return resultobj;
3617 fail:
3618 {
3619 if (temp2)
3620 delete arg2;
3621 }
3622 return NULL;
3623 }
3624
3625
3626 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3627 PyObject *resultobj;
3628 int arg1 ;
3629 wxString result;
3630 PyObject * obj0 = 0 ;
3631 char *kwnames[] = {
3632 (char *) "id", NULL
3633 };
3634
3635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetStockLabel",kwnames,&obj0)) goto fail;
3636 {
3637 arg1 = (int)(SWIG_As_int(obj0));
3638 if (SWIG_arg_fail(1)) SWIG_fail;
3639 }
3640 {
3641 PyThreadState* __tstate = wxPyBeginAllowThreads();
3642 result = wxGetStockLabel(arg1);
3643
3644 wxPyEndAllowThreads(__tstate);
3645 if (PyErr_Occurred()) SWIG_fail;
3646 }
3647 {
3648 #if wxUSE_UNICODE
3649 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3650 #else
3651 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3652 #endif
3653 }
3654 return resultobj;
3655 fail:
3656 return NULL;
3657 }
3658
3659
3660 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3661 PyObject *resultobj;
3662 char *kwnames[] = {
3663 NULL
3664 };
3665
3666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3667 {
3668 if (!wxPyCheckForApp()) SWIG_fail;
3669 PyThreadState* __tstate = wxPyBeginAllowThreads();
3670 wxBell();
3671
3672 wxPyEndAllowThreads(__tstate);
3673 if (PyErr_Occurred()) SWIG_fail;
3674 }
3675 Py_INCREF(Py_None); resultobj = Py_None;
3676 return resultobj;
3677 fail:
3678 return NULL;
3679 }
3680
3681
3682 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3683 PyObject *resultobj;
3684 char *kwnames[] = {
3685 NULL
3686 };
3687
3688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3689 {
3690 if (!wxPyCheckForApp()) SWIG_fail;
3691 PyThreadState* __tstate = wxPyBeginAllowThreads();
3692 wxEndBusyCursor();
3693
3694 wxPyEndAllowThreads(__tstate);
3695 if (PyErr_Occurred()) SWIG_fail;
3696 }
3697 Py_INCREF(Py_None); resultobj = Py_None;
3698 return resultobj;
3699 fail:
3700 return NULL;
3701 }
3702
3703
3704 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3705 PyObject *resultobj;
3706 bool arg1 = (bool) true ;
3707 long result;
3708 PyObject * obj0 = 0 ;
3709 char *kwnames[] = {
3710 (char *) "resetTimer", NULL
3711 };
3712
3713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3714 if (obj0) {
3715 {
3716 arg1 = (bool)(SWIG_As_bool(obj0));
3717 if (SWIG_arg_fail(1)) SWIG_fail;
3718 }
3719 }
3720 {
3721 PyThreadState* __tstate = wxPyBeginAllowThreads();
3722 result = (long)wxGetElapsedTime(arg1);
3723
3724 wxPyEndAllowThreads(__tstate);
3725 if (PyErr_Occurred()) SWIG_fail;
3726 }
3727 {
3728 resultobj = SWIG_From_long((long)(result));
3729 }
3730 return resultobj;
3731 fail:
3732 return NULL;
3733 }
3734
3735
3736 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3737 PyObject *resultobj;
3738 int *arg1 = (int *) 0 ;
3739 int *arg2 = (int *) 0 ;
3740 int temp1 ;
3741 int res1 = 0 ;
3742 int temp2 ;
3743 int res2 = 0 ;
3744 char *kwnames[] = {
3745 NULL
3746 };
3747
3748 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3749 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3751 {
3752 if (!wxPyCheckForApp()) SWIG_fail;
3753 PyThreadState* __tstate = wxPyBeginAllowThreads();
3754 wxGetMousePosition(arg1,arg2);
3755
3756 wxPyEndAllowThreads(__tstate);
3757 if (PyErr_Occurred()) SWIG_fail;
3758 }
3759 Py_INCREF(Py_None); resultobj = Py_None;
3760 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3761 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3762 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3763 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3764 return resultobj;
3765 fail:
3766 return NULL;
3767 }
3768
3769
3770 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3771 PyObject *resultobj;
3772 bool result;
3773 char *kwnames[] = {
3774 NULL
3775 };
3776
3777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3778 {
3779 PyThreadState* __tstate = wxPyBeginAllowThreads();
3780 result = (bool)wxIsBusy();
3781
3782 wxPyEndAllowThreads(__tstate);
3783 if (PyErr_Occurred()) SWIG_fail;
3784 }
3785 {
3786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3787 }
3788 return resultobj;
3789 fail:
3790 return NULL;
3791 }
3792
3793
3794 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3795 PyObject *resultobj;
3796 wxString result;
3797 char *kwnames[] = {
3798 NULL
3799 };
3800
3801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3802 {
3803 PyThreadState* __tstate = wxPyBeginAllowThreads();
3804 result = wxNow();
3805
3806 wxPyEndAllowThreads(__tstate);
3807 if (PyErr_Occurred()) SWIG_fail;
3808 }
3809 {
3810 #if wxUSE_UNICODE
3811 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3812 #else
3813 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3814 #endif
3815 }
3816 return resultobj;
3817 fail:
3818 return NULL;
3819 }
3820
3821
3822 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3823 PyObject *resultobj;
3824 wxString const &arg1_defvalue = wxPyEmptyString ;
3825 wxString *arg1 = (wxString *) &arg1_defvalue ;
3826 bool result;
3827 bool temp1 = false ;
3828 PyObject * obj0 = 0 ;
3829 char *kwnames[] = {
3830 (char *) "command", NULL
3831 };
3832
3833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3834 if (obj0) {
3835 {
3836 arg1 = wxString_in_helper(obj0);
3837 if (arg1 == NULL) SWIG_fail;
3838 temp1 = true;
3839 }
3840 }
3841 {
3842 PyThreadState* __tstate = wxPyBeginAllowThreads();
3843 result = (bool)wxShell((wxString const &)*arg1);
3844
3845 wxPyEndAllowThreads(__tstate);
3846 if (PyErr_Occurred()) SWIG_fail;
3847 }
3848 {
3849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3850 }
3851 {
3852 if (temp1)
3853 delete arg1;
3854 }
3855 return resultobj;
3856 fail:
3857 {
3858 if (temp1)
3859 delete arg1;
3860 }
3861 return NULL;
3862 }
3863
3864
3865 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3866 PyObject *resultobj;
3867 char *kwnames[] = {
3868 NULL
3869 };
3870
3871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3872 {
3873 PyThreadState* __tstate = wxPyBeginAllowThreads();
3874 wxStartTimer();
3875
3876 wxPyEndAllowThreads(__tstate);
3877 if (PyErr_Occurred()) SWIG_fail;
3878 }
3879 Py_INCREF(Py_None); resultobj = Py_None;
3880 return resultobj;
3881 fail:
3882 return NULL;
3883 }
3884
3885
3886 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3887 PyObject *resultobj;
3888 int *arg1 = (int *) 0 ;
3889 int *arg2 = (int *) 0 ;
3890 int result;
3891 int temp1 ;
3892 int res1 = 0 ;
3893 int temp2 ;
3894 int res2 = 0 ;
3895 char *kwnames[] = {
3896 NULL
3897 };
3898
3899 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3900 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3902 {
3903 PyThreadState* __tstate = wxPyBeginAllowThreads();
3904 result = (int)wxGetOsVersion(arg1,arg2);
3905
3906 wxPyEndAllowThreads(__tstate);
3907 if (PyErr_Occurred()) SWIG_fail;
3908 }
3909 {
3910 resultobj = SWIG_From_int((int)(result));
3911 }
3912 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3913 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3914 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3915 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3916 return resultobj;
3917 fail:
3918 return NULL;
3919 }
3920
3921
3922 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3923 PyObject *resultobj;
3924 wxString result;
3925 char *kwnames[] = {
3926 NULL
3927 };
3928
3929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3930 {
3931 PyThreadState* __tstate = wxPyBeginAllowThreads();
3932 result = wxGetOsDescription();
3933
3934 wxPyEndAllowThreads(__tstate);
3935 if (PyErr_Occurred()) SWIG_fail;
3936 }
3937 {
3938 #if wxUSE_UNICODE
3939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3940 #else
3941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3942 #endif
3943 }
3944 return resultobj;
3945 fail:
3946 return NULL;
3947 }
3948
3949
3950 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3951 PyObject *resultobj;
3952 long result;
3953 char *kwnames[] = {
3954 NULL
3955 };
3956
3957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3958 {
3959 PyThreadState* __tstate = wxPyBeginAllowThreads();
3960 result = (long)wxGetFreeMemory();
3961
3962 wxPyEndAllowThreads(__tstate);
3963 if (PyErr_Occurred()) SWIG_fail;
3964 }
3965 {
3966 resultobj = SWIG_From_long((long)(result));
3967 }
3968 return resultobj;
3969 fail:
3970 return NULL;
3971 }
3972
3973
3974 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
3975 PyObject *resultobj;
3976 wxShutdownFlags arg1 ;
3977 bool result;
3978 PyObject * obj0 = 0 ;
3979 char *kwnames[] = {
3980 (char *) "wFlags", NULL
3981 };
3982
3983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
3984 {
3985 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
3986 if (SWIG_arg_fail(1)) SWIG_fail;
3987 }
3988 {
3989 if (!wxPyCheckForApp()) SWIG_fail;
3990 PyThreadState* __tstate = wxPyBeginAllowThreads();
3991 result = (bool)wxShutdown((wxShutdownFlags )arg1);
3992
3993 wxPyEndAllowThreads(__tstate);
3994 if (PyErr_Occurred()) SWIG_fail;
3995 }
3996 {
3997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3998 }
3999 return resultobj;
4000 fail:
4001 return NULL;
4002 }
4003
4004
4005 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4006 PyObject *resultobj;
4007 int arg1 ;
4008 PyObject * obj0 = 0 ;
4009 char *kwnames[] = {
4010 (char *) "secs", NULL
4011 };
4012
4013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4014 {
4015 arg1 = (int)(SWIG_As_int(obj0));
4016 if (SWIG_arg_fail(1)) SWIG_fail;
4017 }
4018 {
4019 PyThreadState* __tstate = wxPyBeginAllowThreads();
4020 wxSleep(arg1);
4021
4022 wxPyEndAllowThreads(__tstate);
4023 if (PyErr_Occurred()) SWIG_fail;
4024 }
4025 Py_INCREF(Py_None); resultobj = Py_None;
4026 return resultobj;
4027 fail:
4028 return NULL;
4029 }
4030
4031
4032 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4033 PyObject *resultobj;
4034 unsigned long arg1 ;
4035 PyObject * obj0 = 0 ;
4036 char *kwnames[] = {
4037 (char *) "milliseconds", NULL
4038 };
4039
4040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4041 {
4042 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4043 if (SWIG_arg_fail(1)) SWIG_fail;
4044 }
4045 {
4046 PyThreadState* __tstate = wxPyBeginAllowThreads();
4047 wxMilliSleep(arg1);
4048
4049 wxPyEndAllowThreads(__tstate);
4050 if (PyErr_Occurred()) SWIG_fail;
4051 }
4052 Py_INCREF(Py_None); resultobj = Py_None;
4053 return resultobj;
4054 fail:
4055 return NULL;
4056 }
4057
4058
4059 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4060 PyObject *resultobj;
4061 unsigned long arg1 ;
4062 PyObject * obj0 = 0 ;
4063 char *kwnames[] = {
4064 (char *) "microseconds", NULL
4065 };
4066
4067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4068 {
4069 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4070 if (SWIG_arg_fail(1)) SWIG_fail;
4071 }
4072 {
4073 PyThreadState* __tstate = wxPyBeginAllowThreads();
4074 wxMicroSleep(arg1);
4075
4076 wxPyEndAllowThreads(__tstate);
4077 if (PyErr_Occurred()) SWIG_fail;
4078 }
4079 Py_INCREF(Py_None); resultobj = Py_None;
4080 return resultobj;
4081 fail:
4082 return NULL;
4083 }
4084
4085
4086 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4087 PyObject *resultobj;
4088 bool arg1 ;
4089 PyObject * obj0 = 0 ;
4090 char *kwnames[] = {
4091 (char *) "enable", NULL
4092 };
4093
4094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4095 {
4096 arg1 = (bool)(SWIG_As_bool(obj0));
4097 if (SWIG_arg_fail(1)) SWIG_fail;
4098 }
4099 {
4100 PyThreadState* __tstate = wxPyBeginAllowThreads();
4101 wxEnableTopLevelWindows(arg1);
4102
4103 wxPyEndAllowThreads(__tstate);
4104 if (PyErr_Occurred()) SWIG_fail;
4105 }
4106 Py_INCREF(Py_None); resultobj = Py_None;
4107 return resultobj;
4108 fail:
4109 return NULL;
4110 }
4111
4112
4113 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4114 PyObject *resultobj;
4115 wxString *arg1 = 0 ;
4116 wxString result;
4117 bool temp1 = false ;
4118 PyObject * obj0 = 0 ;
4119 char *kwnames[] = {
4120 (char *) "in", NULL
4121 };
4122
4123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4124 {
4125 arg1 = wxString_in_helper(obj0);
4126 if (arg1 == NULL) SWIG_fail;
4127 temp1 = true;
4128 }
4129 {
4130 PyThreadState* __tstate = wxPyBeginAllowThreads();
4131 result = wxStripMenuCodes((wxString const &)*arg1);
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 {
4144 if (temp1)
4145 delete arg1;
4146 }
4147 return resultobj;
4148 fail:
4149 {
4150 if (temp1)
4151 delete arg1;
4152 }
4153 return NULL;
4154 }
4155
4156
4157 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4158 PyObject *resultobj;
4159 wxString result;
4160 char *kwnames[] = {
4161 NULL
4162 };
4163
4164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4165 {
4166 PyThreadState* __tstate = wxPyBeginAllowThreads();
4167 result = wxGetEmailAddress();
4168
4169 wxPyEndAllowThreads(__tstate);
4170 if (PyErr_Occurred()) SWIG_fail;
4171 }
4172 {
4173 #if wxUSE_UNICODE
4174 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4175 #else
4176 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4177 #endif
4178 }
4179 return resultobj;
4180 fail:
4181 return NULL;
4182 }
4183
4184
4185 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4186 PyObject *resultobj;
4187 wxString result;
4188 char *kwnames[] = {
4189 NULL
4190 };
4191
4192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4193 {
4194 PyThreadState* __tstate = wxPyBeginAllowThreads();
4195 result = wxGetHostName();
4196
4197 wxPyEndAllowThreads(__tstate);
4198 if (PyErr_Occurred()) SWIG_fail;
4199 }
4200 {
4201 #if wxUSE_UNICODE
4202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4203 #else
4204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4205 #endif
4206 }
4207 return resultobj;
4208 fail:
4209 return NULL;
4210 }
4211
4212
4213 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4214 PyObject *resultobj;
4215 wxString result;
4216 char *kwnames[] = {
4217 NULL
4218 };
4219
4220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4221 {
4222 PyThreadState* __tstate = wxPyBeginAllowThreads();
4223 result = wxGetFullHostName();
4224
4225 wxPyEndAllowThreads(__tstate);
4226 if (PyErr_Occurred()) SWIG_fail;
4227 }
4228 {
4229 #if wxUSE_UNICODE
4230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4231 #else
4232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4233 #endif
4234 }
4235 return resultobj;
4236 fail:
4237 return NULL;
4238 }
4239
4240
4241 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4242 PyObject *resultobj;
4243 wxString result;
4244 char *kwnames[] = {
4245 NULL
4246 };
4247
4248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4249 {
4250 PyThreadState* __tstate = wxPyBeginAllowThreads();
4251 result = wxGetUserId();
4252
4253 wxPyEndAllowThreads(__tstate);
4254 if (PyErr_Occurred()) SWIG_fail;
4255 }
4256 {
4257 #if wxUSE_UNICODE
4258 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4259 #else
4260 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4261 #endif
4262 }
4263 return resultobj;
4264 fail:
4265 return NULL;
4266 }
4267
4268
4269 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4270 PyObject *resultobj;
4271 wxString result;
4272 char *kwnames[] = {
4273 NULL
4274 };
4275
4276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4277 {
4278 PyThreadState* __tstate = wxPyBeginAllowThreads();
4279 result = wxGetUserName();
4280
4281 wxPyEndAllowThreads(__tstate);
4282 if (PyErr_Occurred()) SWIG_fail;
4283 }
4284 {
4285 #if wxUSE_UNICODE
4286 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4287 #else
4288 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4289 #endif
4290 }
4291 return resultobj;
4292 fail:
4293 return NULL;
4294 }
4295
4296
4297 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4298 PyObject *resultobj;
4299 wxString result;
4300 char *kwnames[] = {
4301 NULL
4302 };
4303
4304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4305 {
4306 PyThreadState* __tstate = wxPyBeginAllowThreads();
4307 result = wxGetHomeDir();
4308
4309 wxPyEndAllowThreads(__tstate);
4310 if (PyErr_Occurred()) SWIG_fail;
4311 }
4312 {
4313 #if wxUSE_UNICODE
4314 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4315 #else
4316 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4317 #endif
4318 }
4319 return resultobj;
4320 fail:
4321 return NULL;
4322 }
4323
4324
4325 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4326 PyObject *resultobj;
4327 wxString const &arg1_defvalue = wxPyEmptyString ;
4328 wxString *arg1 = (wxString *) &arg1_defvalue ;
4329 wxString result;
4330 bool temp1 = false ;
4331 PyObject * obj0 = 0 ;
4332 char *kwnames[] = {
4333 (char *) "user", NULL
4334 };
4335
4336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4337 if (obj0) {
4338 {
4339 arg1 = wxString_in_helper(obj0);
4340 if (arg1 == NULL) SWIG_fail;
4341 temp1 = true;
4342 }
4343 }
4344 {
4345 PyThreadState* __tstate = wxPyBeginAllowThreads();
4346 result = wxGetUserHome((wxString const &)*arg1);
4347
4348 wxPyEndAllowThreads(__tstate);
4349 if (PyErr_Occurred()) SWIG_fail;
4350 }
4351 {
4352 #if wxUSE_UNICODE
4353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4354 #else
4355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4356 #endif
4357 }
4358 {
4359 if (temp1)
4360 delete arg1;
4361 }
4362 return resultobj;
4363 fail:
4364 {
4365 if (temp1)
4366 delete arg1;
4367 }
4368 return NULL;
4369 }
4370
4371
4372 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4373 PyObject *resultobj;
4374 unsigned long result;
4375 char *kwnames[] = {
4376 NULL
4377 };
4378
4379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4380 {
4381 PyThreadState* __tstate = wxPyBeginAllowThreads();
4382 result = (unsigned long)wxGetProcessId();
4383
4384 wxPyEndAllowThreads(__tstate);
4385 if (PyErr_Occurred()) SWIG_fail;
4386 }
4387 {
4388 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4389 }
4390 return resultobj;
4391 fail:
4392 return NULL;
4393 }
4394
4395
4396 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4397 PyObject *resultobj;
4398 char *kwnames[] = {
4399 NULL
4400 };
4401
4402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4403 {
4404 PyThreadState* __tstate = wxPyBeginAllowThreads();
4405 wxTrap();
4406
4407 wxPyEndAllowThreads(__tstate);
4408 if (PyErr_Occurred()) SWIG_fail;
4409 }
4410 Py_INCREF(Py_None); resultobj = Py_None;
4411 return resultobj;
4412 fail:
4413 return NULL;
4414 }
4415
4416
4417 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4418 PyObject *resultobj;
4419 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4420 wxString *arg1 = (wxString *) &arg1_defvalue ;
4421 wxString const &arg2_defvalue = wxPyEmptyString ;
4422 wxString *arg2 = (wxString *) &arg2_defvalue ;
4423 wxString const &arg3_defvalue = wxPyEmptyString ;
4424 wxString *arg3 = (wxString *) &arg3_defvalue ;
4425 wxString const &arg4_defvalue = wxPyEmptyString ;
4426 wxString *arg4 = (wxString *) &arg4_defvalue ;
4427 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4428 wxString *arg5 = (wxString *) &arg5_defvalue ;
4429 int arg6 = (int) 0 ;
4430 wxWindow *arg7 = (wxWindow *) NULL ;
4431 int arg8 = (int) -1 ;
4432 int arg9 = (int) -1 ;
4433 wxString result;
4434 bool temp1 = false ;
4435 bool temp2 = false ;
4436 bool temp3 = false ;
4437 bool temp4 = false ;
4438 bool temp5 = false ;
4439 PyObject * obj0 = 0 ;
4440 PyObject * obj1 = 0 ;
4441 PyObject * obj2 = 0 ;
4442 PyObject * obj3 = 0 ;
4443 PyObject * obj4 = 0 ;
4444 PyObject * obj5 = 0 ;
4445 PyObject * obj6 = 0 ;
4446 PyObject * obj7 = 0 ;
4447 PyObject * obj8 = 0 ;
4448 char *kwnames[] = {
4449 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4450 };
4451
4452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4453 if (obj0) {
4454 {
4455 arg1 = wxString_in_helper(obj0);
4456 if (arg1 == NULL) SWIG_fail;
4457 temp1 = true;
4458 }
4459 }
4460 if (obj1) {
4461 {
4462 arg2 = wxString_in_helper(obj1);
4463 if (arg2 == NULL) SWIG_fail;
4464 temp2 = true;
4465 }
4466 }
4467 if (obj2) {
4468 {
4469 arg3 = wxString_in_helper(obj2);
4470 if (arg3 == NULL) SWIG_fail;
4471 temp3 = true;
4472 }
4473 }
4474 if (obj3) {
4475 {
4476 arg4 = wxString_in_helper(obj3);
4477 if (arg4 == NULL) SWIG_fail;
4478 temp4 = true;
4479 }
4480 }
4481 if (obj4) {
4482 {
4483 arg5 = wxString_in_helper(obj4);
4484 if (arg5 == NULL) SWIG_fail;
4485 temp5 = true;
4486 }
4487 }
4488 if (obj5) {
4489 {
4490 arg6 = (int)(SWIG_As_int(obj5));
4491 if (SWIG_arg_fail(6)) SWIG_fail;
4492 }
4493 }
4494 if (obj6) {
4495 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4496 if (SWIG_arg_fail(7)) SWIG_fail;
4497 }
4498 if (obj7) {
4499 {
4500 arg8 = (int)(SWIG_As_int(obj7));
4501 if (SWIG_arg_fail(8)) SWIG_fail;
4502 }
4503 }
4504 if (obj8) {
4505 {
4506 arg9 = (int)(SWIG_As_int(obj8));
4507 if (SWIG_arg_fail(9)) SWIG_fail;
4508 }
4509 }
4510 {
4511 if (!wxPyCheckForApp()) SWIG_fail;
4512 PyThreadState* __tstate = wxPyBeginAllowThreads();
4513 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4514
4515 wxPyEndAllowThreads(__tstate);
4516 if (PyErr_Occurred()) SWIG_fail;
4517 }
4518 {
4519 #if wxUSE_UNICODE
4520 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4521 #else
4522 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4523 #endif
4524 }
4525 {
4526 if (temp1)
4527 delete arg1;
4528 }
4529 {
4530 if (temp2)
4531 delete arg2;
4532 }
4533 {
4534 if (temp3)
4535 delete arg3;
4536 }
4537 {
4538 if (temp4)
4539 delete arg4;
4540 }
4541 {
4542 if (temp5)
4543 delete arg5;
4544 }
4545 return resultobj;
4546 fail:
4547 {
4548 if (temp1)
4549 delete arg1;
4550 }
4551 {
4552 if (temp2)
4553 delete arg2;
4554 }
4555 {
4556 if (temp3)
4557 delete arg3;
4558 }
4559 {
4560 if (temp4)
4561 delete arg4;
4562 }
4563 {
4564 if (temp5)
4565 delete arg5;
4566 }
4567 return NULL;
4568 }
4569
4570
4571 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4572 PyObject *resultobj;
4573 wxString *arg1 = 0 ;
4574 wxString *arg2 = 0 ;
4575 wxString const &arg3_defvalue = wxPyEmptyString ;
4576 wxString *arg3 = (wxString *) &arg3_defvalue ;
4577 wxWindow *arg4 = (wxWindow *) NULL ;
4578 wxString result;
4579 bool temp1 = false ;
4580 bool temp2 = false ;
4581 bool temp3 = false ;
4582 PyObject * obj0 = 0 ;
4583 PyObject * obj1 = 0 ;
4584 PyObject * obj2 = 0 ;
4585 PyObject * obj3 = 0 ;
4586 char *kwnames[] = {
4587 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4588 };
4589
4590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4591 {
4592 arg1 = wxString_in_helper(obj0);
4593 if (arg1 == NULL) SWIG_fail;
4594 temp1 = true;
4595 }
4596 {
4597 arg2 = wxString_in_helper(obj1);
4598 if (arg2 == NULL) SWIG_fail;
4599 temp2 = true;
4600 }
4601 if (obj2) {
4602 {
4603 arg3 = wxString_in_helper(obj2);
4604 if (arg3 == NULL) SWIG_fail;
4605 temp3 = true;
4606 }
4607 }
4608 if (obj3) {
4609 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4610 if (SWIG_arg_fail(4)) SWIG_fail;
4611 }
4612 {
4613 if (!wxPyCheckForApp()) SWIG_fail;
4614 PyThreadState* __tstate = wxPyBeginAllowThreads();
4615 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4616
4617 wxPyEndAllowThreads(__tstate);
4618 if (PyErr_Occurred()) SWIG_fail;
4619 }
4620 {
4621 #if wxUSE_UNICODE
4622 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4623 #else
4624 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4625 #endif
4626 }
4627 {
4628 if (temp1)
4629 delete arg1;
4630 }
4631 {
4632 if (temp2)
4633 delete arg2;
4634 }
4635 {
4636 if (temp3)
4637 delete arg3;
4638 }
4639 return resultobj;
4640 fail:
4641 {
4642 if (temp1)
4643 delete arg1;
4644 }
4645 {
4646 if (temp2)
4647 delete arg2;
4648 }
4649 {
4650 if (temp3)
4651 delete arg3;
4652 }
4653 return NULL;
4654 }
4655
4656
4657 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4658 PyObject *resultobj;
4659 wxString *arg1 = 0 ;
4660 wxString *arg2 = 0 ;
4661 wxString const &arg3_defvalue = wxPyEmptyString ;
4662 wxString *arg3 = (wxString *) &arg3_defvalue ;
4663 wxWindow *arg4 = (wxWindow *) NULL ;
4664 wxString result;
4665 bool temp1 = false ;
4666 bool temp2 = false ;
4667 bool temp3 = false ;
4668 PyObject * obj0 = 0 ;
4669 PyObject * obj1 = 0 ;
4670 PyObject * obj2 = 0 ;
4671 PyObject * obj3 = 0 ;
4672 char *kwnames[] = {
4673 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4674 };
4675
4676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4677 {
4678 arg1 = wxString_in_helper(obj0);
4679 if (arg1 == NULL) SWIG_fail;
4680 temp1 = true;
4681 }
4682 {
4683 arg2 = wxString_in_helper(obj1);
4684 if (arg2 == NULL) SWIG_fail;
4685 temp2 = true;
4686 }
4687 if (obj2) {
4688 {
4689 arg3 = wxString_in_helper(obj2);
4690 if (arg3 == NULL) SWIG_fail;
4691 temp3 = true;
4692 }
4693 }
4694 if (obj3) {
4695 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4696 if (SWIG_arg_fail(4)) SWIG_fail;
4697 }
4698 {
4699 if (!wxPyCheckForApp()) SWIG_fail;
4700 PyThreadState* __tstate = wxPyBeginAllowThreads();
4701 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4702
4703 wxPyEndAllowThreads(__tstate);
4704 if (PyErr_Occurred()) SWIG_fail;
4705 }
4706 {
4707 #if wxUSE_UNICODE
4708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4709 #else
4710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4711 #endif
4712 }
4713 {
4714 if (temp1)
4715 delete arg1;
4716 }
4717 {
4718 if (temp2)
4719 delete arg2;
4720 }
4721 {
4722 if (temp3)
4723 delete arg3;
4724 }
4725 return resultobj;
4726 fail:
4727 {
4728 if (temp1)
4729 delete arg1;
4730 }
4731 {
4732 if (temp2)
4733 delete arg2;
4734 }
4735 {
4736 if (temp3)
4737 delete arg3;
4738 }
4739 return NULL;
4740 }
4741
4742
4743 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4744 PyObject *resultobj;
4745 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4746 wxString *arg1 = (wxString *) &arg1_defvalue ;
4747 wxString const &arg2_defvalue = wxPyEmptyString ;
4748 wxString *arg2 = (wxString *) &arg2_defvalue ;
4749 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4750 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4751 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4752 wxWindow *arg5 = (wxWindow *) NULL ;
4753 wxString result;
4754 bool temp1 = false ;
4755 bool temp2 = false ;
4756 wxPoint temp4 ;
4757 PyObject * obj0 = 0 ;
4758 PyObject * obj1 = 0 ;
4759 PyObject * obj2 = 0 ;
4760 PyObject * obj3 = 0 ;
4761 PyObject * obj4 = 0 ;
4762 char *kwnames[] = {
4763 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4764 };
4765
4766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4767 if (obj0) {
4768 {
4769 arg1 = wxString_in_helper(obj0);
4770 if (arg1 == NULL) SWIG_fail;
4771 temp1 = true;
4772 }
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 = (long)(SWIG_As_long(obj2));
4784 if (SWIG_arg_fail(3)) SWIG_fail;
4785 }
4786 }
4787 if (obj3) {
4788 {
4789 arg4 = &temp4;
4790 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4791 }
4792 }
4793 if (obj4) {
4794 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4795 if (SWIG_arg_fail(5)) SWIG_fail;
4796 }
4797 {
4798 if (!wxPyCheckForApp()) SWIG_fail;
4799 PyThreadState* __tstate = wxPyBeginAllowThreads();
4800 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4801
4802 wxPyEndAllowThreads(__tstate);
4803 if (PyErr_Occurred()) SWIG_fail;
4804 }
4805 {
4806 #if wxUSE_UNICODE
4807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4808 #else
4809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4810 #endif
4811 }
4812 {
4813 if (temp1)
4814 delete arg1;
4815 }
4816 {
4817 if (temp2)
4818 delete arg2;
4819 }
4820 return resultobj;
4821 fail:
4822 {
4823 if (temp1)
4824 delete arg1;
4825 }
4826 {
4827 if (temp2)
4828 delete arg2;
4829 }
4830 return NULL;
4831 }
4832
4833
4834 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4835 PyObject *resultobj;
4836 wxString *arg1 = 0 ;
4837 wxString const &arg2_defvalue = wxPyEmptyString ;
4838 wxString *arg2 = (wxString *) &arg2_defvalue ;
4839 wxString const &arg3_defvalue = wxPyEmptyString ;
4840 wxString *arg3 = (wxString *) &arg3_defvalue ;
4841 wxWindow *arg4 = (wxWindow *) NULL ;
4842 int arg5 = (int) -1 ;
4843 int arg6 = (int) -1 ;
4844 bool arg7 = (bool) true ;
4845 wxString result;
4846 bool temp1 = false ;
4847 bool temp2 = false ;
4848 bool temp3 = false ;
4849 PyObject * obj0 = 0 ;
4850 PyObject * obj1 = 0 ;
4851 PyObject * obj2 = 0 ;
4852 PyObject * obj3 = 0 ;
4853 PyObject * obj4 = 0 ;
4854 PyObject * obj5 = 0 ;
4855 PyObject * obj6 = 0 ;
4856 char *kwnames[] = {
4857 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4858 };
4859
4860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4861 {
4862 arg1 = wxString_in_helper(obj0);
4863 if (arg1 == NULL) SWIG_fail;
4864 temp1 = true;
4865 }
4866 if (obj1) {
4867 {
4868 arg2 = wxString_in_helper(obj1);
4869 if (arg2 == NULL) SWIG_fail;
4870 temp2 = true;
4871 }
4872 }
4873 if (obj2) {
4874 {
4875 arg3 = wxString_in_helper(obj2);
4876 if (arg3 == NULL) SWIG_fail;
4877 temp3 = true;
4878 }
4879 }
4880 if (obj3) {
4881 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4882 if (SWIG_arg_fail(4)) SWIG_fail;
4883 }
4884 if (obj4) {
4885 {
4886 arg5 = (int)(SWIG_As_int(obj4));
4887 if (SWIG_arg_fail(5)) SWIG_fail;
4888 }
4889 }
4890 if (obj5) {
4891 {
4892 arg6 = (int)(SWIG_As_int(obj5));
4893 if (SWIG_arg_fail(6)) SWIG_fail;
4894 }
4895 }
4896 if (obj6) {
4897 {
4898 arg7 = (bool)(SWIG_As_bool(obj6));
4899 if (SWIG_arg_fail(7)) SWIG_fail;
4900 }
4901 }
4902 {
4903 if (!wxPyCheckForApp()) SWIG_fail;
4904 PyThreadState* __tstate = wxPyBeginAllowThreads();
4905 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4906
4907 wxPyEndAllowThreads(__tstate);
4908 if (PyErr_Occurred()) SWIG_fail;
4909 }
4910 {
4911 #if wxUSE_UNICODE
4912 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4913 #else
4914 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4915 #endif
4916 }
4917 {
4918 if (temp1)
4919 delete arg1;
4920 }
4921 {
4922 if (temp2)
4923 delete arg2;
4924 }
4925 {
4926 if (temp3)
4927 delete arg3;
4928 }
4929 return resultobj;
4930 fail:
4931 {
4932 if (temp1)
4933 delete arg1;
4934 }
4935 {
4936 if (temp2)
4937 delete arg2;
4938 }
4939 {
4940 if (temp3)
4941 delete arg3;
4942 }
4943 return NULL;
4944 }
4945
4946
4947 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4948 PyObject *resultobj;
4949 wxString *arg1 = 0 ;
4950 wxString const &arg2_defvalue = wxPyEmptyString ;
4951 wxString *arg2 = (wxString *) &arg2_defvalue ;
4952 wxString const &arg3_defvalue = wxPyEmptyString ;
4953 wxString *arg3 = (wxString *) &arg3_defvalue ;
4954 wxWindow *arg4 = (wxWindow *) NULL ;
4955 wxString result;
4956 bool temp1 = false ;
4957 bool temp2 = false ;
4958 bool temp3 = false ;
4959 PyObject * obj0 = 0 ;
4960 PyObject * obj1 = 0 ;
4961 PyObject * obj2 = 0 ;
4962 PyObject * obj3 = 0 ;
4963 char *kwnames[] = {
4964 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
4965 };
4966
4967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4968 {
4969 arg1 = wxString_in_helper(obj0);
4970 if (arg1 == NULL) SWIG_fail;
4971 temp1 = true;
4972 }
4973 if (obj1) {
4974 {
4975 arg2 = wxString_in_helper(obj1);
4976 if (arg2 == NULL) SWIG_fail;
4977 temp2 = true;
4978 }
4979 }
4980 if (obj2) {
4981 {
4982 arg3 = wxString_in_helper(obj2);
4983 if (arg3 == NULL) SWIG_fail;
4984 temp3 = true;
4985 }
4986 }
4987 if (obj3) {
4988 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4989 if (SWIG_arg_fail(4)) SWIG_fail;
4990 }
4991 {
4992 if (!wxPyCheckForApp()) SWIG_fail;
4993 PyThreadState* __tstate = wxPyBeginAllowThreads();
4994 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4995
4996 wxPyEndAllowThreads(__tstate);
4997 if (PyErr_Occurred()) SWIG_fail;
4998 }
4999 {
5000 #if wxUSE_UNICODE
5001 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5002 #else
5003 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5004 #endif
5005 }
5006 {
5007 if (temp1)
5008 delete arg1;
5009 }
5010 {
5011 if (temp2)
5012 delete arg2;
5013 }
5014 {
5015 if (temp3)
5016 delete arg3;
5017 }
5018 return resultobj;
5019 fail:
5020 {
5021 if (temp1)
5022 delete arg1;
5023 }
5024 {
5025 if (temp2)
5026 delete arg2;
5027 }
5028 {
5029 if (temp3)
5030 delete arg3;
5031 }
5032 return NULL;
5033 }
5034
5035
5036 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5037 PyObject *resultobj;
5038 wxString *arg1 = 0 ;
5039 wxString *arg2 = 0 ;
5040 int arg3 ;
5041 wxString *arg4 = (wxString *) 0 ;
5042 wxWindow *arg5 = (wxWindow *) NULL ;
5043 int arg6 = (int) -1 ;
5044 int arg7 = (int) -1 ;
5045 bool arg8 = (bool) true ;
5046 int arg9 = (int) 150 ;
5047 int arg10 = (int) 200 ;
5048 wxString result;
5049 bool temp1 = false ;
5050 bool temp2 = false ;
5051 PyObject * obj0 = 0 ;
5052 PyObject * obj1 = 0 ;
5053 PyObject * obj2 = 0 ;
5054 PyObject * obj3 = 0 ;
5055 PyObject * obj4 = 0 ;
5056 PyObject * obj5 = 0 ;
5057 PyObject * obj6 = 0 ;
5058 PyObject * obj7 = 0 ;
5059 PyObject * obj8 = 0 ;
5060 char *kwnames[] = {
5061 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5062 };
5063
5064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5065 {
5066 arg1 = wxString_in_helper(obj0);
5067 if (arg1 == NULL) SWIG_fail;
5068 temp1 = true;
5069 }
5070 {
5071 arg2 = wxString_in_helper(obj1);
5072 if (arg2 == NULL) SWIG_fail;
5073 temp2 = true;
5074 }
5075 {
5076 arg3 = PyList_Size(obj2);
5077 arg4 = wxString_LIST_helper(obj2);
5078 if (arg4 == NULL) SWIG_fail;
5079 }
5080 if (obj3) {
5081 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5082 if (SWIG_arg_fail(5)) SWIG_fail;
5083 }
5084 if (obj4) {
5085 {
5086 arg6 = (int)(SWIG_As_int(obj4));
5087 if (SWIG_arg_fail(6)) SWIG_fail;
5088 }
5089 }
5090 if (obj5) {
5091 {
5092 arg7 = (int)(SWIG_As_int(obj5));
5093 if (SWIG_arg_fail(7)) SWIG_fail;
5094 }
5095 }
5096 if (obj6) {
5097 {
5098 arg8 = (bool)(SWIG_As_bool(obj6));
5099 if (SWIG_arg_fail(8)) SWIG_fail;
5100 }
5101 }
5102 if (obj7) {
5103 {
5104 arg9 = (int)(SWIG_As_int(obj7));
5105 if (SWIG_arg_fail(9)) SWIG_fail;
5106 }
5107 }
5108 if (obj8) {
5109 {
5110 arg10 = (int)(SWIG_As_int(obj8));
5111 if (SWIG_arg_fail(10)) SWIG_fail;
5112 }
5113 }
5114 {
5115 if (!wxPyCheckForApp()) SWIG_fail;
5116 PyThreadState* __tstate = wxPyBeginAllowThreads();
5117 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5118
5119 wxPyEndAllowThreads(__tstate);
5120 if (PyErr_Occurred()) SWIG_fail;
5121 }
5122 {
5123 #if wxUSE_UNICODE
5124 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5125 #else
5126 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5127 #endif
5128 }
5129 {
5130 if (temp1)
5131 delete arg1;
5132 }
5133 {
5134 if (temp2)
5135 delete arg2;
5136 }
5137 {
5138 if (arg4) delete [] arg4;
5139 }
5140 return resultobj;
5141 fail:
5142 {
5143 if (temp1)
5144 delete arg1;
5145 }
5146 {
5147 if (temp2)
5148 delete arg2;
5149 }
5150 {
5151 if (arg4) delete [] arg4;
5152 }
5153 return NULL;
5154 }
5155
5156
5157 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5158 PyObject *resultobj;
5159 wxString *arg1 = 0 ;
5160 wxString *arg2 = 0 ;
5161 int arg3 ;
5162 wxString *arg4 = (wxString *) 0 ;
5163 wxWindow *arg5 = (wxWindow *) NULL ;
5164 int arg6 = (int) -1 ;
5165 int arg7 = (int) -1 ;
5166 bool arg8 = (bool) true ;
5167 int arg9 = (int) 150 ;
5168 int arg10 = (int) 200 ;
5169 int result;
5170 bool temp1 = false ;
5171 bool temp2 = false ;
5172 PyObject * obj0 = 0 ;
5173 PyObject * obj1 = 0 ;
5174 PyObject * obj2 = 0 ;
5175 PyObject * obj3 = 0 ;
5176 PyObject * obj4 = 0 ;
5177 PyObject * obj5 = 0 ;
5178 PyObject * obj6 = 0 ;
5179 PyObject * obj7 = 0 ;
5180 PyObject * obj8 = 0 ;
5181 char *kwnames[] = {
5182 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5183 };
5184
5185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5186 {
5187 arg1 = wxString_in_helper(obj0);
5188 if (arg1 == NULL) SWIG_fail;
5189 temp1 = true;
5190 }
5191 {
5192 arg2 = wxString_in_helper(obj1);
5193 if (arg2 == NULL) SWIG_fail;
5194 temp2 = true;
5195 }
5196 {
5197 arg3 = PyList_Size(obj2);
5198 arg4 = wxString_LIST_helper(obj2);
5199 if (arg4 == NULL) SWIG_fail;
5200 }
5201 if (obj3) {
5202 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5203 if (SWIG_arg_fail(5)) SWIG_fail;
5204 }
5205 if (obj4) {
5206 {
5207 arg6 = (int)(SWIG_As_int(obj4));
5208 if (SWIG_arg_fail(6)) SWIG_fail;
5209 }
5210 }
5211 if (obj5) {
5212 {
5213 arg7 = (int)(SWIG_As_int(obj5));
5214 if (SWIG_arg_fail(7)) SWIG_fail;
5215 }
5216 }
5217 if (obj6) {
5218 {
5219 arg8 = (bool)(SWIG_As_bool(obj6));
5220 if (SWIG_arg_fail(8)) SWIG_fail;
5221 }
5222 }
5223 if (obj7) {
5224 {
5225 arg9 = (int)(SWIG_As_int(obj7));
5226 if (SWIG_arg_fail(9)) SWIG_fail;
5227 }
5228 }
5229 if (obj8) {
5230 {
5231 arg10 = (int)(SWIG_As_int(obj8));
5232 if (SWIG_arg_fail(10)) SWIG_fail;
5233 }
5234 }
5235 {
5236 if (!wxPyCheckForApp()) SWIG_fail;
5237 PyThreadState* __tstate = wxPyBeginAllowThreads();
5238 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5239
5240 wxPyEndAllowThreads(__tstate);
5241 if (PyErr_Occurred()) SWIG_fail;
5242 }
5243 {
5244 resultobj = SWIG_From_int((int)(result));
5245 }
5246 {
5247 if (temp1)
5248 delete arg1;
5249 }
5250 {
5251 if (temp2)
5252 delete arg2;
5253 }
5254 {
5255 if (arg4) delete [] arg4;
5256 }
5257 return resultobj;
5258 fail:
5259 {
5260 if (temp1)
5261 delete arg1;
5262 }
5263 {
5264 if (temp2)
5265 delete arg2;
5266 }
5267 {
5268 if (arg4) delete [] arg4;
5269 }
5270 return NULL;
5271 }
5272
5273
5274 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5275 PyObject *resultobj;
5276 wxString *arg1 = 0 ;
5277 wxString const &arg2_defvalue = wxPyEmptyString ;
5278 wxString *arg2 = (wxString *) &arg2_defvalue ;
5279 int arg3 = (int) wxOK|wxCENTRE ;
5280 wxWindow *arg4 = (wxWindow *) NULL ;
5281 int arg5 = (int) -1 ;
5282 int arg6 = (int) -1 ;
5283 int result;
5284 bool temp1 = false ;
5285 bool temp2 = false ;
5286 PyObject * obj0 = 0 ;
5287 PyObject * obj1 = 0 ;
5288 PyObject * obj2 = 0 ;
5289 PyObject * obj3 = 0 ;
5290 PyObject * obj4 = 0 ;
5291 PyObject * obj5 = 0 ;
5292 char *kwnames[] = {
5293 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5294 };
5295
5296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5297 {
5298 arg1 = wxString_in_helper(obj0);
5299 if (arg1 == NULL) SWIG_fail;
5300 temp1 = true;
5301 }
5302 if (obj1) {
5303 {
5304 arg2 = wxString_in_helper(obj1);
5305 if (arg2 == NULL) SWIG_fail;
5306 temp2 = true;
5307 }
5308 }
5309 if (obj2) {
5310 {
5311 arg3 = (int)(SWIG_As_int(obj2));
5312 if (SWIG_arg_fail(3)) SWIG_fail;
5313 }
5314 }
5315 if (obj3) {
5316 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5317 if (SWIG_arg_fail(4)) SWIG_fail;
5318 }
5319 if (obj4) {
5320 {
5321 arg5 = (int)(SWIG_As_int(obj4));
5322 if (SWIG_arg_fail(5)) SWIG_fail;
5323 }
5324 }
5325 if (obj5) {
5326 {
5327 arg6 = (int)(SWIG_As_int(obj5));
5328 if (SWIG_arg_fail(6)) SWIG_fail;
5329 }
5330 }
5331 {
5332 if (!wxPyCheckForApp()) SWIG_fail;
5333 PyThreadState* __tstate = wxPyBeginAllowThreads();
5334 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5335
5336 wxPyEndAllowThreads(__tstate);
5337 if (PyErr_Occurred()) SWIG_fail;
5338 }
5339 {
5340 resultobj = SWIG_From_int((int)(result));
5341 }
5342 {
5343 if (temp1)
5344 delete arg1;
5345 }
5346 {
5347 if (temp2)
5348 delete arg2;
5349 }
5350 return resultobj;
5351 fail:
5352 {
5353 if (temp1)
5354 delete arg1;
5355 }
5356 {
5357 if (temp2)
5358 delete arg2;
5359 }
5360 return NULL;
5361 }
5362
5363
5364 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5365 PyObject *resultobj;
5366 wxString *arg1 = 0 ;
5367 wxString *arg2 = 0 ;
5368 wxString *arg3 = 0 ;
5369 long arg4 ;
5370 long arg5 = (long) 0 ;
5371 long arg6 = (long) 100 ;
5372 wxWindow *arg7 = (wxWindow *) NULL ;
5373 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5374 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5375 long result;
5376 bool temp1 = false ;
5377 bool temp2 = false ;
5378 bool temp3 = false ;
5379 wxPoint temp8 ;
5380 PyObject * obj0 = 0 ;
5381 PyObject * obj1 = 0 ;
5382 PyObject * obj2 = 0 ;
5383 PyObject * obj3 = 0 ;
5384 PyObject * obj4 = 0 ;
5385 PyObject * obj5 = 0 ;
5386 PyObject * obj6 = 0 ;
5387 PyObject * obj7 = 0 ;
5388 char *kwnames[] = {
5389 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5390 };
5391
5392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5393 {
5394 arg1 = wxString_in_helper(obj0);
5395 if (arg1 == NULL) SWIG_fail;
5396 temp1 = true;
5397 }
5398 {
5399 arg2 = wxString_in_helper(obj1);
5400 if (arg2 == NULL) SWIG_fail;
5401 temp2 = true;
5402 }
5403 {
5404 arg3 = wxString_in_helper(obj2);
5405 if (arg3 == NULL) SWIG_fail;
5406 temp3 = true;
5407 }
5408 {
5409 arg4 = (long)(SWIG_As_long(obj3));
5410 if (SWIG_arg_fail(4)) SWIG_fail;
5411 }
5412 if (obj4) {
5413 {
5414 arg5 = (long)(SWIG_As_long(obj4));
5415 if (SWIG_arg_fail(5)) SWIG_fail;
5416 }
5417 }
5418 if (obj5) {
5419 {
5420 arg6 = (long)(SWIG_As_long(obj5));
5421 if (SWIG_arg_fail(6)) SWIG_fail;
5422 }
5423 }
5424 if (obj6) {
5425 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5426 if (SWIG_arg_fail(7)) SWIG_fail;
5427 }
5428 if (obj7) {
5429 {
5430 arg8 = &temp8;
5431 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5432 }
5433 }
5434 {
5435 if (!wxPyCheckForApp()) SWIG_fail;
5436 PyThreadState* __tstate = wxPyBeginAllowThreads();
5437 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5438
5439 wxPyEndAllowThreads(__tstate);
5440 if (PyErr_Occurred()) SWIG_fail;
5441 }
5442 {
5443 resultobj = SWIG_From_long((long)(result));
5444 }
5445 {
5446 if (temp1)
5447 delete arg1;
5448 }
5449 {
5450 if (temp2)
5451 delete arg2;
5452 }
5453 {
5454 if (temp3)
5455 delete arg3;
5456 }
5457 return resultobj;
5458 fail:
5459 {
5460 if (temp1)
5461 delete arg1;
5462 }
5463 {
5464 if (temp2)
5465 delete arg2;
5466 }
5467 {
5468 if (temp3)
5469 delete arg3;
5470 }
5471 return NULL;
5472 }
5473
5474
5475 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5476 PyObject *resultobj;
5477 bool result;
5478 char *kwnames[] = {
5479 NULL
5480 };
5481
5482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5483 {
5484 if (!wxPyCheckForApp()) SWIG_fail;
5485 PyThreadState* __tstate = wxPyBeginAllowThreads();
5486 result = (bool)wxColourDisplay();
5487
5488 wxPyEndAllowThreads(__tstate);
5489 if (PyErr_Occurred()) SWIG_fail;
5490 }
5491 {
5492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5493 }
5494 return resultobj;
5495 fail:
5496 return NULL;
5497 }
5498
5499
5500 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5501 PyObject *resultobj;
5502 int result;
5503 char *kwnames[] = {
5504 NULL
5505 };
5506
5507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5508 {
5509 if (!wxPyCheckForApp()) SWIG_fail;
5510 PyThreadState* __tstate = wxPyBeginAllowThreads();
5511 result = (int)wxDisplayDepth();
5512
5513 wxPyEndAllowThreads(__tstate);
5514 if (PyErr_Occurred()) SWIG_fail;
5515 }
5516 {
5517 resultobj = SWIG_From_int((int)(result));
5518 }
5519 return resultobj;
5520 fail:
5521 return NULL;
5522 }
5523
5524
5525 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5526 PyObject *resultobj;
5527 int result;
5528 char *kwnames[] = {
5529 NULL
5530 };
5531
5532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5533 {
5534 if (!wxPyCheckForApp()) SWIG_fail;
5535 PyThreadState* __tstate = wxPyBeginAllowThreads();
5536 result = (int)wxGetDisplayDepth();
5537
5538 wxPyEndAllowThreads(__tstate);
5539 if (PyErr_Occurred()) SWIG_fail;
5540 }
5541 {
5542 resultobj = SWIG_From_int((int)(result));
5543 }
5544 return resultobj;
5545 fail:
5546 return NULL;
5547 }
5548
5549
5550 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5551 PyObject *resultobj;
5552 int *arg1 = (int *) 0 ;
5553 int *arg2 = (int *) 0 ;
5554 int temp1 ;
5555 int res1 = 0 ;
5556 int temp2 ;
5557 int res2 = 0 ;
5558 char *kwnames[] = {
5559 NULL
5560 };
5561
5562 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5563 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5565 {
5566 if (!wxPyCheckForApp()) SWIG_fail;
5567 PyThreadState* __tstate = wxPyBeginAllowThreads();
5568 wxDisplaySize(arg1,arg2);
5569
5570 wxPyEndAllowThreads(__tstate);
5571 if (PyErr_Occurred()) SWIG_fail;
5572 }
5573 Py_INCREF(Py_None); resultobj = Py_None;
5574 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5575 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5576 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5577 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5578 return resultobj;
5579 fail:
5580 return NULL;
5581 }
5582
5583
5584 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5585 PyObject *resultobj;
5586 wxSize result;
5587 char *kwnames[] = {
5588 NULL
5589 };
5590
5591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5592 {
5593 if (!wxPyCheckForApp()) SWIG_fail;
5594 PyThreadState* __tstate = wxPyBeginAllowThreads();
5595 result = wxGetDisplaySize();
5596
5597 wxPyEndAllowThreads(__tstate);
5598 if (PyErr_Occurred()) SWIG_fail;
5599 }
5600 {
5601 wxSize * resultptr;
5602 resultptr = new wxSize((wxSize &)(result));
5603 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5604 }
5605 return resultobj;
5606 fail:
5607 return NULL;
5608 }
5609
5610
5611 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5612 PyObject *resultobj;
5613 int *arg1 = (int *) 0 ;
5614 int *arg2 = (int *) 0 ;
5615 int temp1 ;
5616 int res1 = 0 ;
5617 int temp2 ;
5618 int res2 = 0 ;
5619 char *kwnames[] = {
5620 NULL
5621 };
5622
5623 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5624 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5626 {
5627 if (!wxPyCheckForApp()) SWIG_fail;
5628 PyThreadState* __tstate = wxPyBeginAllowThreads();
5629 wxDisplaySizeMM(arg1,arg2);
5630
5631 wxPyEndAllowThreads(__tstate);
5632 if (PyErr_Occurred()) SWIG_fail;
5633 }
5634 Py_INCREF(Py_None); resultobj = Py_None;
5635 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5636 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5637 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5638 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5639 return resultobj;
5640 fail:
5641 return NULL;
5642 }
5643
5644
5645 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5646 PyObject *resultobj;
5647 wxSize result;
5648 char *kwnames[] = {
5649 NULL
5650 };
5651
5652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5653 {
5654 if (!wxPyCheckForApp()) SWIG_fail;
5655 PyThreadState* __tstate = wxPyBeginAllowThreads();
5656 result = wxGetDisplaySizeMM();
5657
5658 wxPyEndAllowThreads(__tstate);
5659 if (PyErr_Occurred()) SWIG_fail;
5660 }
5661 {
5662 wxSize * resultptr;
5663 resultptr = new wxSize((wxSize &)(result));
5664 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5665 }
5666 return resultobj;
5667 fail:
5668 return NULL;
5669 }
5670
5671
5672 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5673 PyObject *resultobj;
5674 int *arg1 = (int *) 0 ;
5675 int *arg2 = (int *) 0 ;
5676 int *arg3 = (int *) 0 ;
5677 int *arg4 = (int *) 0 ;
5678 int temp1 ;
5679 int res1 = 0 ;
5680 int temp2 ;
5681 int res2 = 0 ;
5682 int temp3 ;
5683 int res3 = 0 ;
5684 int temp4 ;
5685 int res4 = 0 ;
5686 char *kwnames[] = {
5687 NULL
5688 };
5689
5690 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5691 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5692 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5693 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5695 {
5696 if (!wxPyCheckForApp()) SWIG_fail;
5697 PyThreadState* __tstate = wxPyBeginAllowThreads();
5698 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5699
5700 wxPyEndAllowThreads(__tstate);
5701 if (PyErr_Occurred()) SWIG_fail;
5702 }
5703 Py_INCREF(Py_None); resultobj = Py_None;
5704 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5705 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5706 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5707 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5708 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5709 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5710 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5711 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5712 return resultobj;
5713 fail:
5714 return NULL;
5715 }
5716
5717
5718 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5719 PyObject *resultobj;
5720 wxRect result;
5721 char *kwnames[] = {
5722 NULL
5723 };
5724
5725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5726 {
5727 if (!wxPyCheckForApp()) SWIG_fail;
5728 PyThreadState* __tstate = wxPyBeginAllowThreads();
5729 result = wxGetClientDisplayRect();
5730
5731 wxPyEndAllowThreads(__tstate);
5732 if (PyErr_Occurred()) SWIG_fail;
5733 }
5734 {
5735 wxRect * resultptr;
5736 resultptr = new wxRect((wxRect &)(result));
5737 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5738 }
5739 return resultobj;
5740 fail:
5741 return NULL;
5742 }
5743
5744
5745 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5746 PyObject *resultobj;
5747 wxCursor *arg1 = 0 ;
5748 PyObject * obj0 = 0 ;
5749 char *kwnames[] = {
5750 (char *) "cursor", NULL
5751 };
5752
5753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5754 {
5755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5756 if (SWIG_arg_fail(1)) SWIG_fail;
5757 if (arg1 == NULL) {
5758 SWIG_null_ref("wxCursor");
5759 }
5760 if (SWIG_arg_fail(1)) SWIG_fail;
5761 }
5762 {
5763 if (!wxPyCheckForApp()) SWIG_fail;
5764 PyThreadState* __tstate = wxPyBeginAllowThreads();
5765 wxSetCursor(*arg1);
5766
5767 wxPyEndAllowThreads(__tstate);
5768 if (PyErr_Occurred()) SWIG_fail;
5769 }
5770 Py_INCREF(Py_None); resultobj = Py_None;
5771 return resultobj;
5772 fail:
5773 return NULL;
5774 }
5775
5776
5777 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5778 PyObject *resultobj;
5779 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5780 PyObject * obj0 = 0 ;
5781 char *kwnames[] = {
5782 (char *) "cursor", NULL
5783 };
5784
5785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5786 if (obj0) {
5787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5788 if (SWIG_arg_fail(1)) SWIG_fail;
5789 }
5790 {
5791 if (!wxPyCheckForApp()) SWIG_fail;
5792 PyThreadState* __tstate = wxPyBeginAllowThreads();
5793 wxBeginBusyCursor(arg1);
5794
5795 wxPyEndAllowThreads(__tstate);
5796 if (PyErr_Occurred()) SWIG_fail;
5797 }
5798 Py_INCREF(Py_None); resultobj = Py_None;
5799 return resultobj;
5800 fail:
5801 return NULL;
5802 }
5803
5804
5805 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5806 PyObject *resultobj;
5807 wxWindow *result;
5808 char *kwnames[] = {
5809 NULL
5810 };
5811
5812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5813 {
5814 if (!wxPyCheckForApp()) SWIG_fail;
5815 PyThreadState* __tstate = wxPyBeginAllowThreads();
5816 result = (wxWindow *)wxGetActiveWindow();
5817
5818 wxPyEndAllowThreads(__tstate);
5819 if (PyErr_Occurred()) SWIG_fail;
5820 }
5821 {
5822 resultobj = wxPyMake_wxObject(result, 0);
5823 }
5824 return resultobj;
5825 fail:
5826 return NULL;
5827 }
5828
5829
5830 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5831 PyObject *resultobj;
5832 wxPoint *arg1 = 0 ;
5833 wxWindow *result;
5834 wxPoint temp1 ;
5835 PyObject * obj0 = 0 ;
5836 char *kwnames[] = {
5837 (char *) "pt", NULL
5838 };
5839
5840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5841 {
5842 arg1 = &temp1;
5843 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5844 }
5845 {
5846 if (!wxPyCheckForApp()) SWIG_fail;
5847 PyThreadState* __tstate = wxPyBeginAllowThreads();
5848 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5849
5850 wxPyEndAllowThreads(__tstate);
5851 if (PyErr_Occurred()) SWIG_fail;
5852 }
5853 {
5854 resultobj = wxPyMake_wxObject(result, 0);
5855 }
5856 return resultobj;
5857 fail:
5858 return NULL;
5859 }
5860
5861
5862 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5863 PyObject *resultobj;
5864 wxPoint *arg1 = 0 ;
5865 wxWindow *result;
5866 wxPoint temp1 ;
5867 PyObject * obj0 = 0 ;
5868 char *kwnames[] = {
5869 (char *) "pt", NULL
5870 };
5871
5872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5873 {
5874 arg1 = &temp1;
5875 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5876 }
5877 {
5878 if (!wxPyCheckForApp()) SWIG_fail;
5879 PyThreadState* __tstate = wxPyBeginAllowThreads();
5880 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5881
5882 wxPyEndAllowThreads(__tstate);
5883 if (PyErr_Occurred()) SWIG_fail;
5884 }
5885 {
5886 resultobj = wxPyMake_wxObject(result, 0);
5887 }
5888 return resultobj;
5889 fail:
5890 return NULL;
5891 }
5892
5893
5894 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5895 PyObject *resultobj;
5896 wxWindow *arg1 = (wxWindow *) 0 ;
5897 wxWindow *result;
5898 PyObject * obj0 = 0 ;
5899 char *kwnames[] = {
5900 (char *) "win", NULL
5901 };
5902
5903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5905 if (SWIG_arg_fail(1)) SWIG_fail;
5906 {
5907 if (!wxPyCheckForApp()) SWIG_fail;
5908 PyThreadState* __tstate = wxPyBeginAllowThreads();
5909 result = (wxWindow *)wxGetTopLevelParent(arg1);
5910
5911 wxPyEndAllowThreads(__tstate);
5912 if (PyErr_Occurred()) SWIG_fail;
5913 }
5914 {
5915 resultobj = wxPyMake_wxObject(result, 0);
5916 }
5917 return resultobj;
5918 fail:
5919 return NULL;
5920 }
5921
5922
5923 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5924 PyObject *resultobj;
5925 wxKeyCode arg1 ;
5926 bool result;
5927 PyObject * obj0 = 0 ;
5928 char *kwnames[] = {
5929 (char *) "key", NULL
5930 };
5931
5932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5933 {
5934 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5935 if (SWIG_arg_fail(1)) SWIG_fail;
5936 }
5937 {
5938 if (!wxPyCheckForApp()) SWIG_fail;
5939 PyThreadState* __tstate = wxPyBeginAllowThreads();
5940 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5941
5942 wxPyEndAllowThreads(__tstate);
5943 if (PyErr_Occurred()) SWIG_fail;
5944 }
5945 {
5946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5947 }
5948 return resultobj;
5949 fail:
5950 return NULL;
5951 }
5952
5953
5954 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5955 PyObject *resultobj;
5956 char *kwnames[] = {
5957 NULL
5958 };
5959
5960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
5961 {
5962 if (!wxPyCheckForApp()) SWIG_fail;
5963 PyThreadState* __tstate = wxPyBeginAllowThreads();
5964 wxWakeUpMainThread();
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 *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
5977 PyObject *resultobj;
5978 char *kwnames[] = {
5979 NULL
5980 };
5981
5982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
5983 {
5984 if (!wxPyCheckForApp()) SWIG_fail;
5985 PyThreadState* __tstate = wxPyBeginAllowThreads();
5986 wxMutexGuiEnter();
5987
5988 wxPyEndAllowThreads(__tstate);
5989 if (PyErr_Occurred()) SWIG_fail;
5990 }
5991 Py_INCREF(Py_None); resultobj = Py_None;
5992 return resultobj;
5993 fail:
5994 return NULL;
5995 }
5996
5997
5998 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
5999 PyObject *resultobj;
6000 char *kwnames[] = {
6001 NULL
6002 };
6003
6004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6005 {
6006 if (!wxPyCheckForApp()) SWIG_fail;
6007 PyThreadState* __tstate = wxPyBeginAllowThreads();
6008 wxMutexGuiLeave();
6009
6010 wxPyEndAllowThreads(__tstate);
6011 if (PyErr_Occurred()) SWIG_fail;
6012 }
6013 Py_INCREF(Py_None); resultobj = Py_None;
6014 return resultobj;
6015 fail:
6016 return NULL;
6017 }
6018
6019
6020 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6021 PyObject *resultobj;
6022 wxMutexGuiLocker *result;
6023 char *kwnames[] = {
6024 NULL
6025 };
6026
6027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6028 {
6029 if (!wxPyCheckForApp()) SWIG_fail;
6030 PyThreadState* __tstate = wxPyBeginAllowThreads();
6031 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6032
6033 wxPyEndAllowThreads(__tstate);
6034 if (PyErr_Occurred()) SWIG_fail;
6035 }
6036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6037 return resultobj;
6038 fail:
6039 return NULL;
6040 }
6041
6042
6043 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6044 PyObject *resultobj;
6045 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6046 PyObject * obj0 = 0 ;
6047 char *kwnames[] = {
6048 (char *) "self", NULL
6049 };
6050
6051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6053 if (SWIG_arg_fail(1)) SWIG_fail;
6054 {
6055 PyThreadState* __tstate = wxPyBeginAllowThreads();
6056 delete arg1;
6057
6058 wxPyEndAllowThreads(__tstate);
6059 if (PyErr_Occurred()) SWIG_fail;
6060 }
6061 Py_INCREF(Py_None); resultobj = Py_None;
6062 return resultobj;
6063 fail:
6064 return NULL;
6065 }
6066
6067
6068 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6069 PyObject *obj;
6070 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6071 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6072 Py_INCREF(obj);
6073 return Py_BuildValue((char *)"");
6074 }
6075 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6076 PyObject *resultobj;
6077 bool result;
6078 char *kwnames[] = {
6079 NULL
6080 };
6081
6082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6083 {
6084 PyThreadState* __tstate = wxPyBeginAllowThreads();
6085 result = (bool)wxThread_IsMain();
6086
6087 wxPyEndAllowThreads(__tstate);
6088 if (PyErr_Occurred()) SWIG_fail;
6089 }
6090 {
6091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6092 }
6093 return resultobj;
6094 fail:
6095 return NULL;
6096 }
6097
6098
6099 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6100 PyObject *resultobj;
6101 wxString *arg1 = 0 ;
6102 wxToolTip *result;
6103 bool temp1 = false ;
6104 PyObject * obj0 = 0 ;
6105 char *kwnames[] = {
6106 (char *) "tip", NULL
6107 };
6108
6109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6110 {
6111 arg1 = wxString_in_helper(obj0);
6112 if (arg1 == NULL) SWIG_fail;
6113 temp1 = true;
6114 }
6115 {
6116 if (!wxPyCheckForApp()) SWIG_fail;
6117 PyThreadState* __tstate = wxPyBeginAllowThreads();
6118 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6119
6120 wxPyEndAllowThreads(__tstate);
6121 if (PyErr_Occurred()) SWIG_fail;
6122 }
6123 {
6124 resultobj = wxPyMake_wxObject(result, 1);
6125 }
6126 {
6127 if (temp1)
6128 delete arg1;
6129 }
6130 return resultobj;
6131 fail:
6132 {
6133 if (temp1)
6134 delete arg1;
6135 }
6136 return NULL;
6137 }
6138
6139
6140 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6141 PyObject *resultobj;
6142 wxToolTip *arg1 = (wxToolTip *) 0 ;
6143 wxString *arg2 = 0 ;
6144 bool temp2 = false ;
6145 PyObject * obj0 = 0 ;
6146 PyObject * obj1 = 0 ;
6147 char *kwnames[] = {
6148 (char *) "self",(char *) "tip", NULL
6149 };
6150
6151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6153 if (SWIG_arg_fail(1)) SWIG_fail;
6154 {
6155 arg2 = wxString_in_helper(obj1);
6156 if (arg2 == NULL) SWIG_fail;
6157 temp2 = true;
6158 }
6159 {
6160 PyThreadState* __tstate = wxPyBeginAllowThreads();
6161 (arg1)->SetTip((wxString const &)*arg2);
6162
6163 wxPyEndAllowThreads(__tstate);
6164 if (PyErr_Occurred()) SWIG_fail;
6165 }
6166 Py_INCREF(Py_None); resultobj = Py_None;
6167 {
6168 if (temp2)
6169 delete arg2;
6170 }
6171 return resultobj;
6172 fail:
6173 {
6174 if (temp2)
6175 delete arg2;
6176 }
6177 return NULL;
6178 }
6179
6180
6181 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6182 PyObject *resultobj;
6183 wxToolTip *arg1 = (wxToolTip *) 0 ;
6184 wxString result;
6185 PyObject * obj0 = 0 ;
6186 char *kwnames[] = {
6187 (char *) "self", NULL
6188 };
6189
6190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6192 if (SWIG_arg_fail(1)) SWIG_fail;
6193 {
6194 PyThreadState* __tstate = wxPyBeginAllowThreads();
6195 result = (arg1)->GetTip();
6196
6197 wxPyEndAllowThreads(__tstate);
6198 if (PyErr_Occurred()) SWIG_fail;
6199 }
6200 {
6201 #if wxUSE_UNICODE
6202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6203 #else
6204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6205 #endif
6206 }
6207 return resultobj;
6208 fail:
6209 return NULL;
6210 }
6211
6212
6213 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6214 PyObject *resultobj;
6215 wxToolTip *arg1 = (wxToolTip *) 0 ;
6216 wxWindow *result;
6217 PyObject * obj0 = 0 ;
6218 char *kwnames[] = {
6219 (char *) "self", NULL
6220 };
6221
6222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6224 if (SWIG_arg_fail(1)) SWIG_fail;
6225 {
6226 PyThreadState* __tstate = wxPyBeginAllowThreads();
6227 result = (wxWindow *)(arg1)->GetWindow();
6228
6229 wxPyEndAllowThreads(__tstate);
6230 if (PyErr_Occurred()) SWIG_fail;
6231 }
6232 {
6233 resultobj = wxPyMake_wxObject(result, 0);
6234 }
6235 return resultobj;
6236 fail:
6237 return NULL;
6238 }
6239
6240
6241 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6242 PyObject *resultobj;
6243 bool arg1 ;
6244 PyObject * obj0 = 0 ;
6245 char *kwnames[] = {
6246 (char *) "flag", NULL
6247 };
6248
6249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6250 {
6251 arg1 = (bool)(SWIG_As_bool(obj0));
6252 if (SWIG_arg_fail(1)) SWIG_fail;
6253 }
6254 {
6255 PyThreadState* __tstate = wxPyBeginAllowThreads();
6256 wxToolTip::Enable(arg1);
6257
6258 wxPyEndAllowThreads(__tstate);
6259 if (PyErr_Occurred()) SWIG_fail;
6260 }
6261 Py_INCREF(Py_None); resultobj = Py_None;
6262 return resultobj;
6263 fail:
6264 return NULL;
6265 }
6266
6267
6268 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6269 PyObject *resultobj;
6270 long arg1 ;
6271 PyObject * obj0 = 0 ;
6272 char *kwnames[] = {
6273 (char *) "milliseconds", NULL
6274 };
6275
6276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6277 {
6278 arg1 = (long)(SWIG_As_long(obj0));
6279 if (SWIG_arg_fail(1)) SWIG_fail;
6280 }
6281 {
6282 PyThreadState* __tstate = wxPyBeginAllowThreads();
6283 wxToolTip::SetDelay(arg1);
6284
6285 wxPyEndAllowThreads(__tstate);
6286 if (PyErr_Occurred()) SWIG_fail;
6287 }
6288 Py_INCREF(Py_None); resultobj = Py_None;
6289 return resultobj;
6290 fail:
6291 return NULL;
6292 }
6293
6294
6295 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6296 PyObject *obj;
6297 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6298 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6299 Py_INCREF(obj);
6300 return Py_BuildValue((char *)"");
6301 }
6302 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6303 PyObject *resultobj;
6304 wxWindow *arg1 = (wxWindow *) 0 ;
6305 wxSize *arg2 = 0 ;
6306 wxCaret *result;
6307 wxSize temp2 ;
6308 PyObject * obj0 = 0 ;
6309 PyObject * obj1 = 0 ;
6310 char *kwnames[] = {
6311 (char *) "window",(char *) "size", NULL
6312 };
6313
6314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6316 if (SWIG_arg_fail(1)) SWIG_fail;
6317 {
6318 arg2 = &temp2;
6319 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6320 }
6321 {
6322 if (!wxPyCheckForApp()) SWIG_fail;
6323 PyThreadState* __tstate = wxPyBeginAllowThreads();
6324 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6325
6326 wxPyEndAllowThreads(__tstate);
6327 if (PyErr_Occurred()) SWIG_fail;
6328 }
6329 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6330 return resultobj;
6331 fail:
6332 return NULL;
6333 }
6334
6335
6336 static PyObject *_wrap_delete_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6337 PyObject *resultobj;
6338 wxCaret *arg1 = (wxCaret *) 0 ;
6339 PyObject * obj0 = 0 ;
6340 char *kwnames[] = {
6341 (char *) "self", NULL
6342 };
6343
6344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Caret",kwnames,&obj0)) goto fail;
6345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6346 if (SWIG_arg_fail(1)) SWIG_fail;
6347 {
6348 PyThreadState* __tstate = wxPyBeginAllowThreads();
6349 delete arg1;
6350
6351 wxPyEndAllowThreads(__tstate);
6352 if (PyErr_Occurred()) SWIG_fail;
6353 }
6354 Py_INCREF(Py_None); resultobj = Py_None;
6355 return resultobj;
6356 fail:
6357 return NULL;
6358 }
6359
6360
6361 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6362 PyObject *resultobj;
6363 wxCaret *arg1 = (wxCaret *) 0 ;
6364 bool result;
6365 PyObject * obj0 = 0 ;
6366 char *kwnames[] = {
6367 (char *) "self", NULL
6368 };
6369
6370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6372 if (SWIG_arg_fail(1)) SWIG_fail;
6373 {
6374 PyThreadState* __tstate = wxPyBeginAllowThreads();
6375 result = (bool)(arg1)->IsOk();
6376
6377 wxPyEndAllowThreads(__tstate);
6378 if (PyErr_Occurred()) SWIG_fail;
6379 }
6380 {
6381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6382 }
6383 return resultobj;
6384 fail:
6385 return NULL;
6386 }
6387
6388
6389 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6390 PyObject *resultobj;
6391 wxCaret *arg1 = (wxCaret *) 0 ;
6392 bool result;
6393 PyObject * obj0 = 0 ;
6394 char *kwnames[] = {
6395 (char *) "self", NULL
6396 };
6397
6398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6400 if (SWIG_arg_fail(1)) SWIG_fail;
6401 {
6402 PyThreadState* __tstate = wxPyBeginAllowThreads();
6403 result = (bool)(arg1)->IsVisible();
6404
6405 wxPyEndAllowThreads(__tstate);
6406 if (PyErr_Occurred()) SWIG_fail;
6407 }
6408 {
6409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6410 }
6411 return resultobj;
6412 fail:
6413 return NULL;
6414 }
6415
6416
6417 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6418 PyObject *resultobj;
6419 wxCaret *arg1 = (wxCaret *) 0 ;
6420 wxPoint result;
6421 PyObject * obj0 = 0 ;
6422 char *kwnames[] = {
6423 (char *) "self", NULL
6424 };
6425
6426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6428 if (SWIG_arg_fail(1)) SWIG_fail;
6429 {
6430 PyThreadState* __tstate = wxPyBeginAllowThreads();
6431 result = (arg1)->GetPosition();
6432
6433 wxPyEndAllowThreads(__tstate);
6434 if (PyErr_Occurred()) SWIG_fail;
6435 }
6436 {
6437 wxPoint * resultptr;
6438 resultptr = new wxPoint((wxPoint &)(result));
6439 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6440 }
6441 return resultobj;
6442 fail:
6443 return NULL;
6444 }
6445
6446
6447 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6448 PyObject *resultobj;
6449 wxCaret *arg1 = (wxCaret *) 0 ;
6450 int *arg2 = (int *) 0 ;
6451 int *arg3 = (int *) 0 ;
6452 int temp2 ;
6453 int res2 = 0 ;
6454 int temp3 ;
6455 int res3 = 0 ;
6456 PyObject * obj0 = 0 ;
6457 char *kwnames[] = {
6458 (char *) "self", NULL
6459 };
6460
6461 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6462 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6465 if (SWIG_arg_fail(1)) SWIG_fail;
6466 {
6467 PyThreadState* __tstate = wxPyBeginAllowThreads();
6468 (arg1)->GetPosition(arg2,arg3);
6469
6470 wxPyEndAllowThreads(__tstate);
6471 if (PyErr_Occurred()) SWIG_fail;
6472 }
6473 Py_INCREF(Py_None); resultobj = Py_None;
6474 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6475 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6476 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6477 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6478 return resultobj;
6479 fail:
6480 return NULL;
6481 }
6482
6483
6484 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6485 PyObject *resultobj;
6486 wxCaret *arg1 = (wxCaret *) 0 ;
6487 wxSize result;
6488 PyObject * obj0 = 0 ;
6489 char *kwnames[] = {
6490 (char *) "self", NULL
6491 };
6492
6493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6495 if (SWIG_arg_fail(1)) SWIG_fail;
6496 {
6497 PyThreadState* __tstate = wxPyBeginAllowThreads();
6498 result = (arg1)->GetSize();
6499
6500 wxPyEndAllowThreads(__tstate);
6501 if (PyErr_Occurred()) SWIG_fail;
6502 }
6503 {
6504 wxSize * resultptr;
6505 resultptr = new wxSize((wxSize &)(result));
6506 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6507 }
6508 return resultobj;
6509 fail:
6510 return NULL;
6511 }
6512
6513
6514 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6515 PyObject *resultobj;
6516 wxCaret *arg1 = (wxCaret *) 0 ;
6517 int *arg2 = (int *) 0 ;
6518 int *arg3 = (int *) 0 ;
6519 int temp2 ;
6520 int res2 = 0 ;
6521 int temp3 ;
6522 int res3 = 0 ;
6523 PyObject * obj0 = 0 ;
6524 char *kwnames[] = {
6525 (char *) "self", NULL
6526 };
6527
6528 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6529 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6532 if (SWIG_arg_fail(1)) SWIG_fail;
6533 {
6534 PyThreadState* __tstate = wxPyBeginAllowThreads();
6535 (arg1)->GetSize(arg2,arg3);
6536
6537 wxPyEndAllowThreads(__tstate);
6538 if (PyErr_Occurred()) SWIG_fail;
6539 }
6540 Py_INCREF(Py_None); resultobj = Py_None;
6541 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6542 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6543 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6544 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6545 return resultobj;
6546 fail:
6547 return NULL;
6548 }
6549
6550
6551 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6552 PyObject *resultobj;
6553 wxCaret *arg1 = (wxCaret *) 0 ;
6554 wxWindow *result;
6555 PyObject * obj0 = 0 ;
6556 char *kwnames[] = {
6557 (char *) "self", NULL
6558 };
6559
6560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6562 if (SWIG_arg_fail(1)) SWIG_fail;
6563 {
6564 PyThreadState* __tstate = wxPyBeginAllowThreads();
6565 result = (wxWindow *)(arg1)->GetWindow();
6566
6567 wxPyEndAllowThreads(__tstate);
6568 if (PyErr_Occurred()) SWIG_fail;
6569 }
6570 {
6571 resultobj = wxPyMake_wxObject(result, 0);
6572 }
6573 return resultobj;
6574 fail:
6575 return NULL;
6576 }
6577
6578
6579 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6580 PyObject *resultobj;
6581 wxCaret *arg1 = (wxCaret *) 0 ;
6582 int arg2 ;
6583 int arg3 ;
6584 PyObject * obj0 = 0 ;
6585 PyObject * obj1 = 0 ;
6586 PyObject * obj2 = 0 ;
6587 char *kwnames[] = {
6588 (char *) "self",(char *) "x",(char *) "y", NULL
6589 };
6590
6591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6593 if (SWIG_arg_fail(1)) SWIG_fail;
6594 {
6595 arg2 = (int)(SWIG_As_int(obj1));
6596 if (SWIG_arg_fail(2)) SWIG_fail;
6597 }
6598 {
6599 arg3 = (int)(SWIG_As_int(obj2));
6600 if (SWIG_arg_fail(3)) SWIG_fail;
6601 }
6602 {
6603 PyThreadState* __tstate = wxPyBeginAllowThreads();
6604 (arg1)->Move(arg2,arg3);
6605
6606 wxPyEndAllowThreads(__tstate);
6607 if (PyErr_Occurred()) SWIG_fail;
6608 }
6609 Py_INCREF(Py_None); resultobj = Py_None;
6610 return resultobj;
6611 fail:
6612 return NULL;
6613 }
6614
6615
6616 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6617 PyObject *resultobj;
6618 wxCaret *arg1 = (wxCaret *) 0 ;
6619 wxPoint *arg2 = 0 ;
6620 wxPoint temp2 ;
6621 PyObject * obj0 = 0 ;
6622 PyObject * obj1 = 0 ;
6623 char *kwnames[] = {
6624 (char *) "self",(char *) "pt", NULL
6625 };
6626
6627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6629 if (SWIG_arg_fail(1)) SWIG_fail;
6630 {
6631 arg2 = &temp2;
6632 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6633 }
6634 {
6635 PyThreadState* __tstate = wxPyBeginAllowThreads();
6636 (arg1)->Move((wxPoint const &)*arg2);
6637
6638 wxPyEndAllowThreads(__tstate);
6639 if (PyErr_Occurred()) SWIG_fail;
6640 }
6641 Py_INCREF(Py_None); resultobj = Py_None;
6642 return resultobj;
6643 fail:
6644 return NULL;
6645 }
6646
6647
6648 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6649 PyObject *resultobj;
6650 wxCaret *arg1 = (wxCaret *) 0 ;
6651 int arg2 ;
6652 int arg3 ;
6653 PyObject * obj0 = 0 ;
6654 PyObject * obj1 = 0 ;
6655 PyObject * obj2 = 0 ;
6656 char *kwnames[] = {
6657 (char *) "self",(char *) "width",(char *) "height", NULL
6658 };
6659
6660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6662 if (SWIG_arg_fail(1)) SWIG_fail;
6663 {
6664 arg2 = (int)(SWIG_As_int(obj1));
6665 if (SWIG_arg_fail(2)) SWIG_fail;
6666 }
6667 {
6668 arg3 = (int)(SWIG_As_int(obj2));
6669 if (SWIG_arg_fail(3)) SWIG_fail;
6670 }
6671 {
6672 PyThreadState* __tstate = wxPyBeginAllowThreads();
6673 (arg1)->SetSize(arg2,arg3);
6674
6675 wxPyEndAllowThreads(__tstate);
6676 if (PyErr_Occurred()) SWIG_fail;
6677 }
6678 Py_INCREF(Py_None); resultobj = Py_None;
6679 return resultobj;
6680 fail:
6681 return NULL;
6682 }
6683
6684
6685 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6686 PyObject *resultobj;
6687 wxCaret *arg1 = (wxCaret *) 0 ;
6688 wxSize *arg2 = 0 ;
6689 wxSize temp2 ;
6690 PyObject * obj0 = 0 ;
6691 PyObject * obj1 = 0 ;
6692 char *kwnames[] = {
6693 (char *) "self",(char *) "size", NULL
6694 };
6695
6696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6698 if (SWIG_arg_fail(1)) SWIG_fail;
6699 {
6700 arg2 = &temp2;
6701 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6702 }
6703 {
6704 PyThreadState* __tstate = wxPyBeginAllowThreads();
6705 (arg1)->SetSize((wxSize const &)*arg2);
6706
6707 wxPyEndAllowThreads(__tstate);
6708 if (PyErr_Occurred()) SWIG_fail;
6709 }
6710 Py_INCREF(Py_None); resultobj = Py_None;
6711 return resultobj;
6712 fail:
6713 return NULL;
6714 }
6715
6716
6717 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6718 PyObject *resultobj;
6719 wxCaret *arg1 = (wxCaret *) 0 ;
6720 int arg2 = (int) true ;
6721 PyObject * obj0 = 0 ;
6722 PyObject * obj1 = 0 ;
6723 char *kwnames[] = {
6724 (char *) "self",(char *) "show", NULL
6725 };
6726
6727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6729 if (SWIG_arg_fail(1)) SWIG_fail;
6730 if (obj1) {
6731 {
6732 arg2 = (int)(SWIG_As_int(obj1));
6733 if (SWIG_arg_fail(2)) SWIG_fail;
6734 }
6735 }
6736 {
6737 PyThreadState* __tstate = wxPyBeginAllowThreads();
6738 (arg1)->Show(arg2);
6739
6740 wxPyEndAllowThreads(__tstate);
6741 if (PyErr_Occurred()) SWIG_fail;
6742 }
6743 Py_INCREF(Py_None); resultobj = Py_None;
6744 return resultobj;
6745 fail:
6746 return NULL;
6747 }
6748
6749
6750 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6751 PyObject *resultobj;
6752 wxCaret *arg1 = (wxCaret *) 0 ;
6753 PyObject * obj0 = 0 ;
6754 char *kwnames[] = {
6755 (char *) "self", NULL
6756 };
6757
6758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6760 if (SWIG_arg_fail(1)) SWIG_fail;
6761 {
6762 PyThreadState* __tstate = wxPyBeginAllowThreads();
6763 (arg1)->Hide();
6764
6765 wxPyEndAllowThreads(__tstate);
6766 if (PyErr_Occurred()) SWIG_fail;
6767 }
6768 Py_INCREF(Py_None); resultobj = Py_None;
6769 return resultobj;
6770 fail:
6771 return NULL;
6772 }
6773
6774
6775 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6776 PyObject *obj;
6777 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6778 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6779 Py_INCREF(obj);
6780 return Py_BuildValue((char *)"");
6781 }
6782 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6783 PyObject *resultobj;
6784 int result;
6785 char *kwnames[] = {
6786 NULL
6787 };
6788
6789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6790 {
6791 PyThreadState* __tstate = wxPyBeginAllowThreads();
6792 result = (int)wxCaret_GetBlinkTime();
6793
6794 wxPyEndAllowThreads(__tstate);
6795 if (PyErr_Occurred()) SWIG_fail;
6796 }
6797 {
6798 resultobj = SWIG_From_int((int)(result));
6799 }
6800 return resultobj;
6801 fail:
6802 return NULL;
6803 }
6804
6805
6806 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6807 PyObject *resultobj;
6808 int arg1 ;
6809 PyObject * obj0 = 0 ;
6810 char *kwnames[] = {
6811 (char *) "milliseconds", NULL
6812 };
6813
6814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6815 {
6816 arg1 = (int)(SWIG_As_int(obj0));
6817 if (SWIG_arg_fail(1)) SWIG_fail;
6818 }
6819 {
6820 PyThreadState* __tstate = wxPyBeginAllowThreads();
6821 wxCaret_SetBlinkTime(arg1);
6822
6823 wxPyEndAllowThreads(__tstate);
6824 if (PyErr_Occurred()) SWIG_fail;
6825 }
6826 Py_INCREF(Py_None); resultobj = Py_None;
6827 return resultobj;
6828 fail:
6829 return NULL;
6830 }
6831
6832
6833 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6834 PyObject *resultobj;
6835 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6836 wxBusyCursor *result;
6837 PyObject * obj0 = 0 ;
6838 char *kwnames[] = {
6839 (char *) "cursor", NULL
6840 };
6841
6842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6843 if (obj0) {
6844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6845 if (SWIG_arg_fail(1)) SWIG_fail;
6846 }
6847 {
6848 if (!wxPyCheckForApp()) SWIG_fail;
6849 PyThreadState* __tstate = wxPyBeginAllowThreads();
6850 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6851
6852 wxPyEndAllowThreads(__tstate);
6853 if (PyErr_Occurred()) SWIG_fail;
6854 }
6855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6856 return resultobj;
6857 fail:
6858 return NULL;
6859 }
6860
6861
6862 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6863 PyObject *resultobj;
6864 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6865 PyObject * obj0 = 0 ;
6866 char *kwnames[] = {
6867 (char *) "self", NULL
6868 };
6869
6870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6872 if (SWIG_arg_fail(1)) SWIG_fail;
6873 {
6874 PyThreadState* __tstate = wxPyBeginAllowThreads();
6875 delete arg1;
6876
6877 wxPyEndAllowThreads(__tstate);
6878 if (PyErr_Occurred()) SWIG_fail;
6879 }
6880 Py_INCREF(Py_None); resultobj = Py_None;
6881 return resultobj;
6882 fail:
6883 return NULL;
6884 }
6885
6886
6887 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6888 PyObject *obj;
6889 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6890 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6891 Py_INCREF(obj);
6892 return Py_BuildValue((char *)"");
6893 }
6894 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6895 PyObject *resultobj;
6896 wxWindow *arg1 = (wxWindow *) NULL ;
6897 wxWindowDisabler *result;
6898 PyObject * obj0 = 0 ;
6899 char *kwnames[] = {
6900 (char *) "winToSkip", NULL
6901 };
6902
6903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6904 if (obj0) {
6905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6906 if (SWIG_arg_fail(1)) SWIG_fail;
6907 }
6908 {
6909 if (!wxPyCheckForApp()) SWIG_fail;
6910 PyThreadState* __tstate = wxPyBeginAllowThreads();
6911 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6912
6913 wxPyEndAllowThreads(__tstate);
6914 if (PyErr_Occurred()) SWIG_fail;
6915 }
6916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6917 return resultobj;
6918 fail:
6919 return NULL;
6920 }
6921
6922
6923 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6924 PyObject *resultobj;
6925 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6926 PyObject * obj0 = 0 ;
6927 char *kwnames[] = {
6928 (char *) "self", NULL
6929 };
6930
6931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6933 if (SWIG_arg_fail(1)) SWIG_fail;
6934 {
6935 PyThreadState* __tstate = wxPyBeginAllowThreads();
6936 delete arg1;
6937
6938 wxPyEndAllowThreads(__tstate);
6939 if (PyErr_Occurred()) SWIG_fail;
6940 }
6941 Py_INCREF(Py_None); resultobj = Py_None;
6942 return resultobj;
6943 fail:
6944 return NULL;
6945 }
6946
6947
6948 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6949 PyObject *obj;
6950 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6951 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6952 Py_INCREF(obj);
6953 return Py_BuildValue((char *)"");
6954 }
6955 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6956 PyObject *resultobj;
6957 wxString *arg1 = 0 ;
6958 wxBusyInfo *result;
6959 bool temp1 = false ;
6960 PyObject * obj0 = 0 ;
6961 char *kwnames[] = {
6962 (char *) "message", NULL
6963 };
6964
6965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
6966 {
6967 arg1 = wxString_in_helper(obj0);
6968 if (arg1 == NULL) SWIG_fail;
6969 temp1 = true;
6970 }
6971 {
6972 if (!wxPyCheckForApp()) SWIG_fail;
6973 PyThreadState* __tstate = wxPyBeginAllowThreads();
6974 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
6975
6976 wxPyEndAllowThreads(__tstate);
6977 if (PyErr_Occurred()) SWIG_fail;
6978 }
6979 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
6980 {
6981 if (temp1)
6982 delete arg1;
6983 }
6984 return resultobj;
6985 fail:
6986 {
6987 if (temp1)
6988 delete arg1;
6989 }
6990 return NULL;
6991 }
6992
6993
6994 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6995 PyObject *resultobj;
6996 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
6997 PyObject * obj0 = 0 ;
6998 char *kwnames[] = {
6999 (char *) "self", NULL
7000 };
7001
7002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7004 if (SWIG_arg_fail(1)) SWIG_fail;
7005 {
7006 PyThreadState* __tstate = wxPyBeginAllowThreads();
7007 delete arg1;
7008
7009 wxPyEndAllowThreads(__tstate);
7010 if (PyErr_Occurred()) SWIG_fail;
7011 }
7012 Py_INCREF(Py_None); resultobj = Py_None;
7013 return resultobj;
7014 fail:
7015 return NULL;
7016 }
7017
7018
7019 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7020 PyObject *obj;
7021 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7022 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7023 Py_INCREF(obj);
7024 return Py_BuildValue((char *)"");
7025 }
7026 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7027 PyObject *resultobj;
7028 wxStopWatch *result;
7029 char *kwnames[] = {
7030 NULL
7031 };
7032
7033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7034 {
7035 PyThreadState* __tstate = wxPyBeginAllowThreads();
7036 result = (wxStopWatch *)new wxStopWatch();
7037
7038 wxPyEndAllowThreads(__tstate);
7039 if (PyErr_Occurred()) SWIG_fail;
7040 }
7041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7042 return resultobj;
7043 fail:
7044 return NULL;
7045 }
7046
7047
7048 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7049 PyObject *resultobj;
7050 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7051 long arg2 = (long) 0 ;
7052 PyObject * obj0 = 0 ;
7053 PyObject * obj1 = 0 ;
7054 char *kwnames[] = {
7055 (char *) "self",(char *) "t0", NULL
7056 };
7057
7058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7060 if (SWIG_arg_fail(1)) SWIG_fail;
7061 if (obj1) {
7062 {
7063 arg2 = (long)(SWIG_As_long(obj1));
7064 if (SWIG_arg_fail(2)) SWIG_fail;
7065 }
7066 }
7067 {
7068 PyThreadState* __tstate = wxPyBeginAllowThreads();
7069 (arg1)->Start(arg2);
7070
7071 wxPyEndAllowThreads(__tstate);
7072 if (PyErr_Occurred()) SWIG_fail;
7073 }
7074 Py_INCREF(Py_None); resultobj = Py_None;
7075 return resultobj;
7076 fail:
7077 return NULL;
7078 }
7079
7080
7081 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7082 PyObject *resultobj;
7083 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7084 PyObject * obj0 = 0 ;
7085 char *kwnames[] = {
7086 (char *) "self", NULL
7087 };
7088
7089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7091 if (SWIG_arg_fail(1)) SWIG_fail;
7092 {
7093 PyThreadState* __tstate = wxPyBeginAllowThreads();
7094 (arg1)->Pause();
7095
7096 wxPyEndAllowThreads(__tstate);
7097 if (PyErr_Occurred()) SWIG_fail;
7098 }
7099 Py_INCREF(Py_None); resultobj = Py_None;
7100 return resultobj;
7101 fail:
7102 return NULL;
7103 }
7104
7105
7106 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7107 PyObject *resultobj;
7108 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7109 PyObject * obj0 = 0 ;
7110 char *kwnames[] = {
7111 (char *) "self", NULL
7112 };
7113
7114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7116 if (SWIG_arg_fail(1)) SWIG_fail;
7117 {
7118 PyThreadState* __tstate = wxPyBeginAllowThreads();
7119 (arg1)->Resume();
7120
7121 wxPyEndAllowThreads(__tstate);
7122 if (PyErr_Occurred()) SWIG_fail;
7123 }
7124 Py_INCREF(Py_None); resultobj = Py_None;
7125 return resultobj;
7126 fail:
7127 return NULL;
7128 }
7129
7130
7131 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7132 PyObject *resultobj;
7133 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7134 long result;
7135 PyObject * obj0 = 0 ;
7136 char *kwnames[] = {
7137 (char *) "self", NULL
7138 };
7139
7140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7142 if (SWIG_arg_fail(1)) SWIG_fail;
7143 {
7144 PyThreadState* __tstate = wxPyBeginAllowThreads();
7145 result = (long)((wxStopWatch const *)arg1)->Time();
7146
7147 wxPyEndAllowThreads(__tstate);
7148 if (PyErr_Occurred()) SWIG_fail;
7149 }
7150 {
7151 resultobj = SWIG_From_long((long)(result));
7152 }
7153 return resultobj;
7154 fail:
7155 return NULL;
7156 }
7157
7158
7159 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7160 PyObject *obj;
7161 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7162 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7163 Py_INCREF(obj);
7164 return Py_BuildValue((char *)"");
7165 }
7166 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7167 PyObject *resultobj;
7168 int arg1 = (int) 9 ;
7169 int arg2 = (int) wxID_FILE1 ;
7170 wxFileHistory *result;
7171 PyObject * obj0 = 0 ;
7172 PyObject * obj1 = 0 ;
7173 char *kwnames[] = {
7174 (char *) "maxFiles",(char *) "idBase", NULL
7175 };
7176
7177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7178 if (obj0) {
7179 {
7180 arg1 = (int)(SWIG_As_int(obj0));
7181 if (SWIG_arg_fail(1)) SWIG_fail;
7182 }
7183 }
7184 if (obj1) {
7185 {
7186 arg2 = (int)(SWIG_As_int(obj1));
7187 if (SWIG_arg_fail(2)) SWIG_fail;
7188 }
7189 }
7190 {
7191 PyThreadState* __tstate = wxPyBeginAllowThreads();
7192 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7193
7194 wxPyEndAllowThreads(__tstate);
7195 if (PyErr_Occurred()) SWIG_fail;
7196 }
7197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7198 return resultobj;
7199 fail:
7200 return NULL;
7201 }
7202
7203
7204 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7205 PyObject *resultobj;
7206 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7207 PyObject * obj0 = 0 ;
7208 char *kwnames[] = {
7209 (char *) "self", NULL
7210 };
7211
7212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7214 if (SWIG_arg_fail(1)) SWIG_fail;
7215 {
7216 PyThreadState* __tstate = wxPyBeginAllowThreads();
7217 delete arg1;
7218
7219 wxPyEndAllowThreads(__tstate);
7220 if (PyErr_Occurred()) SWIG_fail;
7221 }
7222 Py_INCREF(Py_None); resultobj = Py_None;
7223 return resultobj;
7224 fail:
7225 return NULL;
7226 }
7227
7228
7229 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7230 PyObject *resultobj;
7231 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7232 wxString *arg2 = 0 ;
7233 bool temp2 = false ;
7234 PyObject * obj0 = 0 ;
7235 PyObject * obj1 = 0 ;
7236 char *kwnames[] = {
7237 (char *) "self",(char *) "file", NULL
7238 };
7239
7240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7242 if (SWIG_arg_fail(1)) SWIG_fail;
7243 {
7244 arg2 = wxString_in_helper(obj1);
7245 if (arg2 == NULL) SWIG_fail;
7246 temp2 = true;
7247 }
7248 {
7249 PyThreadState* __tstate = wxPyBeginAllowThreads();
7250 (arg1)->AddFileToHistory((wxString const &)*arg2);
7251
7252 wxPyEndAllowThreads(__tstate);
7253 if (PyErr_Occurred()) SWIG_fail;
7254 }
7255 Py_INCREF(Py_None); resultobj = Py_None;
7256 {
7257 if (temp2)
7258 delete arg2;
7259 }
7260 return resultobj;
7261 fail:
7262 {
7263 if (temp2)
7264 delete arg2;
7265 }
7266 return NULL;
7267 }
7268
7269
7270 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7271 PyObject *resultobj;
7272 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7273 int arg2 ;
7274 PyObject * obj0 = 0 ;
7275 PyObject * obj1 = 0 ;
7276 char *kwnames[] = {
7277 (char *) "self",(char *) "i", NULL
7278 };
7279
7280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7282 if (SWIG_arg_fail(1)) SWIG_fail;
7283 {
7284 arg2 = (int)(SWIG_As_int(obj1));
7285 if (SWIG_arg_fail(2)) SWIG_fail;
7286 }
7287 {
7288 PyThreadState* __tstate = wxPyBeginAllowThreads();
7289 (arg1)->RemoveFileFromHistory(arg2);
7290
7291 wxPyEndAllowThreads(__tstate);
7292 if (PyErr_Occurred()) SWIG_fail;
7293 }
7294 Py_INCREF(Py_None); resultobj = Py_None;
7295 return resultobj;
7296 fail:
7297 return NULL;
7298 }
7299
7300
7301 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7302 PyObject *resultobj;
7303 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7304 int result;
7305 PyObject * obj0 = 0 ;
7306 char *kwnames[] = {
7307 (char *) "self", NULL
7308 };
7309
7310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7312 if (SWIG_arg_fail(1)) SWIG_fail;
7313 {
7314 PyThreadState* __tstate = wxPyBeginAllowThreads();
7315 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7316
7317 wxPyEndAllowThreads(__tstate);
7318 if (PyErr_Occurred()) SWIG_fail;
7319 }
7320 {
7321 resultobj = SWIG_From_int((int)(result));
7322 }
7323 return resultobj;
7324 fail:
7325 return NULL;
7326 }
7327
7328
7329 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7330 PyObject *resultobj;
7331 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7332 wxMenu *arg2 = (wxMenu *) 0 ;
7333 PyObject * obj0 = 0 ;
7334 PyObject * obj1 = 0 ;
7335 char *kwnames[] = {
7336 (char *) "self",(char *) "menu", NULL
7337 };
7338
7339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7341 if (SWIG_arg_fail(1)) SWIG_fail;
7342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7343 if (SWIG_arg_fail(2)) SWIG_fail;
7344 {
7345 PyThreadState* __tstate = wxPyBeginAllowThreads();
7346 (arg1)->UseMenu(arg2);
7347
7348 wxPyEndAllowThreads(__tstate);
7349 if (PyErr_Occurred()) SWIG_fail;
7350 }
7351 Py_INCREF(Py_None); resultobj = Py_None;
7352 return resultobj;
7353 fail:
7354 return NULL;
7355 }
7356
7357
7358 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7359 PyObject *resultobj;
7360 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7361 wxMenu *arg2 = (wxMenu *) 0 ;
7362 PyObject * obj0 = 0 ;
7363 PyObject * obj1 = 0 ;
7364 char *kwnames[] = {
7365 (char *) "self",(char *) "menu", NULL
7366 };
7367
7368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7370 if (SWIG_arg_fail(1)) SWIG_fail;
7371 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7372 if (SWIG_arg_fail(2)) SWIG_fail;
7373 {
7374 PyThreadState* __tstate = wxPyBeginAllowThreads();
7375 (arg1)->RemoveMenu(arg2);
7376
7377 wxPyEndAllowThreads(__tstate);
7378 if (PyErr_Occurred()) SWIG_fail;
7379 }
7380 Py_INCREF(Py_None); resultobj = Py_None;
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj;
7389 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7390 wxConfigBase *arg2 = 0 ;
7391 PyObject * obj0 = 0 ;
7392 PyObject * obj1 = 0 ;
7393 char *kwnames[] = {
7394 (char *) "self",(char *) "config", NULL
7395 };
7396
7397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7399 if (SWIG_arg_fail(1)) SWIG_fail;
7400 {
7401 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7402 if (SWIG_arg_fail(2)) SWIG_fail;
7403 if (arg2 == NULL) {
7404 SWIG_null_ref("wxConfigBase");
7405 }
7406 if (SWIG_arg_fail(2)) SWIG_fail;
7407 }
7408 {
7409 PyThreadState* __tstate = wxPyBeginAllowThreads();
7410 (arg1)->Load(*arg2);
7411
7412 wxPyEndAllowThreads(__tstate);
7413 if (PyErr_Occurred()) SWIG_fail;
7414 }
7415 Py_INCREF(Py_None); resultobj = Py_None;
7416 return resultobj;
7417 fail:
7418 return NULL;
7419 }
7420
7421
7422 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7423 PyObject *resultobj;
7424 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7425 wxConfigBase *arg2 = 0 ;
7426 PyObject * obj0 = 0 ;
7427 PyObject * obj1 = 0 ;
7428 char *kwnames[] = {
7429 (char *) "self",(char *) "config", NULL
7430 };
7431
7432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7434 if (SWIG_arg_fail(1)) SWIG_fail;
7435 {
7436 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7437 if (SWIG_arg_fail(2)) SWIG_fail;
7438 if (arg2 == NULL) {
7439 SWIG_null_ref("wxConfigBase");
7440 }
7441 if (SWIG_arg_fail(2)) SWIG_fail;
7442 }
7443 {
7444 PyThreadState* __tstate = wxPyBeginAllowThreads();
7445 (arg1)->Save(*arg2);
7446
7447 wxPyEndAllowThreads(__tstate);
7448 if (PyErr_Occurred()) SWIG_fail;
7449 }
7450 Py_INCREF(Py_None); resultobj = Py_None;
7451 return resultobj;
7452 fail:
7453 return NULL;
7454 }
7455
7456
7457 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7458 PyObject *resultobj;
7459 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7460 PyObject * obj0 = 0 ;
7461 char *kwnames[] = {
7462 (char *) "self", NULL
7463 };
7464
7465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7467 if (SWIG_arg_fail(1)) SWIG_fail;
7468 {
7469 PyThreadState* __tstate = wxPyBeginAllowThreads();
7470 (arg1)->AddFilesToMenu();
7471
7472 wxPyEndAllowThreads(__tstate);
7473 if (PyErr_Occurred()) SWIG_fail;
7474 }
7475 Py_INCREF(Py_None); resultobj = Py_None;
7476 return resultobj;
7477 fail:
7478 return NULL;
7479 }
7480
7481
7482 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7483 PyObject *resultobj;
7484 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7485 wxMenu *arg2 = (wxMenu *) 0 ;
7486 PyObject * obj0 = 0 ;
7487 PyObject * obj1 = 0 ;
7488 char *kwnames[] = {
7489 (char *) "self",(char *) "menu", NULL
7490 };
7491
7492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7494 if (SWIG_arg_fail(1)) SWIG_fail;
7495 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7496 if (SWIG_arg_fail(2)) SWIG_fail;
7497 {
7498 PyThreadState* __tstate = wxPyBeginAllowThreads();
7499 (arg1)->AddFilesToMenu(arg2);
7500
7501 wxPyEndAllowThreads(__tstate);
7502 if (PyErr_Occurred()) SWIG_fail;
7503 }
7504 Py_INCREF(Py_None); resultobj = Py_None;
7505 return resultobj;
7506 fail:
7507 return NULL;
7508 }
7509
7510
7511 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7512 PyObject *resultobj;
7513 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7514 int arg2 ;
7515 wxString result;
7516 PyObject * obj0 = 0 ;
7517 PyObject * obj1 = 0 ;
7518 char *kwnames[] = {
7519 (char *) "self",(char *) "i", NULL
7520 };
7521
7522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7524 if (SWIG_arg_fail(1)) SWIG_fail;
7525 {
7526 arg2 = (int)(SWIG_As_int(obj1));
7527 if (SWIG_arg_fail(2)) SWIG_fail;
7528 }
7529 {
7530 PyThreadState* __tstate = wxPyBeginAllowThreads();
7531 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7532
7533 wxPyEndAllowThreads(__tstate);
7534 if (PyErr_Occurred()) SWIG_fail;
7535 }
7536 {
7537 #if wxUSE_UNICODE
7538 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7539 #else
7540 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7541 #endif
7542 }
7543 return resultobj;
7544 fail:
7545 return NULL;
7546 }
7547
7548
7549 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7550 PyObject *resultobj;
7551 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7552 int result;
7553 PyObject * obj0 = 0 ;
7554 char *kwnames[] = {
7555 (char *) "self", NULL
7556 };
7557
7558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7560 if (SWIG_arg_fail(1)) SWIG_fail;
7561 {
7562 PyThreadState* __tstate = wxPyBeginAllowThreads();
7563 result = (int)((wxFileHistory const *)arg1)->GetCount();
7564
7565 wxPyEndAllowThreads(__tstate);
7566 if (PyErr_Occurred()) SWIG_fail;
7567 }
7568 {
7569 resultobj = SWIG_From_int((int)(result));
7570 }
7571 return resultobj;
7572 fail:
7573 return NULL;
7574 }
7575
7576
7577 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7578 PyObject *obj;
7579 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7580 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7581 Py_INCREF(obj);
7582 return Py_BuildValue((char *)"");
7583 }
7584 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7585 PyObject *resultobj;
7586 wxString *arg1 = 0 ;
7587 wxString const &arg2_defvalue = wxPyEmptyString ;
7588 wxString *arg2 = (wxString *) &arg2_defvalue ;
7589 wxSingleInstanceChecker *result;
7590 bool temp1 = false ;
7591 bool temp2 = false ;
7592 PyObject * obj0 = 0 ;
7593 PyObject * obj1 = 0 ;
7594 char *kwnames[] = {
7595 (char *) "name",(char *) "path", NULL
7596 };
7597
7598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7599 {
7600 arg1 = wxString_in_helper(obj0);
7601 if (arg1 == NULL) SWIG_fail;
7602 temp1 = true;
7603 }
7604 if (obj1) {
7605 {
7606 arg2 = wxString_in_helper(obj1);
7607 if (arg2 == NULL) SWIG_fail;
7608 temp2 = true;
7609 }
7610 }
7611 {
7612 PyThreadState* __tstate = wxPyBeginAllowThreads();
7613 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7614
7615 wxPyEndAllowThreads(__tstate);
7616 if (PyErr_Occurred()) SWIG_fail;
7617 }
7618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7619 {
7620 if (temp1)
7621 delete arg1;
7622 }
7623 {
7624 if (temp2)
7625 delete arg2;
7626 }
7627 return resultobj;
7628 fail:
7629 {
7630 if (temp1)
7631 delete arg1;
7632 }
7633 {
7634 if (temp2)
7635 delete arg2;
7636 }
7637 return NULL;
7638 }
7639
7640
7641 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7642 PyObject *resultobj;
7643 wxSingleInstanceChecker *result;
7644 char *kwnames[] = {
7645 NULL
7646 };
7647
7648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7649 {
7650 PyThreadState* __tstate = wxPyBeginAllowThreads();
7651 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7652
7653 wxPyEndAllowThreads(__tstate);
7654 if (PyErr_Occurred()) SWIG_fail;
7655 }
7656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7657 return resultobj;
7658 fail:
7659 return NULL;
7660 }
7661
7662
7663 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7664 PyObject *resultobj;
7665 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7666 PyObject * obj0 = 0 ;
7667 char *kwnames[] = {
7668 (char *) "self", NULL
7669 };
7670
7671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7673 if (SWIG_arg_fail(1)) SWIG_fail;
7674 {
7675 PyThreadState* __tstate = wxPyBeginAllowThreads();
7676 delete arg1;
7677
7678 wxPyEndAllowThreads(__tstate);
7679 if (PyErr_Occurred()) SWIG_fail;
7680 }
7681 Py_INCREF(Py_None); resultobj = Py_None;
7682 return resultobj;
7683 fail:
7684 return NULL;
7685 }
7686
7687
7688 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7689 PyObject *resultobj;
7690 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7691 wxString *arg2 = 0 ;
7692 wxString const &arg3_defvalue = wxPyEmptyString ;
7693 wxString *arg3 = (wxString *) &arg3_defvalue ;
7694 bool result;
7695 bool temp2 = false ;
7696 bool temp3 = false ;
7697 PyObject * obj0 = 0 ;
7698 PyObject * obj1 = 0 ;
7699 PyObject * obj2 = 0 ;
7700 char *kwnames[] = {
7701 (char *) "self",(char *) "name",(char *) "path", NULL
7702 };
7703
7704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7706 if (SWIG_arg_fail(1)) SWIG_fail;
7707 {
7708 arg2 = wxString_in_helper(obj1);
7709 if (arg2 == NULL) SWIG_fail;
7710 temp2 = true;
7711 }
7712 if (obj2) {
7713 {
7714 arg3 = wxString_in_helper(obj2);
7715 if (arg3 == NULL) SWIG_fail;
7716 temp3 = true;
7717 }
7718 }
7719 {
7720 PyThreadState* __tstate = wxPyBeginAllowThreads();
7721 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7722
7723 wxPyEndAllowThreads(__tstate);
7724 if (PyErr_Occurred()) SWIG_fail;
7725 }
7726 {
7727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7728 }
7729 {
7730 if (temp2)
7731 delete arg2;
7732 }
7733 {
7734 if (temp3)
7735 delete arg3;
7736 }
7737 return resultobj;
7738 fail:
7739 {
7740 if (temp2)
7741 delete arg2;
7742 }
7743 {
7744 if (temp3)
7745 delete arg3;
7746 }
7747 return NULL;
7748 }
7749
7750
7751 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7752 PyObject *resultobj;
7753 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7754 bool result;
7755 PyObject * obj0 = 0 ;
7756 char *kwnames[] = {
7757 (char *) "self", NULL
7758 };
7759
7760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7762 if (SWIG_arg_fail(1)) SWIG_fail;
7763 {
7764 PyThreadState* __tstate = wxPyBeginAllowThreads();
7765 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7766
7767 wxPyEndAllowThreads(__tstate);
7768 if (PyErr_Occurred()) SWIG_fail;
7769 }
7770 {
7771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7772 }
7773 return resultobj;
7774 fail:
7775 return NULL;
7776 }
7777
7778
7779 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7780 PyObject *obj;
7781 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7782 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7783 Py_INCREF(obj);
7784 return Py_BuildValue((char *)"");
7785 }
7786 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7787 PyObject *resultobj;
7788 wxWindow *arg1 = (wxWindow *) 0 ;
7789 wxDC *arg2 = 0 ;
7790 int arg3 ;
7791 PyObject * obj0 = 0 ;
7792 PyObject * obj1 = 0 ;
7793 PyObject * obj2 = 0 ;
7794 char *kwnames[] = {
7795 (char *) "window",(char *) "dc",(char *) "method", NULL
7796 };
7797
7798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DrawWindowOnDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
7799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7800 if (SWIG_arg_fail(1)) SWIG_fail;
7801 {
7802 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7803 if (SWIG_arg_fail(2)) SWIG_fail;
7804 if (arg2 == NULL) {
7805 SWIG_null_ref("wxDC");
7806 }
7807 if (SWIG_arg_fail(2)) SWIG_fail;
7808 }
7809 {
7810 arg3 = (int)(SWIG_As_int(obj2));
7811 if (SWIG_arg_fail(3)) SWIG_fail;
7812 }
7813 {
7814 PyThreadState* __tstate = wxPyBeginAllowThreads();
7815 wxDrawWindowOnDC(arg1,(wxDC const &)*arg2,arg3);
7816
7817 wxPyEndAllowThreads(__tstate);
7818 if (PyErr_Occurred()) SWIG_fail;
7819 }
7820 Py_INCREF(Py_None); resultobj = Py_None;
7821 return resultobj;
7822 fail:
7823 return NULL;
7824 }
7825
7826
7827 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7828 PyObject *resultobj;
7829 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7830 PyObject * obj0 = 0 ;
7831 char *kwnames[] = {
7832 (char *) "self", NULL
7833 };
7834
7835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7837 if (SWIG_arg_fail(1)) SWIG_fail;
7838 {
7839 PyThreadState* __tstate = wxPyBeginAllowThreads();
7840 delete arg1;
7841
7842 wxPyEndAllowThreads(__tstate);
7843 if (PyErr_Occurred()) SWIG_fail;
7844 }
7845 Py_INCREF(Py_None); resultobj = Py_None;
7846 return resultobj;
7847 fail:
7848 return NULL;
7849 }
7850
7851
7852 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7853 PyObject *resultobj;
7854 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7855 wxString result;
7856 PyObject * obj0 = 0 ;
7857 char *kwnames[] = {
7858 (char *) "self", NULL
7859 };
7860
7861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7863 if (SWIG_arg_fail(1)) SWIG_fail;
7864 {
7865 PyThreadState* __tstate = wxPyBeginAllowThreads();
7866 result = (arg1)->GetTip();
7867
7868 wxPyEndAllowThreads(__tstate);
7869 if (PyErr_Occurred()) SWIG_fail;
7870 }
7871 {
7872 #if wxUSE_UNICODE
7873 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7874 #else
7875 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7876 #endif
7877 }
7878 return resultobj;
7879 fail:
7880 return NULL;
7881 }
7882
7883
7884 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7885 PyObject *resultobj;
7886 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7887 size_t result;
7888 PyObject * obj0 = 0 ;
7889 char *kwnames[] = {
7890 (char *) "self", NULL
7891 };
7892
7893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7895 if (SWIG_arg_fail(1)) SWIG_fail;
7896 {
7897 PyThreadState* __tstate = wxPyBeginAllowThreads();
7898 result = (size_t)(arg1)->GetCurrentTip();
7899
7900 wxPyEndAllowThreads(__tstate);
7901 if (PyErr_Occurred()) SWIG_fail;
7902 }
7903 {
7904 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7905 }
7906 return resultobj;
7907 fail:
7908 return NULL;
7909 }
7910
7911
7912 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7913 PyObject *resultobj;
7914 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7915 wxString *arg2 = 0 ;
7916 wxString result;
7917 bool temp2 = false ;
7918 PyObject * obj0 = 0 ;
7919 PyObject * obj1 = 0 ;
7920 char *kwnames[] = {
7921 (char *) "self",(char *) "tip", NULL
7922 };
7923
7924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7926 if (SWIG_arg_fail(1)) SWIG_fail;
7927 {
7928 arg2 = wxString_in_helper(obj1);
7929 if (arg2 == NULL) SWIG_fail;
7930 temp2 = true;
7931 }
7932 {
7933 PyThreadState* __tstate = wxPyBeginAllowThreads();
7934 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7935
7936 wxPyEndAllowThreads(__tstate);
7937 if (PyErr_Occurred()) SWIG_fail;
7938 }
7939 {
7940 #if wxUSE_UNICODE
7941 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7942 #else
7943 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7944 #endif
7945 }
7946 {
7947 if (temp2)
7948 delete arg2;
7949 }
7950 return resultobj;
7951 fail:
7952 {
7953 if (temp2)
7954 delete arg2;
7955 }
7956 return NULL;
7957 }
7958
7959
7960 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7961 PyObject *obj;
7962 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7963 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
7964 Py_INCREF(obj);
7965 return Py_BuildValue((char *)"");
7966 }
7967 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7968 PyObject *resultobj;
7969 size_t arg1 ;
7970 wxPyTipProvider *result;
7971 PyObject * obj0 = 0 ;
7972 char *kwnames[] = {
7973 (char *) "currentTip", NULL
7974 };
7975
7976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
7977 {
7978 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
7979 if (SWIG_arg_fail(1)) SWIG_fail;
7980 }
7981 {
7982 PyThreadState* __tstate = wxPyBeginAllowThreads();
7983 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
7984
7985 wxPyEndAllowThreads(__tstate);
7986 if (PyErr_Occurred()) SWIG_fail;
7987 }
7988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
7989 return resultobj;
7990 fail:
7991 return NULL;
7992 }
7993
7994
7995 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7996 PyObject *resultobj;
7997 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
7998 PyObject *arg2 = (PyObject *) 0 ;
7999 PyObject *arg3 = (PyObject *) 0 ;
8000 PyObject * obj0 = 0 ;
8001 PyObject * obj1 = 0 ;
8002 PyObject * obj2 = 0 ;
8003 char *kwnames[] = {
8004 (char *) "self",(char *) "self",(char *) "_class", NULL
8005 };
8006
8007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8009 if (SWIG_arg_fail(1)) SWIG_fail;
8010 arg2 = obj1;
8011 arg3 = obj2;
8012 {
8013 PyThreadState* __tstate = wxPyBeginAllowThreads();
8014 (arg1)->_setCallbackInfo(arg2,arg3);
8015
8016 wxPyEndAllowThreads(__tstate);
8017 if (PyErr_Occurred()) SWIG_fail;
8018 }
8019 Py_INCREF(Py_None); resultobj = Py_None;
8020 return resultobj;
8021 fail:
8022 return NULL;
8023 }
8024
8025
8026 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8027 PyObject *obj;
8028 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8029 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8030 Py_INCREF(obj);
8031 return Py_BuildValue((char *)"");
8032 }
8033 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8034 PyObject *resultobj;
8035 wxWindow *arg1 = (wxWindow *) 0 ;
8036 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8037 bool arg3 = (bool) true ;
8038 bool result;
8039 PyObject * obj0 = 0 ;
8040 PyObject * obj1 = 0 ;
8041 PyObject * obj2 = 0 ;
8042 char *kwnames[] = {
8043 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8044 };
8045
8046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8048 if (SWIG_arg_fail(1)) SWIG_fail;
8049 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8050 if (SWIG_arg_fail(2)) SWIG_fail;
8051 if (obj2) {
8052 {
8053 arg3 = (bool)(SWIG_As_bool(obj2));
8054 if (SWIG_arg_fail(3)) SWIG_fail;
8055 }
8056 }
8057 {
8058 if (!wxPyCheckForApp()) SWIG_fail;
8059 PyThreadState* __tstate = wxPyBeginAllowThreads();
8060 result = (bool)wxShowTip(arg1,arg2,arg3);
8061
8062 wxPyEndAllowThreads(__tstate);
8063 if (PyErr_Occurred()) SWIG_fail;
8064 }
8065 {
8066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8067 }
8068 return resultobj;
8069 fail:
8070 return NULL;
8071 }
8072
8073
8074 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8075 PyObject *resultobj;
8076 wxString *arg1 = 0 ;
8077 size_t arg2 ;
8078 wxTipProvider *result;
8079 bool temp1 = false ;
8080 PyObject * obj0 = 0 ;
8081 PyObject * obj1 = 0 ;
8082 char *kwnames[] = {
8083 (char *) "filename",(char *) "currentTip", NULL
8084 };
8085
8086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8087 {
8088 arg1 = wxString_in_helper(obj0);
8089 if (arg1 == NULL) SWIG_fail;
8090 temp1 = true;
8091 }
8092 {
8093 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8094 if (SWIG_arg_fail(2)) SWIG_fail;
8095 }
8096 {
8097 if (!wxPyCheckForApp()) SWIG_fail;
8098 PyThreadState* __tstate = wxPyBeginAllowThreads();
8099 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8100
8101 wxPyEndAllowThreads(__tstate);
8102 if (PyErr_Occurred()) SWIG_fail;
8103 }
8104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8105 {
8106 if (temp1)
8107 delete arg1;
8108 }
8109 return resultobj;
8110 fail:
8111 {
8112 if (temp1)
8113 delete arg1;
8114 }
8115 return NULL;
8116 }
8117
8118
8119 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8120 PyObject *resultobj;
8121 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8122 int arg2 = (int) -1 ;
8123 wxPyTimer *result;
8124 PyObject * obj0 = 0 ;
8125 PyObject * obj1 = 0 ;
8126 char *kwnames[] = {
8127 (char *) "owner",(char *) "id", NULL
8128 };
8129
8130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8131 if (obj0) {
8132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8133 if (SWIG_arg_fail(1)) SWIG_fail;
8134 }
8135 if (obj1) {
8136 {
8137 arg2 = (int)(SWIG_As_int(obj1));
8138 if (SWIG_arg_fail(2)) SWIG_fail;
8139 }
8140 }
8141 {
8142 if (!wxPyCheckForApp()) SWIG_fail;
8143 PyThreadState* __tstate = wxPyBeginAllowThreads();
8144 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8145
8146 wxPyEndAllowThreads(__tstate);
8147 if (PyErr_Occurred()) SWIG_fail;
8148 }
8149 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8150 return resultobj;
8151 fail:
8152 return NULL;
8153 }
8154
8155
8156 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8157 PyObject *resultobj;
8158 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8159 PyObject * obj0 = 0 ;
8160 char *kwnames[] = {
8161 (char *) "self", NULL
8162 };
8163
8164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8166 if (SWIG_arg_fail(1)) SWIG_fail;
8167 {
8168 PyThreadState* __tstate = wxPyBeginAllowThreads();
8169 delete arg1;
8170
8171 wxPyEndAllowThreads(__tstate);
8172 if (PyErr_Occurred()) SWIG_fail;
8173 }
8174 Py_INCREF(Py_None); resultobj = Py_None;
8175 return resultobj;
8176 fail:
8177 return NULL;
8178 }
8179
8180
8181 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8182 PyObject *resultobj;
8183 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8184 PyObject *arg2 = (PyObject *) 0 ;
8185 PyObject *arg3 = (PyObject *) 0 ;
8186 int arg4 = (int) 1 ;
8187 PyObject * obj0 = 0 ;
8188 PyObject * obj1 = 0 ;
8189 PyObject * obj2 = 0 ;
8190 PyObject * obj3 = 0 ;
8191 char *kwnames[] = {
8192 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8193 };
8194
8195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8197 if (SWIG_arg_fail(1)) SWIG_fail;
8198 arg2 = obj1;
8199 arg3 = obj2;
8200 if (obj3) {
8201 {
8202 arg4 = (int)(SWIG_As_int(obj3));
8203 if (SWIG_arg_fail(4)) SWIG_fail;
8204 }
8205 }
8206 {
8207 PyThreadState* __tstate = wxPyBeginAllowThreads();
8208 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8209
8210 wxPyEndAllowThreads(__tstate);
8211 if (PyErr_Occurred()) SWIG_fail;
8212 }
8213 Py_INCREF(Py_None); resultobj = Py_None;
8214 return resultobj;
8215 fail:
8216 return NULL;
8217 }
8218
8219
8220 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8221 PyObject *resultobj;
8222 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8223 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8224 int arg3 = (int) -1 ;
8225 PyObject * obj0 = 0 ;
8226 PyObject * obj1 = 0 ;
8227 PyObject * obj2 = 0 ;
8228 char *kwnames[] = {
8229 (char *) "self",(char *) "owner",(char *) "id", NULL
8230 };
8231
8232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8234 if (SWIG_arg_fail(1)) SWIG_fail;
8235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8236 if (SWIG_arg_fail(2)) SWIG_fail;
8237 if (obj2) {
8238 {
8239 arg3 = (int)(SWIG_As_int(obj2));
8240 if (SWIG_arg_fail(3)) SWIG_fail;
8241 }
8242 }
8243 {
8244 PyThreadState* __tstate = wxPyBeginAllowThreads();
8245 (arg1)->SetOwner(arg2,arg3);
8246
8247 wxPyEndAllowThreads(__tstate);
8248 if (PyErr_Occurred()) SWIG_fail;
8249 }
8250 Py_INCREF(Py_None); resultobj = Py_None;
8251 return resultobj;
8252 fail:
8253 return NULL;
8254 }
8255
8256
8257 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8258 PyObject *resultobj;
8259 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8260 wxEvtHandler *result;
8261 PyObject * obj0 = 0 ;
8262 char *kwnames[] = {
8263 (char *) "self", NULL
8264 };
8265
8266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8268 if (SWIG_arg_fail(1)) SWIG_fail;
8269 {
8270 PyThreadState* __tstate = wxPyBeginAllowThreads();
8271 result = (wxEvtHandler *)(arg1)->GetOwner();
8272
8273 wxPyEndAllowThreads(__tstate);
8274 if (PyErr_Occurred()) SWIG_fail;
8275 }
8276 {
8277 resultobj = wxPyMake_wxObject(result, 0);
8278 }
8279 return resultobj;
8280 fail:
8281 return NULL;
8282 }
8283
8284
8285 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8286 PyObject *resultobj;
8287 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8288 int arg2 = (int) -1 ;
8289 bool arg3 = (bool) false ;
8290 bool result;
8291 PyObject * obj0 = 0 ;
8292 PyObject * obj1 = 0 ;
8293 PyObject * obj2 = 0 ;
8294 char *kwnames[] = {
8295 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8296 };
8297
8298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8300 if (SWIG_arg_fail(1)) SWIG_fail;
8301 if (obj1) {
8302 {
8303 arg2 = (int)(SWIG_As_int(obj1));
8304 if (SWIG_arg_fail(2)) SWIG_fail;
8305 }
8306 }
8307 if (obj2) {
8308 {
8309 arg3 = (bool)(SWIG_As_bool(obj2));
8310 if (SWIG_arg_fail(3)) SWIG_fail;
8311 }
8312 }
8313 {
8314 PyThreadState* __tstate = wxPyBeginAllowThreads();
8315 result = (bool)(arg1)->Start(arg2,arg3);
8316
8317 wxPyEndAllowThreads(__tstate);
8318 if (PyErr_Occurred()) SWIG_fail;
8319 }
8320 {
8321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8322 }
8323 return resultobj;
8324 fail:
8325 return NULL;
8326 }
8327
8328
8329 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8330 PyObject *resultobj;
8331 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8332 PyObject * obj0 = 0 ;
8333 char *kwnames[] = {
8334 (char *) "self", NULL
8335 };
8336
8337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8339 if (SWIG_arg_fail(1)) SWIG_fail;
8340 {
8341 PyThreadState* __tstate = wxPyBeginAllowThreads();
8342 (arg1)->Stop();
8343
8344 wxPyEndAllowThreads(__tstate);
8345 if (PyErr_Occurred()) SWIG_fail;
8346 }
8347 Py_INCREF(Py_None); resultobj = Py_None;
8348 return resultobj;
8349 fail:
8350 return NULL;
8351 }
8352
8353
8354 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8355 PyObject *resultobj;
8356 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8357 bool result;
8358 PyObject * obj0 = 0 ;
8359 char *kwnames[] = {
8360 (char *) "self", NULL
8361 };
8362
8363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8365 if (SWIG_arg_fail(1)) SWIG_fail;
8366 {
8367 PyThreadState* __tstate = wxPyBeginAllowThreads();
8368 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8369
8370 wxPyEndAllowThreads(__tstate);
8371 if (PyErr_Occurred()) SWIG_fail;
8372 }
8373 {
8374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8375 }
8376 return resultobj;
8377 fail:
8378 return NULL;
8379 }
8380
8381
8382 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8383 PyObject *resultobj;
8384 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8385 int result;
8386 PyObject * obj0 = 0 ;
8387 char *kwnames[] = {
8388 (char *) "self", NULL
8389 };
8390
8391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8393 if (SWIG_arg_fail(1)) SWIG_fail;
8394 {
8395 PyThreadState* __tstate = wxPyBeginAllowThreads();
8396 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8397
8398 wxPyEndAllowThreads(__tstate);
8399 if (PyErr_Occurred()) SWIG_fail;
8400 }
8401 {
8402 resultobj = SWIG_From_int((int)(result));
8403 }
8404 return resultobj;
8405 fail:
8406 return NULL;
8407 }
8408
8409
8410 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8411 PyObject *resultobj;
8412 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8413 bool result;
8414 PyObject * obj0 = 0 ;
8415 char *kwnames[] = {
8416 (char *) "self", NULL
8417 };
8418
8419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8421 if (SWIG_arg_fail(1)) SWIG_fail;
8422 {
8423 PyThreadState* __tstate = wxPyBeginAllowThreads();
8424 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8425
8426 wxPyEndAllowThreads(__tstate);
8427 if (PyErr_Occurred()) SWIG_fail;
8428 }
8429 {
8430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8431 }
8432 return resultobj;
8433 fail:
8434 return NULL;
8435 }
8436
8437
8438 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8439 PyObject *resultobj;
8440 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8441 int result;
8442 PyObject * obj0 = 0 ;
8443 char *kwnames[] = {
8444 (char *) "self", NULL
8445 };
8446
8447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8449 if (SWIG_arg_fail(1)) SWIG_fail;
8450 {
8451 PyThreadState* __tstate = wxPyBeginAllowThreads();
8452 result = (int)((wxPyTimer const *)arg1)->GetId();
8453
8454 wxPyEndAllowThreads(__tstate);
8455 if (PyErr_Occurred()) SWIG_fail;
8456 }
8457 {
8458 resultobj = SWIG_From_int((int)(result));
8459 }
8460 return resultobj;
8461 fail:
8462 return NULL;
8463 }
8464
8465
8466 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8467 PyObject *obj;
8468 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8469 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8470 Py_INCREF(obj);
8471 return Py_BuildValue((char *)"");
8472 }
8473 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8474 PyObject *resultobj;
8475 int arg1 = (int) 0 ;
8476 int arg2 = (int) 0 ;
8477 wxTimerEvent *result;
8478 PyObject * obj0 = 0 ;
8479 PyObject * obj1 = 0 ;
8480 char *kwnames[] = {
8481 (char *) "timerid",(char *) "interval", NULL
8482 };
8483
8484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8485 if (obj0) {
8486 {
8487 arg1 = (int)(SWIG_As_int(obj0));
8488 if (SWIG_arg_fail(1)) SWIG_fail;
8489 }
8490 }
8491 if (obj1) {
8492 {
8493 arg2 = (int)(SWIG_As_int(obj1));
8494 if (SWIG_arg_fail(2)) SWIG_fail;
8495 }
8496 }
8497 {
8498 PyThreadState* __tstate = wxPyBeginAllowThreads();
8499 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8500
8501 wxPyEndAllowThreads(__tstate);
8502 if (PyErr_Occurred()) SWIG_fail;
8503 }
8504 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8505 return resultobj;
8506 fail:
8507 return NULL;
8508 }
8509
8510
8511 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8512 PyObject *resultobj;
8513 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8514 int result;
8515 PyObject * obj0 = 0 ;
8516 char *kwnames[] = {
8517 (char *) "self", NULL
8518 };
8519
8520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8522 if (SWIG_arg_fail(1)) SWIG_fail;
8523 {
8524 PyThreadState* __tstate = wxPyBeginAllowThreads();
8525 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8526
8527 wxPyEndAllowThreads(__tstate);
8528 if (PyErr_Occurred()) SWIG_fail;
8529 }
8530 {
8531 resultobj = SWIG_From_int((int)(result));
8532 }
8533 return resultobj;
8534 fail:
8535 return NULL;
8536 }
8537
8538
8539 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8540 PyObject *obj;
8541 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8542 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8543 Py_INCREF(obj);
8544 return Py_BuildValue((char *)"");
8545 }
8546 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8547 PyObject *resultobj;
8548 wxTimer *arg1 = 0 ;
8549 wxTimerRunner *result;
8550 PyObject * obj0 = 0 ;
8551
8552 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8553 {
8554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8555 if (SWIG_arg_fail(1)) SWIG_fail;
8556 if (arg1 == NULL) {
8557 SWIG_null_ref("wxTimer");
8558 }
8559 if (SWIG_arg_fail(1)) SWIG_fail;
8560 }
8561 {
8562 if (!wxPyCheckForApp()) SWIG_fail;
8563 PyThreadState* __tstate = wxPyBeginAllowThreads();
8564 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8565
8566 wxPyEndAllowThreads(__tstate);
8567 if (PyErr_Occurred()) SWIG_fail;
8568 }
8569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8570 return resultobj;
8571 fail:
8572 return NULL;
8573 }
8574
8575
8576 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8577 PyObject *resultobj;
8578 wxTimer *arg1 = 0 ;
8579 int arg2 ;
8580 bool arg3 = (bool) false ;
8581 wxTimerRunner *result;
8582 PyObject * obj0 = 0 ;
8583 PyObject * obj1 = 0 ;
8584 PyObject * obj2 = 0 ;
8585
8586 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8587 {
8588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8589 if (SWIG_arg_fail(1)) SWIG_fail;
8590 if (arg1 == NULL) {
8591 SWIG_null_ref("wxTimer");
8592 }
8593 if (SWIG_arg_fail(1)) SWIG_fail;
8594 }
8595 {
8596 arg2 = (int)(SWIG_As_int(obj1));
8597 if (SWIG_arg_fail(2)) SWIG_fail;
8598 }
8599 if (obj2) {
8600 {
8601 arg3 = (bool)(SWIG_As_bool(obj2));
8602 if (SWIG_arg_fail(3)) SWIG_fail;
8603 }
8604 }
8605 {
8606 if (!wxPyCheckForApp()) SWIG_fail;
8607 PyThreadState* __tstate = wxPyBeginAllowThreads();
8608 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8609
8610 wxPyEndAllowThreads(__tstate);
8611 if (PyErr_Occurred()) SWIG_fail;
8612 }
8613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8614 return resultobj;
8615 fail:
8616 return NULL;
8617 }
8618
8619
8620 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8621 int argc;
8622 PyObject *argv[4];
8623 int ii;
8624
8625 argc = PyObject_Length(args);
8626 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8627 argv[ii] = PyTuple_GetItem(args,ii);
8628 }
8629 if (argc == 1) {
8630 int _v;
8631 {
8632 void *ptr = 0;
8633 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8634 _v = 0;
8635 PyErr_Clear();
8636 } else {
8637 _v = (ptr != 0);
8638 }
8639 }
8640 if (_v) {
8641 return _wrap_new_TimerRunner__SWIG_0(self,args);
8642 }
8643 }
8644 if ((argc >= 2) && (argc <= 3)) {
8645 int _v;
8646 {
8647 void *ptr = 0;
8648 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8649 _v = 0;
8650 PyErr_Clear();
8651 } else {
8652 _v = (ptr != 0);
8653 }
8654 }
8655 if (_v) {
8656 _v = SWIG_Check_int(argv[1]);
8657 if (_v) {
8658 if (argc <= 2) {
8659 return _wrap_new_TimerRunner__SWIG_1(self,args);
8660 }
8661 _v = SWIG_Check_bool(argv[2]);
8662 if (_v) {
8663 return _wrap_new_TimerRunner__SWIG_1(self,args);
8664 }
8665 }
8666 }
8667 }
8668
8669 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8670 return NULL;
8671 }
8672
8673
8674 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8675 PyObject *resultobj;
8676 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8677 PyObject * obj0 = 0 ;
8678 char *kwnames[] = {
8679 (char *) "self", NULL
8680 };
8681
8682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8684 if (SWIG_arg_fail(1)) SWIG_fail;
8685 {
8686 PyThreadState* __tstate = wxPyBeginAllowThreads();
8687 delete arg1;
8688
8689 wxPyEndAllowThreads(__tstate);
8690 if (PyErr_Occurred()) SWIG_fail;
8691 }
8692 Py_INCREF(Py_None); resultobj = Py_None;
8693 return resultobj;
8694 fail:
8695 return NULL;
8696 }
8697
8698
8699 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8700 PyObject *resultobj;
8701 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8702 int arg2 ;
8703 bool arg3 = (bool) false ;
8704 PyObject * obj0 = 0 ;
8705 PyObject * obj1 = 0 ;
8706 PyObject * obj2 = 0 ;
8707 char *kwnames[] = {
8708 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8709 };
8710
8711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8713 if (SWIG_arg_fail(1)) SWIG_fail;
8714 {
8715 arg2 = (int)(SWIG_As_int(obj1));
8716 if (SWIG_arg_fail(2)) SWIG_fail;
8717 }
8718 if (obj2) {
8719 {
8720 arg3 = (bool)(SWIG_As_bool(obj2));
8721 if (SWIG_arg_fail(3)) SWIG_fail;
8722 }
8723 }
8724 {
8725 PyThreadState* __tstate = wxPyBeginAllowThreads();
8726 (arg1)->Start(arg2,arg3);
8727
8728 wxPyEndAllowThreads(__tstate);
8729 if (PyErr_Occurred()) SWIG_fail;
8730 }
8731 Py_INCREF(Py_None); resultobj = Py_None;
8732 return resultobj;
8733 fail:
8734 return NULL;
8735 }
8736
8737
8738 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8739 PyObject *obj;
8740 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8741 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8742 Py_INCREF(obj);
8743 return Py_BuildValue((char *)"");
8744 }
8745 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8746 PyObject *resultobj;
8747 wxLog *result;
8748 char *kwnames[] = {
8749 NULL
8750 };
8751
8752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8753 {
8754 PyThreadState* __tstate = wxPyBeginAllowThreads();
8755 result = (wxLog *)new wxLog();
8756
8757 wxPyEndAllowThreads(__tstate);
8758 if (PyErr_Occurred()) SWIG_fail;
8759 }
8760 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8761 return resultobj;
8762 fail:
8763 return NULL;
8764 }
8765
8766
8767 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8768 PyObject *resultobj;
8769 bool result;
8770 char *kwnames[] = {
8771 NULL
8772 };
8773
8774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8775 {
8776 PyThreadState* __tstate = wxPyBeginAllowThreads();
8777 result = (bool)wxLog::IsEnabled();
8778
8779 wxPyEndAllowThreads(__tstate);
8780 if (PyErr_Occurred()) SWIG_fail;
8781 }
8782 {
8783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8784 }
8785 return resultobj;
8786 fail:
8787 return NULL;
8788 }
8789
8790
8791 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8792 PyObject *resultobj;
8793 bool arg1 = (bool) true ;
8794 bool result;
8795 PyObject * obj0 = 0 ;
8796 char *kwnames[] = {
8797 (char *) "doIt", NULL
8798 };
8799
8800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8801 if (obj0) {
8802 {
8803 arg1 = (bool)(SWIG_As_bool(obj0));
8804 if (SWIG_arg_fail(1)) SWIG_fail;
8805 }
8806 }
8807 {
8808 PyThreadState* __tstate = wxPyBeginAllowThreads();
8809 result = (bool)wxLog::EnableLogging(arg1);
8810
8811 wxPyEndAllowThreads(__tstate);
8812 if (PyErr_Occurred()) SWIG_fail;
8813 }
8814 {
8815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8816 }
8817 return resultobj;
8818 fail:
8819 return NULL;
8820 }
8821
8822
8823 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8824 PyObject *resultobj;
8825 wxLogLevel arg1 ;
8826 wxChar *arg2 = (wxChar *) 0 ;
8827 time_t arg3 ;
8828 PyObject * obj0 = 0 ;
8829 PyObject * obj1 = 0 ;
8830 PyObject * obj2 = 0 ;
8831 char *kwnames[] = {
8832 (char *) "level",(char *) "szString",(char *) "t", NULL
8833 };
8834
8835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8836 {
8837 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8838 if (SWIG_arg_fail(1)) SWIG_fail;
8839 }
8840 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8841 if (SWIG_arg_fail(2)) SWIG_fail;
8842 {
8843 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8844 if (SWIG_arg_fail(3)) SWIG_fail;
8845 }
8846 {
8847 PyThreadState* __tstate = wxPyBeginAllowThreads();
8848 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8849
8850 wxPyEndAllowThreads(__tstate);
8851 if (PyErr_Occurred()) SWIG_fail;
8852 }
8853 Py_INCREF(Py_None); resultobj = Py_None;
8854 return resultobj;
8855 fail:
8856 return NULL;
8857 }
8858
8859
8860 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8861 PyObject *resultobj;
8862 wxLog *arg1 = (wxLog *) 0 ;
8863 PyObject * obj0 = 0 ;
8864 char *kwnames[] = {
8865 (char *) "self", NULL
8866 };
8867
8868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8870 if (SWIG_arg_fail(1)) SWIG_fail;
8871 {
8872 PyThreadState* __tstate = wxPyBeginAllowThreads();
8873 (arg1)->Flush();
8874
8875 wxPyEndAllowThreads(__tstate);
8876 if (PyErr_Occurred()) SWIG_fail;
8877 }
8878 Py_INCREF(Py_None); resultobj = Py_None;
8879 return resultobj;
8880 fail:
8881 return NULL;
8882 }
8883
8884
8885 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8886 PyObject *resultobj;
8887 char *kwnames[] = {
8888 NULL
8889 };
8890
8891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8892 {
8893 PyThreadState* __tstate = wxPyBeginAllowThreads();
8894 wxLog::FlushActive();
8895
8896 wxPyEndAllowThreads(__tstate);
8897 if (PyErr_Occurred()) SWIG_fail;
8898 }
8899 Py_INCREF(Py_None); resultobj = Py_None;
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj;
8908 wxLog *result;
8909 char *kwnames[] = {
8910 NULL
8911 };
8912
8913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8914 {
8915 PyThreadState* __tstate = wxPyBeginAllowThreads();
8916 result = (wxLog *)wxLog::GetActiveTarget();
8917
8918 wxPyEndAllowThreads(__tstate);
8919 if (PyErr_Occurred()) SWIG_fail;
8920 }
8921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8922 return resultobj;
8923 fail:
8924 return NULL;
8925 }
8926
8927
8928 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8929 PyObject *resultobj;
8930 wxLog *arg1 = (wxLog *) 0 ;
8931 wxLog *result;
8932 PyObject * obj0 = 0 ;
8933 char *kwnames[] = {
8934 (char *) "pLogger", NULL
8935 };
8936
8937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8939 if (SWIG_arg_fail(1)) SWIG_fail;
8940 {
8941 PyThreadState* __tstate = wxPyBeginAllowThreads();
8942 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8943
8944 wxPyEndAllowThreads(__tstate);
8945 if (PyErr_Occurred()) SWIG_fail;
8946 }
8947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8948 return resultobj;
8949 fail:
8950 return NULL;
8951 }
8952
8953
8954 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8955 PyObject *resultobj;
8956 char *kwnames[] = {
8957 NULL
8958 };
8959
8960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8961 {
8962 PyThreadState* __tstate = wxPyBeginAllowThreads();
8963 wxLog::Suspend();
8964
8965 wxPyEndAllowThreads(__tstate);
8966 if (PyErr_Occurred()) SWIG_fail;
8967 }
8968 Py_INCREF(Py_None); resultobj = Py_None;
8969 return resultobj;
8970 fail:
8971 return NULL;
8972 }
8973
8974
8975 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8976 PyObject *resultobj;
8977 char *kwnames[] = {
8978 NULL
8979 };
8980
8981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
8982 {
8983 PyThreadState* __tstate = wxPyBeginAllowThreads();
8984 wxLog::Resume();
8985
8986 wxPyEndAllowThreads(__tstate);
8987 if (PyErr_Occurred()) SWIG_fail;
8988 }
8989 Py_INCREF(Py_None); resultobj = Py_None;
8990 return resultobj;
8991 fail:
8992 return NULL;
8993 }
8994
8995
8996 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
8997 PyObject *resultobj;
8998 bool arg1 = (bool) true ;
8999 PyObject * obj0 = 0 ;
9000 char *kwnames[] = {
9001 (char *) "bVerbose", NULL
9002 };
9003
9004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9005 if (obj0) {
9006 {
9007 arg1 = (bool)(SWIG_As_bool(obj0));
9008 if (SWIG_arg_fail(1)) SWIG_fail;
9009 }
9010 }
9011 {
9012 PyThreadState* __tstate = wxPyBeginAllowThreads();
9013 wxLog::SetVerbose(arg1);
9014
9015 wxPyEndAllowThreads(__tstate);
9016 if (PyErr_Occurred()) SWIG_fail;
9017 }
9018 Py_INCREF(Py_None); resultobj = Py_None;
9019 return resultobj;
9020 fail:
9021 return NULL;
9022 }
9023
9024
9025 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9026 PyObject *resultobj;
9027 wxLogLevel arg1 ;
9028 PyObject * obj0 = 0 ;
9029 char *kwnames[] = {
9030 (char *) "logLevel", NULL
9031 };
9032
9033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9034 {
9035 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9036 if (SWIG_arg_fail(1)) SWIG_fail;
9037 }
9038 {
9039 PyThreadState* __tstate = wxPyBeginAllowThreads();
9040 wxLog::SetLogLevel(arg1);
9041
9042 wxPyEndAllowThreads(__tstate);
9043 if (PyErr_Occurred()) SWIG_fail;
9044 }
9045 Py_INCREF(Py_None); resultobj = Py_None;
9046 return resultobj;
9047 fail:
9048 return NULL;
9049 }
9050
9051
9052 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9053 PyObject *resultobj;
9054 char *kwnames[] = {
9055 NULL
9056 };
9057
9058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9059 {
9060 PyThreadState* __tstate = wxPyBeginAllowThreads();
9061 wxLog::DontCreateOnDemand();
9062
9063 wxPyEndAllowThreads(__tstate);
9064 if (PyErr_Occurred()) SWIG_fail;
9065 }
9066 Py_INCREF(Py_None); resultobj = Py_None;
9067 return resultobj;
9068 fail:
9069 return NULL;
9070 }
9071
9072
9073 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9074 PyObject *resultobj;
9075 wxTraceMask arg1 ;
9076 PyObject * obj0 = 0 ;
9077 char *kwnames[] = {
9078 (char *) "ulMask", NULL
9079 };
9080
9081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9082 {
9083 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9084 if (SWIG_arg_fail(1)) SWIG_fail;
9085 }
9086 {
9087 PyThreadState* __tstate = wxPyBeginAllowThreads();
9088 wxLog::SetTraceMask(arg1);
9089
9090 wxPyEndAllowThreads(__tstate);
9091 if (PyErr_Occurred()) SWIG_fail;
9092 }
9093 Py_INCREF(Py_None); resultobj = Py_None;
9094 return resultobj;
9095 fail:
9096 return NULL;
9097 }
9098
9099
9100 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9101 PyObject *resultobj;
9102 wxString *arg1 = 0 ;
9103 bool temp1 = false ;
9104 PyObject * obj0 = 0 ;
9105 char *kwnames[] = {
9106 (char *) "str", NULL
9107 };
9108
9109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9110 {
9111 arg1 = wxString_in_helper(obj0);
9112 if (arg1 == NULL) SWIG_fail;
9113 temp1 = true;
9114 }
9115 {
9116 PyThreadState* __tstate = wxPyBeginAllowThreads();
9117 wxLog::AddTraceMask((wxString const &)*arg1);
9118
9119 wxPyEndAllowThreads(__tstate);
9120 if (PyErr_Occurred()) SWIG_fail;
9121 }
9122 Py_INCREF(Py_None); resultobj = Py_None;
9123 {
9124 if (temp1)
9125 delete arg1;
9126 }
9127 return resultobj;
9128 fail:
9129 {
9130 if (temp1)
9131 delete arg1;
9132 }
9133 return NULL;
9134 }
9135
9136
9137 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9138 PyObject *resultobj;
9139 wxString *arg1 = 0 ;
9140 bool temp1 = false ;
9141 PyObject * obj0 = 0 ;
9142 char *kwnames[] = {
9143 (char *) "str", NULL
9144 };
9145
9146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9147 {
9148 arg1 = wxString_in_helper(obj0);
9149 if (arg1 == NULL) SWIG_fail;
9150 temp1 = true;
9151 }
9152 {
9153 PyThreadState* __tstate = wxPyBeginAllowThreads();
9154 wxLog::RemoveTraceMask((wxString const &)*arg1);
9155
9156 wxPyEndAllowThreads(__tstate);
9157 if (PyErr_Occurred()) SWIG_fail;
9158 }
9159 Py_INCREF(Py_None); resultobj = Py_None;
9160 {
9161 if (temp1)
9162 delete arg1;
9163 }
9164 return resultobj;
9165 fail:
9166 {
9167 if (temp1)
9168 delete arg1;
9169 }
9170 return NULL;
9171 }
9172
9173
9174 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9175 PyObject *resultobj;
9176 char *kwnames[] = {
9177 NULL
9178 };
9179
9180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9181 {
9182 PyThreadState* __tstate = wxPyBeginAllowThreads();
9183 wxLog::ClearTraceMasks();
9184
9185 wxPyEndAllowThreads(__tstate);
9186 if (PyErr_Occurred()) SWIG_fail;
9187 }
9188 Py_INCREF(Py_None); resultobj = Py_None;
9189 return resultobj;
9190 fail:
9191 return NULL;
9192 }
9193
9194
9195 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9196 PyObject *resultobj;
9197 wxArrayString *result;
9198 char *kwnames[] = {
9199 NULL
9200 };
9201
9202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9203 {
9204 PyThreadState* __tstate = wxPyBeginAllowThreads();
9205 {
9206 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9207 result = (wxArrayString *) &_result_ref;
9208 }
9209
9210 wxPyEndAllowThreads(__tstate);
9211 if (PyErr_Occurred()) SWIG_fail;
9212 }
9213 {
9214 resultobj = wxArrayString2PyList_helper(*result);
9215 }
9216 return resultobj;
9217 fail:
9218 return NULL;
9219 }
9220
9221
9222 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9223 PyObject *resultobj;
9224 wxChar *arg1 = (wxChar *) 0 ;
9225 PyObject * obj0 = 0 ;
9226 char *kwnames[] = {
9227 (char *) "ts", NULL
9228 };
9229
9230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9232 if (SWIG_arg_fail(1)) SWIG_fail;
9233 {
9234 PyThreadState* __tstate = wxPyBeginAllowThreads();
9235 wxLog::SetTimestamp((wxChar const *)arg1);
9236
9237 wxPyEndAllowThreads(__tstate);
9238 if (PyErr_Occurred()) SWIG_fail;
9239 }
9240 Py_INCREF(Py_None); resultobj = Py_None;
9241 return resultobj;
9242 fail:
9243 return NULL;
9244 }
9245
9246
9247 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9248 PyObject *resultobj;
9249 bool result;
9250 char *kwnames[] = {
9251 NULL
9252 };
9253
9254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9255 {
9256 PyThreadState* __tstate = wxPyBeginAllowThreads();
9257 result = (bool)wxLog::GetVerbose();
9258
9259 wxPyEndAllowThreads(__tstate);
9260 if (PyErr_Occurred()) SWIG_fail;
9261 }
9262 {
9263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9264 }
9265 return resultobj;
9266 fail:
9267 return NULL;
9268 }
9269
9270
9271 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9272 PyObject *resultobj;
9273 wxTraceMask result;
9274 char *kwnames[] = {
9275 NULL
9276 };
9277
9278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9279 {
9280 PyThreadState* __tstate = wxPyBeginAllowThreads();
9281 result = (wxTraceMask)wxLog::GetTraceMask();
9282
9283 wxPyEndAllowThreads(__tstate);
9284 if (PyErr_Occurred()) SWIG_fail;
9285 }
9286 {
9287 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9288 }
9289 return resultobj;
9290 fail:
9291 return NULL;
9292 }
9293
9294
9295 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9296 PyObject *resultobj;
9297 wxChar *arg1 = (wxChar *) 0 ;
9298 bool result;
9299 PyObject * obj0 = 0 ;
9300 char *kwnames[] = {
9301 (char *) "mask", NULL
9302 };
9303
9304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9306 if (SWIG_arg_fail(1)) SWIG_fail;
9307 {
9308 PyThreadState* __tstate = wxPyBeginAllowThreads();
9309 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9310
9311 wxPyEndAllowThreads(__tstate);
9312 if (PyErr_Occurred()) SWIG_fail;
9313 }
9314 {
9315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9316 }
9317 return resultobj;
9318 fail:
9319 return NULL;
9320 }
9321
9322
9323 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9324 PyObject *resultobj;
9325 wxLogLevel result;
9326 char *kwnames[] = {
9327 NULL
9328 };
9329
9330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9331 {
9332 PyThreadState* __tstate = wxPyBeginAllowThreads();
9333 result = (wxLogLevel)wxLog::GetLogLevel();
9334
9335 wxPyEndAllowThreads(__tstate);
9336 if (PyErr_Occurred()) SWIG_fail;
9337 }
9338 {
9339 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9340 }
9341 return resultobj;
9342 fail:
9343 return NULL;
9344 }
9345
9346
9347 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9348 PyObject *resultobj;
9349 wxChar *result;
9350 char *kwnames[] = {
9351 NULL
9352 };
9353
9354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9355 {
9356 PyThreadState* __tstate = wxPyBeginAllowThreads();
9357 result = (wxChar *)wxLog::GetTimestamp();
9358
9359 wxPyEndAllowThreads(__tstate);
9360 if (PyErr_Occurred()) SWIG_fail;
9361 }
9362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9363 return resultobj;
9364 fail:
9365 return NULL;
9366 }
9367
9368
9369 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9370 PyObject *resultobj;
9371 wxString result;
9372 char *kwnames[] = {
9373 NULL
9374 };
9375
9376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9377 {
9378 PyThreadState* __tstate = wxPyBeginAllowThreads();
9379 result = Log_TimeStamp();
9380
9381 wxPyEndAllowThreads(__tstate);
9382 if (PyErr_Occurred()) SWIG_fail;
9383 }
9384 {
9385 #if wxUSE_UNICODE
9386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9387 #else
9388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9389 #endif
9390 }
9391 return resultobj;
9392 fail:
9393 return NULL;
9394 }
9395
9396
9397 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9398 PyObject *resultobj;
9399 wxLog *arg1 = (wxLog *) 0 ;
9400 PyObject * obj0 = 0 ;
9401 char *kwnames[] = {
9402 (char *) "self", NULL
9403 };
9404
9405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9407 if (SWIG_arg_fail(1)) SWIG_fail;
9408 {
9409 PyThreadState* __tstate = wxPyBeginAllowThreads();
9410 wxLog_Destroy(arg1);
9411
9412 wxPyEndAllowThreads(__tstate);
9413 if (PyErr_Occurred()) SWIG_fail;
9414 }
9415 Py_INCREF(Py_None); resultobj = Py_None;
9416 return resultobj;
9417 fail:
9418 return NULL;
9419 }
9420
9421
9422 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9423 PyObject *obj;
9424 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9425 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9426 Py_INCREF(obj);
9427 return Py_BuildValue((char *)"");
9428 }
9429 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9430 PyObject *resultobj;
9431 wxLogStderr *result;
9432 char *kwnames[] = {
9433 NULL
9434 };
9435
9436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9437 {
9438 PyThreadState* __tstate = wxPyBeginAllowThreads();
9439 result = (wxLogStderr *)new wxLogStderr();
9440
9441 wxPyEndAllowThreads(__tstate);
9442 if (PyErr_Occurred()) SWIG_fail;
9443 }
9444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9445 return resultobj;
9446 fail:
9447 return NULL;
9448 }
9449
9450
9451 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9452 PyObject *obj;
9453 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9454 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9455 Py_INCREF(obj);
9456 return Py_BuildValue((char *)"");
9457 }
9458 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9459 PyObject *resultobj;
9460 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9461 wxLogTextCtrl *result;
9462 PyObject * obj0 = 0 ;
9463 char *kwnames[] = {
9464 (char *) "pTextCtrl", NULL
9465 };
9466
9467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9469 if (SWIG_arg_fail(1)) SWIG_fail;
9470 {
9471 PyThreadState* __tstate = wxPyBeginAllowThreads();
9472 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9473
9474 wxPyEndAllowThreads(__tstate);
9475 if (PyErr_Occurred()) SWIG_fail;
9476 }
9477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9478 return resultobj;
9479 fail:
9480 return NULL;
9481 }
9482
9483
9484 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9485 PyObject *obj;
9486 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9487 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9488 Py_INCREF(obj);
9489 return Py_BuildValue((char *)"");
9490 }
9491 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9492 PyObject *resultobj;
9493 wxLogGui *result;
9494 char *kwnames[] = {
9495 NULL
9496 };
9497
9498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9499 {
9500 PyThreadState* __tstate = wxPyBeginAllowThreads();
9501 result = (wxLogGui *)new wxLogGui();
9502
9503 wxPyEndAllowThreads(__tstate);
9504 if (PyErr_Occurred()) SWIG_fail;
9505 }
9506 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9507 return resultobj;
9508 fail:
9509 return NULL;
9510 }
9511
9512
9513 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9514 PyObject *obj;
9515 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9516 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9517 Py_INCREF(obj);
9518 return Py_BuildValue((char *)"");
9519 }
9520 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9521 PyObject *resultobj;
9522 wxFrame *arg1 = (wxFrame *) 0 ;
9523 wxString *arg2 = 0 ;
9524 bool arg3 = (bool) true ;
9525 bool arg4 = (bool) true ;
9526 wxLogWindow *result;
9527 bool temp2 = false ;
9528 PyObject * obj0 = 0 ;
9529 PyObject * obj1 = 0 ;
9530 PyObject * obj2 = 0 ;
9531 PyObject * obj3 = 0 ;
9532 char *kwnames[] = {
9533 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9534 };
9535
9536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9538 if (SWIG_arg_fail(1)) SWIG_fail;
9539 {
9540 arg2 = wxString_in_helper(obj1);
9541 if (arg2 == NULL) SWIG_fail;
9542 temp2 = true;
9543 }
9544 if (obj2) {
9545 {
9546 arg3 = (bool)(SWIG_As_bool(obj2));
9547 if (SWIG_arg_fail(3)) SWIG_fail;
9548 }
9549 }
9550 if (obj3) {
9551 {
9552 arg4 = (bool)(SWIG_As_bool(obj3));
9553 if (SWIG_arg_fail(4)) SWIG_fail;
9554 }
9555 }
9556 {
9557 PyThreadState* __tstate = wxPyBeginAllowThreads();
9558 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9559
9560 wxPyEndAllowThreads(__tstate);
9561 if (PyErr_Occurred()) SWIG_fail;
9562 }
9563 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9564 {
9565 if (temp2)
9566 delete arg2;
9567 }
9568 return resultobj;
9569 fail:
9570 {
9571 if (temp2)
9572 delete arg2;
9573 }
9574 return NULL;
9575 }
9576
9577
9578 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9579 PyObject *resultobj;
9580 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9581 bool arg2 = (bool) true ;
9582 PyObject * obj0 = 0 ;
9583 PyObject * obj1 = 0 ;
9584 char *kwnames[] = {
9585 (char *) "self",(char *) "bShow", NULL
9586 };
9587
9588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9590 if (SWIG_arg_fail(1)) SWIG_fail;
9591 if (obj1) {
9592 {
9593 arg2 = (bool)(SWIG_As_bool(obj1));
9594 if (SWIG_arg_fail(2)) SWIG_fail;
9595 }
9596 }
9597 {
9598 PyThreadState* __tstate = wxPyBeginAllowThreads();
9599 (arg1)->Show(arg2);
9600
9601 wxPyEndAllowThreads(__tstate);
9602 if (PyErr_Occurred()) SWIG_fail;
9603 }
9604 Py_INCREF(Py_None); resultobj = Py_None;
9605 return resultobj;
9606 fail:
9607 return NULL;
9608 }
9609
9610
9611 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9612 PyObject *resultobj;
9613 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9614 wxFrame *result;
9615 PyObject * obj0 = 0 ;
9616 char *kwnames[] = {
9617 (char *) "self", NULL
9618 };
9619
9620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9622 if (SWIG_arg_fail(1)) SWIG_fail;
9623 {
9624 PyThreadState* __tstate = wxPyBeginAllowThreads();
9625 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9626
9627 wxPyEndAllowThreads(__tstate);
9628 if (PyErr_Occurred()) SWIG_fail;
9629 }
9630 {
9631 resultobj = wxPyMake_wxObject(result, 0);
9632 }
9633 return resultobj;
9634 fail:
9635 return NULL;
9636 }
9637
9638
9639 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9640 PyObject *resultobj;
9641 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9642 wxLog *result;
9643 PyObject * obj0 = 0 ;
9644 char *kwnames[] = {
9645 (char *) "self", NULL
9646 };
9647
9648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9650 if (SWIG_arg_fail(1)) SWIG_fail;
9651 {
9652 PyThreadState* __tstate = wxPyBeginAllowThreads();
9653 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9654
9655 wxPyEndAllowThreads(__tstate);
9656 if (PyErr_Occurred()) SWIG_fail;
9657 }
9658 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9659 return resultobj;
9660 fail:
9661 return NULL;
9662 }
9663
9664
9665 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9666 PyObject *resultobj;
9667 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9668 bool result;
9669 PyObject * obj0 = 0 ;
9670 char *kwnames[] = {
9671 (char *) "self", NULL
9672 };
9673
9674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9676 if (SWIG_arg_fail(1)) SWIG_fail;
9677 {
9678 PyThreadState* __tstate = wxPyBeginAllowThreads();
9679 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9680
9681 wxPyEndAllowThreads(__tstate);
9682 if (PyErr_Occurred()) SWIG_fail;
9683 }
9684 {
9685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9686 }
9687 return resultobj;
9688 fail:
9689 return NULL;
9690 }
9691
9692
9693 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9694 PyObject *resultobj;
9695 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9696 bool arg2 ;
9697 PyObject * obj0 = 0 ;
9698 PyObject * obj1 = 0 ;
9699 char *kwnames[] = {
9700 (char *) "self",(char *) "bDoPass", NULL
9701 };
9702
9703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9705 if (SWIG_arg_fail(1)) SWIG_fail;
9706 {
9707 arg2 = (bool)(SWIG_As_bool(obj1));
9708 if (SWIG_arg_fail(2)) SWIG_fail;
9709 }
9710 {
9711 PyThreadState* __tstate = wxPyBeginAllowThreads();
9712 (arg1)->PassMessages(arg2);
9713
9714 wxPyEndAllowThreads(__tstate);
9715 if (PyErr_Occurred()) SWIG_fail;
9716 }
9717 Py_INCREF(Py_None); resultobj = Py_None;
9718 return resultobj;
9719 fail:
9720 return NULL;
9721 }
9722
9723
9724 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9725 PyObject *obj;
9726 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9727 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9728 Py_INCREF(obj);
9729 return Py_BuildValue((char *)"");
9730 }
9731 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9732 PyObject *resultobj;
9733 wxLog *arg1 = (wxLog *) 0 ;
9734 wxLogChain *result;
9735 PyObject * obj0 = 0 ;
9736 char *kwnames[] = {
9737 (char *) "logger", NULL
9738 };
9739
9740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9742 if (SWIG_arg_fail(1)) SWIG_fail;
9743 {
9744 PyThreadState* __tstate = wxPyBeginAllowThreads();
9745 result = (wxLogChain *)new wxLogChain(arg1);
9746
9747 wxPyEndAllowThreads(__tstate);
9748 if (PyErr_Occurred()) SWIG_fail;
9749 }
9750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9751 return resultobj;
9752 fail:
9753 return NULL;
9754 }
9755
9756
9757 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9758 PyObject *resultobj;
9759 wxLogChain *arg1 = (wxLogChain *) 0 ;
9760 wxLog *arg2 = (wxLog *) 0 ;
9761 PyObject * obj0 = 0 ;
9762 PyObject * obj1 = 0 ;
9763 char *kwnames[] = {
9764 (char *) "self",(char *) "logger", NULL
9765 };
9766
9767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9769 if (SWIG_arg_fail(1)) SWIG_fail;
9770 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9771 if (SWIG_arg_fail(2)) SWIG_fail;
9772 {
9773 PyThreadState* __tstate = wxPyBeginAllowThreads();
9774 (arg1)->SetLog(arg2);
9775
9776 wxPyEndAllowThreads(__tstate);
9777 if (PyErr_Occurred()) SWIG_fail;
9778 }
9779 Py_INCREF(Py_None); resultobj = Py_None;
9780 return resultobj;
9781 fail:
9782 return NULL;
9783 }
9784
9785
9786 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9787 PyObject *resultobj;
9788 wxLogChain *arg1 = (wxLogChain *) 0 ;
9789 bool arg2 ;
9790 PyObject * obj0 = 0 ;
9791 PyObject * obj1 = 0 ;
9792 char *kwnames[] = {
9793 (char *) "self",(char *) "bDoPass", NULL
9794 };
9795
9796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9798 if (SWIG_arg_fail(1)) SWIG_fail;
9799 {
9800 arg2 = (bool)(SWIG_As_bool(obj1));
9801 if (SWIG_arg_fail(2)) SWIG_fail;
9802 }
9803 {
9804 PyThreadState* __tstate = wxPyBeginAllowThreads();
9805 (arg1)->PassMessages(arg2);
9806
9807 wxPyEndAllowThreads(__tstate);
9808 if (PyErr_Occurred()) SWIG_fail;
9809 }
9810 Py_INCREF(Py_None); resultobj = Py_None;
9811 return resultobj;
9812 fail:
9813 return NULL;
9814 }
9815
9816
9817 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9818 PyObject *resultobj;
9819 wxLogChain *arg1 = (wxLogChain *) 0 ;
9820 bool result;
9821 PyObject * obj0 = 0 ;
9822 char *kwnames[] = {
9823 (char *) "self", NULL
9824 };
9825
9826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9828 if (SWIG_arg_fail(1)) SWIG_fail;
9829 {
9830 PyThreadState* __tstate = wxPyBeginAllowThreads();
9831 result = (bool)(arg1)->IsPassingMessages();
9832
9833 wxPyEndAllowThreads(__tstate);
9834 if (PyErr_Occurred()) SWIG_fail;
9835 }
9836 {
9837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9838 }
9839 return resultobj;
9840 fail:
9841 return NULL;
9842 }
9843
9844
9845 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9846 PyObject *resultobj;
9847 wxLogChain *arg1 = (wxLogChain *) 0 ;
9848 wxLog *result;
9849 PyObject * obj0 = 0 ;
9850 char *kwnames[] = {
9851 (char *) "self", NULL
9852 };
9853
9854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9856 if (SWIG_arg_fail(1)) SWIG_fail;
9857 {
9858 PyThreadState* __tstate = wxPyBeginAllowThreads();
9859 result = (wxLog *)(arg1)->GetOldLog();
9860
9861 wxPyEndAllowThreads(__tstate);
9862 if (PyErr_Occurred()) SWIG_fail;
9863 }
9864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9865 return resultobj;
9866 fail:
9867 return NULL;
9868 }
9869
9870
9871 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9872 PyObject *obj;
9873 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9874 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9875 Py_INCREF(obj);
9876 return Py_BuildValue((char *)"");
9877 }
9878 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9879 PyObject *resultobj;
9880 unsigned long result;
9881 char *kwnames[] = {
9882 NULL
9883 };
9884
9885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9886 {
9887 PyThreadState* __tstate = wxPyBeginAllowThreads();
9888 result = (unsigned long)wxSysErrorCode();
9889
9890 wxPyEndAllowThreads(__tstate);
9891 if (PyErr_Occurred()) SWIG_fail;
9892 }
9893 {
9894 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9895 }
9896 return resultobj;
9897 fail:
9898 return NULL;
9899 }
9900
9901
9902 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9903 PyObject *resultobj;
9904 unsigned long arg1 = (unsigned long) 0 ;
9905 wxString result;
9906 PyObject * obj0 = 0 ;
9907 char *kwnames[] = {
9908 (char *) "nErrCode", NULL
9909 };
9910
9911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9912 if (obj0) {
9913 {
9914 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9915 if (SWIG_arg_fail(1)) SWIG_fail;
9916 }
9917 }
9918 {
9919 PyThreadState* __tstate = wxPyBeginAllowThreads();
9920 result = wxSysErrorMsg(arg1);
9921
9922 wxPyEndAllowThreads(__tstate);
9923 if (PyErr_Occurred()) SWIG_fail;
9924 }
9925 {
9926 #if wxUSE_UNICODE
9927 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9928 #else
9929 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9930 #endif
9931 }
9932 return resultobj;
9933 fail:
9934 return NULL;
9935 }
9936
9937
9938 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9939 PyObject *resultobj;
9940 wxString *arg1 = 0 ;
9941 bool temp1 = false ;
9942 PyObject * obj0 = 0 ;
9943 char *kwnames[] = {
9944 (char *) "msg", NULL
9945 };
9946
9947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9948 {
9949 arg1 = wxString_in_helper(obj0);
9950 if (arg1 == NULL) SWIG_fail;
9951 temp1 = true;
9952 }
9953 {
9954 PyThreadState* __tstate = wxPyBeginAllowThreads();
9955 wxPyLogFatalError((wxString const &)*arg1);
9956
9957 wxPyEndAllowThreads(__tstate);
9958 if (PyErr_Occurred()) SWIG_fail;
9959 }
9960 Py_INCREF(Py_None); resultobj = Py_None;
9961 {
9962 if (temp1)
9963 delete arg1;
9964 }
9965 return resultobj;
9966 fail:
9967 {
9968 if (temp1)
9969 delete arg1;
9970 }
9971 return NULL;
9972 }
9973
9974
9975 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
9976 PyObject *resultobj;
9977 wxString *arg1 = 0 ;
9978 bool temp1 = false ;
9979 PyObject * obj0 = 0 ;
9980 char *kwnames[] = {
9981 (char *) "msg", NULL
9982 };
9983
9984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
9985 {
9986 arg1 = wxString_in_helper(obj0);
9987 if (arg1 == NULL) SWIG_fail;
9988 temp1 = true;
9989 }
9990 {
9991 PyThreadState* __tstate = wxPyBeginAllowThreads();
9992 wxPyLogError((wxString const &)*arg1);
9993
9994 wxPyEndAllowThreads(__tstate);
9995 if (PyErr_Occurred()) SWIG_fail;
9996 }
9997 Py_INCREF(Py_None); resultobj = Py_None;
9998 {
9999 if (temp1)
10000 delete arg1;
10001 }
10002 return resultobj;
10003 fail:
10004 {
10005 if (temp1)
10006 delete arg1;
10007 }
10008 return NULL;
10009 }
10010
10011
10012 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10013 PyObject *resultobj;
10014 wxString *arg1 = 0 ;
10015 bool temp1 = false ;
10016 PyObject * obj0 = 0 ;
10017 char *kwnames[] = {
10018 (char *) "msg", NULL
10019 };
10020
10021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10022 {
10023 arg1 = wxString_in_helper(obj0);
10024 if (arg1 == NULL) SWIG_fail;
10025 temp1 = true;
10026 }
10027 {
10028 PyThreadState* __tstate = wxPyBeginAllowThreads();
10029 wxPyLogWarning((wxString const &)*arg1);
10030
10031 wxPyEndAllowThreads(__tstate);
10032 if (PyErr_Occurred()) SWIG_fail;
10033 }
10034 Py_INCREF(Py_None); resultobj = Py_None;
10035 {
10036 if (temp1)
10037 delete arg1;
10038 }
10039 return resultobj;
10040 fail:
10041 {
10042 if (temp1)
10043 delete arg1;
10044 }
10045 return NULL;
10046 }
10047
10048
10049 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10050 PyObject *resultobj;
10051 wxString *arg1 = 0 ;
10052 bool temp1 = false ;
10053 PyObject * obj0 = 0 ;
10054 char *kwnames[] = {
10055 (char *) "msg", NULL
10056 };
10057
10058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10059 {
10060 arg1 = wxString_in_helper(obj0);
10061 if (arg1 == NULL) SWIG_fail;
10062 temp1 = true;
10063 }
10064 {
10065 PyThreadState* __tstate = wxPyBeginAllowThreads();
10066 wxPyLogMessage((wxString const &)*arg1);
10067
10068 wxPyEndAllowThreads(__tstate);
10069 if (PyErr_Occurred()) SWIG_fail;
10070 }
10071 Py_INCREF(Py_None); resultobj = Py_None;
10072 {
10073 if (temp1)
10074 delete arg1;
10075 }
10076 return resultobj;
10077 fail:
10078 {
10079 if (temp1)
10080 delete arg1;
10081 }
10082 return NULL;
10083 }
10084
10085
10086 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10087 PyObject *resultobj;
10088 wxString *arg1 = 0 ;
10089 bool temp1 = false ;
10090 PyObject * obj0 = 0 ;
10091 char *kwnames[] = {
10092 (char *) "msg", NULL
10093 };
10094
10095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10096 {
10097 arg1 = wxString_in_helper(obj0);
10098 if (arg1 == NULL) SWIG_fail;
10099 temp1 = true;
10100 }
10101 {
10102 PyThreadState* __tstate = wxPyBeginAllowThreads();
10103 wxPyLogInfo((wxString const &)*arg1);
10104
10105 wxPyEndAllowThreads(__tstate);
10106 if (PyErr_Occurred()) SWIG_fail;
10107 }
10108 Py_INCREF(Py_None); resultobj = Py_None;
10109 {
10110 if (temp1)
10111 delete arg1;
10112 }
10113 return resultobj;
10114 fail:
10115 {
10116 if (temp1)
10117 delete arg1;
10118 }
10119 return NULL;
10120 }
10121
10122
10123 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10124 PyObject *resultobj;
10125 wxString *arg1 = 0 ;
10126 bool temp1 = false ;
10127 PyObject * obj0 = 0 ;
10128 char *kwnames[] = {
10129 (char *) "msg", NULL
10130 };
10131
10132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10133 {
10134 arg1 = wxString_in_helper(obj0);
10135 if (arg1 == NULL) SWIG_fail;
10136 temp1 = true;
10137 }
10138 {
10139 PyThreadState* __tstate = wxPyBeginAllowThreads();
10140 wxPyLogDebug((wxString const &)*arg1);
10141
10142 wxPyEndAllowThreads(__tstate);
10143 if (PyErr_Occurred()) SWIG_fail;
10144 }
10145 Py_INCREF(Py_None); resultobj = Py_None;
10146 {
10147 if (temp1)
10148 delete arg1;
10149 }
10150 return resultobj;
10151 fail:
10152 {
10153 if (temp1)
10154 delete arg1;
10155 }
10156 return NULL;
10157 }
10158
10159
10160 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10161 PyObject *resultobj;
10162 wxString *arg1 = 0 ;
10163 bool temp1 = false ;
10164 PyObject * obj0 = 0 ;
10165 char *kwnames[] = {
10166 (char *) "msg", NULL
10167 };
10168
10169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10170 {
10171 arg1 = wxString_in_helper(obj0);
10172 if (arg1 == NULL) SWIG_fail;
10173 temp1 = true;
10174 }
10175 {
10176 PyThreadState* __tstate = wxPyBeginAllowThreads();
10177 wxPyLogVerbose((wxString const &)*arg1);
10178
10179 wxPyEndAllowThreads(__tstate);
10180 if (PyErr_Occurred()) SWIG_fail;
10181 }
10182 Py_INCREF(Py_None); resultobj = Py_None;
10183 {
10184 if (temp1)
10185 delete arg1;
10186 }
10187 return resultobj;
10188 fail:
10189 {
10190 if (temp1)
10191 delete arg1;
10192 }
10193 return NULL;
10194 }
10195
10196
10197 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10198 PyObject *resultobj;
10199 wxString *arg1 = 0 ;
10200 bool temp1 = false ;
10201 PyObject * obj0 = 0 ;
10202 char *kwnames[] = {
10203 (char *) "msg", NULL
10204 };
10205
10206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10207 {
10208 arg1 = wxString_in_helper(obj0);
10209 if (arg1 == NULL) SWIG_fail;
10210 temp1 = true;
10211 }
10212 {
10213 PyThreadState* __tstate = wxPyBeginAllowThreads();
10214 wxPyLogStatus((wxString const &)*arg1);
10215
10216 wxPyEndAllowThreads(__tstate);
10217 if (PyErr_Occurred()) SWIG_fail;
10218 }
10219 Py_INCREF(Py_None); resultobj = Py_None;
10220 {
10221 if (temp1)
10222 delete arg1;
10223 }
10224 return resultobj;
10225 fail:
10226 {
10227 if (temp1)
10228 delete arg1;
10229 }
10230 return NULL;
10231 }
10232
10233
10234 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10235 PyObject *resultobj;
10236 wxFrame *arg1 = (wxFrame *) 0 ;
10237 wxString *arg2 = 0 ;
10238 bool temp2 = false ;
10239 PyObject * obj0 = 0 ;
10240 PyObject * obj1 = 0 ;
10241 char *kwnames[] = {
10242 (char *) "pFrame",(char *) "msg", NULL
10243 };
10244
10245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10247 if (SWIG_arg_fail(1)) SWIG_fail;
10248 {
10249 arg2 = wxString_in_helper(obj1);
10250 if (arg2 == NULL) SWIG_fail;
10251 temp2 = true;
10252 }
10253 {
10254 PyThreadState* __tstate = wxPyBeginAllowThreads();
10255 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10256
10257 wxPyEndAllowThreads(__tstate);
10258 if (PyErr_Occurred()) SWIG_fail;
10259 }
10260 Py_INCREF(Py_None); resultobj = Py_None;
10261 {
10262 if (temp2)
10263 delete arg2;
10264 }
10265 return resultobj;
10266 fail:
10267 {
10268 if (temp2)
10269 delete arg2;
10270 }
10271 return NULL;
10272 }
10273
10274
10275 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10276 PyObject *resultobj;
10277 wxString *arg1 = 0 ;
10278 bool temp1 = false ;
10279 PyObject * obj0 = 0 ;
10280 char *kwnames[] = {
10281 (char *) "msg", NULL
10282 };
10283
10284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10285 {
10286 arg1 = wxString_in_helper(obj0);
10287 if (arg1 == NULL) SWIG_fail;
10288 temp1 = true;
10289 }
10290 {
10291 PyThreadState* __tstate = wxPyBeginAllowThreads();
10292 wxPyLogSysError((wxString const &)*arg1);
10293
10294 wxPyEndAllowThreads(__tstate);
10295 if (PyErr_Occurred()) SWIG_fail;
10296 }
10297 Py_INCREF(Py_None); resultobj = Py_None;
10298 {
10299 if (temp1)
10300 delete arg1;
10301 }
10302 return resultobj;
10303 fail:
10304 {
10305 if (temp1)
10306 delete arg1;
10307 }
10308 return NULL;
10309 }
10310
10311
10312 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10313 PyObject *resultobj;
10314 unsigned long arg1 ;
10315 wxString *arg2 = 0 ;
10316 bool temp2 = false ;
10317 PyObject * obj0 = 0 ;
10318 PyObject * obj1 = 0 ;
10319 char *kwnames[] = {
10320 (char *) "level",(char *) "msg", NULL
10321 };
10322
10323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10324 {
10325 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10326 if (SWIG_arg_fail(1)) SWIG_fail;
10327 }
10328 {
10329 arg2 = wxString_in_helper(obj1);
10330 if (arg2 == NULL) SWIG_fail;
10331 temp2 = true;
10332 }
10333 {
10334 PyThreadState* __tstate = wxPyBeginAllowThreads();
10335 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10336
10337 wxPyEndAllowThreads(__tstate);
10338 if (PyErr_Occurred()) SWIG_fail;
10339 }
10340 Py_INCREF(Py_None); resultobj = Py_None;
10341 {
10342 if (temp2)
10343 delete arg2;
10344 }
10345 return resultobj;
10346 fail:
10347 {
10348 if (temp2)
10349 delete arg2;
10350 }
10351 return NULL;
10352 }
10353
10354
10355 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10356 PyObject *resultobj;
10357 unsigned long arg1 ;
10358 wxString *arg2 = 0 ;
10359 bool temp2 = false ;
10360 PyObject * obj0 = 0 ;
10361 PyObject * obj1 = 0 ;
10362
10363 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10364 {
10365 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10366 if (SWIG_arg_fail(1)) SWIG_fail;
10367 }
10368 {
10369 arg2 = wxString_in_helper(obj1);
10370 if (arg2 == NULL) SWIG_fail;
10371 temp2 = true;
10372 }
10373 {
10374 PyThreadState* __tstate = wxPyBeginAllowThreads();
10375 wxPyLogTrace(arg1,(wxString const &)*arg2);
10376
10377 wxPyEndAllowThreads(__tstate);
10378 if (PyErr_Occurred()) SWIG_fail;
10379 }
10380 Py_INCREF(Py_None); resultobj = Py_None;
10381 {
10382 if (temp2)
10383 delete arg2;
10384 }
10385 return resultobj;
10386 fail:
10387 {
10388 if (temp2)
10389 delete arg2;
10390 }
10391 return NULL;
10392 }
10393
10394
10395 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10396 PyObject *resultobj;
10397 wxString *arg1 = 0 ;
10398 wxString *arg2 = 0 ;
10399 bool temp1 = false ;
10400 bool temp2 = false ;
10401 PyObject * obj0 = 0 ;
10402 PyObject * obj1 = 0 ;
10403
10404 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10405 {
10406 arg1 = wxString_in_helper(obj0);
10407 if (arg1 == NULL) SWIG_fail;
10408 temp1 = true;
10409 }
10410 {
10411 arg2 = wxString_in_helper(obj1);
10412 if (arg2 == NULL) SWIG_fail;
10413 temp2 = true;
10414 }
10415 {
10416 PyThreadState* __tstate = wxPyBeginAllowThreads();
10417 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10418
10419 wxPyEndAllowThreads(__tstate);
10420 if (PyErr_Occurred()) SWIG_fail;
10421 }
10422 Py_INCREF(Py_None); resultobj = Py_None;
10423 {
10424 if (temp1)
10425 delete arg1;
10426 }
10427 {
10428 if (temp2)
10429 delete arg2;
10430 }
10431 return resultobj;
10432 fail:
10433 {
10434 if (temp1)
10435 delete arg1;
10436 }
10437 {
10438 if (temp2)
10439 delete arg2;
10440 }
10441 return NULL;
10442 }
10443
10444
10445 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10446 int argc;
10447 PyObject *argv[3];
10448 int ii;
10449
10450 argc = PyObject_Length(args);
10451 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10452 argv[ii] = PyTuple_GetItem(args,ii);
10453 }
10454 if (argc == 2) {
10455 int _v;
10456 {
10457 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10458 }
10459 if (_v) {
10460 {
10461 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10462 }
10463 if (_v) {
10464 return _wrap_LogTrace__SWIG_1(self,args);
10465 }
10466 }
10467 }
10468 if (argc == 2) {
10469 int _v;
10470 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10471 if (_v) {
10472 {
10473 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10474 }
10475 if (_v) {
10476 return _wrap_LogTrace__SWIG_0(self,args);
10477 }
10478 }
10479 }
10480
10481 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10482 return NULL;
10483 }
10484
10485
10486 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10487 PyObject *resultobj;
10488 wxString *arg1 = 0 ;
10489 wxString *arg2 = 0 ;
10490 bool temp1 = false ;
10491 bool temp2 = false ;
10492 PyObject * obj0 = 0 ;
10493 PyObject * obj1 = 0 ;
10494 char *kwnames[] = {
10495 (char *) "title",(char *) "text", NULL
10496 };
10497
10498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10499 {
10500 arg1 = wxString_in_helper(obj0);
10501 if (arg1 == NULL) SWIG_fail;
10502 temp1 = true;
10503 }
10504 {
10505 arg2 = wxString_in_helper(obj1);
10506 if (arg2 == NULL) SWIG_fail;
10507 temp2 = true;
10508 }
10509 {
10510 PyThreadState* __tstate = wxPyBeginAllowThreads();
10511 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10512
10513 wxPyEndAllowThreads(__tstate);
10514 if (PyErr_Occurred()) SWIG_fail;
10515 }
10516 Py_INCREF(Py_None); resultobj = Py_None;
10517 {
10518 if (temp1)
10519 delete arg1;
10520 }
10521 {
10522 if (temp2)
10523 delete arg2;
10524 }
10525 return resultobj;
10526 fail:
10527 {
10528 if (temp1)
10529 delete arg1;
10530 }
10531 {
10532 if (temp2)
10533 delete arg2;
10534 }
10535 return NULL;
10536 }
10537
10538
10539 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10540 PyObject *resultobj;
10541 wxLogNull *result;
10542 char *kwnames[] = {
10543 NULL
10544 };
10545
10546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10547 {
10548 PyThreadState* __tstate = wxPyBeginAllowThreads();
10549 result = (wxLogNull *)new wxLogNull();
10550
10551 wxPyEndAllowThreads(__tstate);
10552 if (PyErr_Occurred()) SWIG_fail;
10553 }
10554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10555 return resultobj;
10556 fail:
10557 return NULL;
10558 }
10559
10560
10561 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10562 PyObject *resultobj;
10563 wxLogNull *arg1 = (wxLogNull *) 0 ;
10564 PyObject * obj0 = 0 ;
10565 char *kwnames[] = {
10566 (char *) "self", NULL
10567 };
10568
10569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10571 if (SWIG_arg_fail(1)) SWIG_fail;
10572 {
10573 PyThreadState* __tstate = wxPyBeginAllowThreads();
10574 delete arg1;
10575
10576 wxPyEndAllowThreads(__tstate);
10577 if (PyErr_Occurred()) SWIG_fail;
10578 }
10579 Py_INCREF(Py_None); resultobj = Py_None;
10580 return resultobj;
10581 fail:
10582 return NULL;
10583 }
10584
10585
10586 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10587 PyObject *obj;
10588 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10589 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10590 Py_INCREF(obj);
10591 return Py_BuildValue((char *)"");
10592 }
10593 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10594 PyObject *resultobj;
10595 wxPyLog *result;
10596 char *kwnames[] = {
10597 NULL
10598 };
10599
10600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10601 {
10602 PyThreadState* __tstate = wxPyBeginAllowThreads();
10603 result = (wxPyLog *)new wxPyLog();
10604
10605 wxPyEndAllowThreads(__tstate);
10606 if (PyErr_Occurred()) SWIG_fail;
10607 }
10608 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10609 return resultobj;
10610 fail:
10611 return NULL;
10612 }
10613
10614
10615 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10616 PyObject *resultobj;
10617 wxPyLog *arg1 = (wxPyLog *) 0 ;
10618 PyObject *arg2 = (PyObject *) 0 ;
10619 PyObject *arg3 = (PyObject *) 0 ;
10620 PyObject * obj0 = 0 ;
10621 PyObject * obj1 = 0 ;
10622 PyObject * obj2 = 0 ;
10623 char *kwnames[] = {
10624 (char *) "self",(char *) "self",(char *) "_class", NULL
10625 };
10626
10627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10629 if (SWIG_arg_fail(1)) SWIG_fail;
10630 arg2 = obj1;
10631 arg3 = obj2;
10632 {
10633 PyThreadState* __tstate = wxPyBeginAllowThreads();
10634 (arg1)->_setCallbackInfo(arg2,arg3);
10635
10636 wxPyEndAllowThreads(__tstate);
10637 if (PyErr_Occurred()) SWIG_fail;
10638 }
10639 Py_INCREF(Py_None); resultobj = Py_None;
10640 return resultobj;
10641 fail:
10642 return NULL;
10643 }
10644
10645
10646 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10647 PyObject *obj;
10648 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10649 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10650 Py_INCREF(obj);
10651 return Py_BuildValue((char *)"");
10652 }
10653 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10654 PyObject *resultobj;
10655 int arg1 ;
10656 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10657 int arg3 = (int) wxKILL_NOCHILDREN ;
10658 wxKillError result;
10659 PyObject * obj0 = 0 ;
10660 PyObject * obj1 = 0 ;
10661 PyObject * obj2 = 0 ;
10662 char *kwnames[] = {
10663 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10664 };
10665
10666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10667 {
10668 arg1 = (int)(SWIG_As_int(obj0));
10669 if (SWIG_arg_fail(1)) SWIG_fail;
10670 }
10671 if (obj1) {
10672 {
10673 arg2 = (wxSignal)(SWIG_As_int(obj1));
10674 if (SWIG_arg_fail(2)) SWIG_fail;
10675 }
10676 }
10677 if (obj2) {
10678 {
10679 arg3 = (int)(SWIG_As_int(obj2));
10680 if (SWIG_arg_fail(3)) SWIG_fail;
10681 }
10682 }
10683 {
10684 PyThreadState* __tstate = wxPyBeginAllowThreads();
10685 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10686
10687 wxPyEndAllowThreads(__tstate);
10688 if (PyErr_Occurred()) SWIG_fail;
10689 }
10690 resultobj = SWIG_From_int((result));
10691 return resultobj;
10692 fail:
10693 return NULL;
10694 }
10695
10696
10697 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10698 PyObject *resultobj;
10699 int arg1 ;
10700 bool result;
10701 PyObject * obj0 = 0 ;
10702 char *kwnames[] = {
10703 (char *) "pid", NULL
10704 };
10705
10706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10707 {
10708 arg1 = (int)(SWIG_As_int(obj0));
10709 if (SWIG_arg_fail(1)) SWIG_fail;
10710 }
10711 {
10712 PyThreadState* __tstate = wxPyBeginAllowThreads();
10713 result = (bool)wxPyProcess::Exists(arg1);
10714
10715 wxPyEndAllowThreads(__tstate);
10716 if (PyErr_Occurred()) SWIG_fail;
10717 }
10718 {
10719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10720 }
10721 return resultobj;
10722 fail:
10723 return NULL;
10724 }
10725
10726
10727 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10728 PyObject *resultobj;
10729 wxString *arg1 = 0 ;
10730 int arg2 = (int) wxEXEC_ASYNC ;
10731 wxPyProcess *result;
10732 bool temp1 = false ;
10733 PyObject * obj0 = 0 ;
10734 PyObject * obj1 = 0 ;
10735 char *kwnames[] = {
10736 (char *) "cmd",(char *) "flags", NULL
10737 };
10738
10739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10740 {
10741 arg1 = wxString_in_helper(obj0);
10742 if (arg1 == NULL) SWIG_fail;
10743 temp1 = true;
10744 }
10745 if (obj1) {
10746 {
10747 arg2 = (int)(SWIG_As_int(obj1));
10748 if (SWIG_arg_fail(2)) SWIG_fail;
10749 }
10750 }
10751 {
10752 PyThreadState* __tstate = wxPyBeginAllowThreads();
10753 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10754
10755 wxPyEndAllowThreads(__tstate);
10756 if (PyErr_Occurred()) SWIG_fail;
10757 }
10758 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10759 {
10760 if (temp1)
10761 delete arg1;
10762 }
10763 return resultobj;
10764 fail:
10765 {
10766 if (temp1)
10767 delete arg1;
10768 }
10769 return NULL;
10770 }
10771
10772
10773 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10774 PyObject *resultobj;
10775 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10776 int arg2 = (int) -1 ;
10777 wxPyProcess *result;
10778 PyObject * obj0 = 0 ;
10779 PyObject * obj1 = 0 ;
10780 char *kwnames[] = {
10781 (char *) "parent",(char *) "id", NULL
10782 };
10783
10784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10785 if (obj0) {
10786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10787 if (SWIG_arg_fail(1)) SWIG_fail;
10788 }
10789 if (obj1) {
10790 {
10791 arg2 = (int)(SWIG_As_int(obj1));
10792 if (SWIG_arg_fail(2)) SWIG_fail;
10793 }
10794 }
10795 {
10796 PyThreadState* __tstate = wxPyBeginAllowThreads();
10797 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10798
10799 wxPyEndAllowThreads(__tstate);
10800 if (PyErr_Occurred()) SWIG_fail;
10801 }
10802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10803 return resultobj;
10804 fail:
10805 return NULL;
10806 }
10807
10808
10809 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10810 PyObject *resultobj;
10811 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10812 PyObject *arg2 = (PyObject *) 0 ;
10813 PyObject *arg3 = (PyObject *) 0 ;
10814 PyObject * obj0 = 0 ;
10815 PyObject * obj1 = 0 ;
10816 PyObject * obj2 = 0 ;
10817 char *kwnames[] = {
10818 (char *) "self",(char *) "self",(char *) "_class", NULL
10819 };
10820
10821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10823 if (SWIG_arg_fail(1)) SWIG_fail;
10824 arg2 = obj1;
10825 arg3 = obj2;
10826 {
10827 PyThreadState* __tstate = wxPyBeginAllowThreads();
10828 (arg1)->_setCallbackInfo(arg2,arg3);
10829
10830 wxPyEndAllowThreads(__tstate);
10831 if (PyErr_Occurred()) SWIG_fail;
10832 }
10833 Py_INCREF(Py_None); resultobj = Py_None;
10834 return resultobj;
10835 fail:
10836 return NULL;
10837 }
10838
10839
10840 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10841 PyObject *resultobj;
10842 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10843 int arg2 ;
10844 int arg3 ;
10845 PyObject * obj0 = 0 ;
10846 PyObject * obj1 = 0 ;
10847 PyObject * obj2 = 0 ;
10848 char *kwnames[] = {
10849 (char *) "self",(char *) "pid",(char *) "status", NULL
10850 };
10851
10852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10854 if (SWIG_arg_fail(1)) SWIG_fail;
10855 {
10856 arg2 = (int)(SWIG_As_int(obj1));
10857 if (SWIG_arg_fail(2)) SWIG_fail;
10858 }
10859 {
10860 arg3 = (int)(SWIG_As_int(obj2));
10861 if (SWIG_arg_fail(3)) SWIG_fail;
10862 }
10863 {
10864 PyThreadState* __tstate = wxPyBeginAllowThreads();
10865 (arg1)->base_OnTerminate(arg2,arg3);
10866
10867 wxPyEndAllowThreads(__tstate);
10868 if (PyErr_Occurred()) SWIG_fail;
10869 }
10870 Py_INCREF(Py_None); resultobj = Py_None;
10871 return resultobj;
10872 fail:
10873 return NULL;
10874 }
10875
10876
10877 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10878 PyObject *resultobj;
10879 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10880 PyObject * obj0 = 0 ;
10881 char *kwnames[] = {
10882 (char *) "self", NULL
10883 };
10884
10885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10887 if (SWIG_arg_fail(1)) SWIG_fail;
10888 {
10889 PyThreadState* __tstate = wxPyBeginAllowThreads();
10890 (arg1)->Redirect();
10891
10892 wxPyEndAllowThreads(__tstate);
10893 if (PyErr_Occurred()) SWIG_fail;
10894 }
10895 Py_INCREF(Py_None); resultobj = Py_None;
10896 return resultobj;
10897 fail:
10898 return NULL;
10899 }
10900
10901
10902 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10903 PyObject *resultobj;
10904 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10905 bool result;
10906 PyObject * obj0 = 0 ;
10907 char *kwnames[] = {
10908 (char *) "self", NULL
10909 };
10910
10911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10913 if (SWIG_arg_fail(1)) SWIG_fail;
10914 {
10915 PyThreadState* __tstate = wxPyBeginAllowThreads();
10916 result = (bool)(arg1)->IsRedirected();
10917
10918 wxPyEndAllowThreads(__tstate);
10919 if (PyErr_Occurred()) SWIG_fail;
10920 }
10921 {
10922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10923 }
10924 return resultobj;
10925 fail:
10926 return NULL;
10927 }
10928
10929
10930 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10931 PyObject *resultobj;
10932 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10933 PyObject * obj0 = 0 ;
10934 char *kwnames[] = {
10935 (char *) "self", NULL
10936 };
10937
10938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10940 if (SWIG_arg_fail(1)) SWIG_fail;
10941 {
10942 PyThreadState* __tstate = wxPyBeginAllowThreads();
10943 (arg1)->Detach();
10944
10945 wxPyEndAllowThreads(__tstate);
10946 if (PyErr_Occurred()) SWIG_fail;
10947 }
10948 Py_INCREF(Py_None); resultobj = Py_None;
10949 return resultobj;
10950 fail:
10951 return NULL;
10952 }
10953
10954
10955 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10956 PyObject *resultobj;
10957 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10958 wxInputStream *result;
10959 PyObject * obj0 = 0 ;
10960 char *kwnames[] = {
10961 (char *) "self", NULL
10962 };
10963
10964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
10965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10966 if (SWIG_arg_fail(1)) SWIG_fail;
10967 {
10968 PyThreadState* __tstate = wxPyBeginAllowThreads();
10969 result = (wxInputStream *)(arg1)->GetInputStream();
10970
10971 wxPyEndAllowThreads(__tstate);
10972 if (PyErr_Occurred()) SWIG_fail;
10973 }
10974 {
10975 wxPyInputStream * _ptr = NULL;
10976
10977 if (result) {
10978 _ptr = new wxPyInputStream(result);
10979 }
10980 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10981 }
10982 return resultobj;
10983 fail:
10984 return NULL;
10985 }
10986
10987
10988 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
10989 PyObject *resultobj;
10990 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10991 wxInputStream *result;
10992 PyObject * obj0 = 0 ;
10993 char *kwnames[] = {
10994 (char *) "self", NULL
10995 };
10996
10997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
10998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10999 if (SWIG_arg_fail(1)) SWIG_fail;
11000 {
11001 PyThreadState* __tstate = wxPyBeginAllowThreads();
11002 result = (wxInputStream *)(arg1)->GetErrorStream();
11003
11004 wxPyEndAllowThreads(__tstate);
11005 if (PyErr_Occurred()) SWIG_fail;
11006 }
11007 {
11008 wxPyInputStream * _ptr = NULL;
11009
11010 if (result) {
11011 _ptr = new wxPyInputStream(result);
11012 }
11013 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11014 }
11015 return resultobj;
11016 fail:
11017 return NULL;
11018 }
11019
11020
11021 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11022 PyObject *resultobj;
11023 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11024 wxOutputStream *result;
11025 PyObject * obj0 = 0 ;
11026 char *kwnames[] = {
11027 (char *) "self", NULL
11028 };
11029
11030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11032 if (SWIG_arg_fail(1)) SWIG_fail;
11033 {
11034 PyThreadState* __tstate = wxPyBeginAllowThreads();
11035 result = (wxOutputStream *)(arg1)->GetOutputStream();
11036
11037 wxPyEndAllowThreads(__tstate);
11038 if (PyErr_Occurred()) SWIG_fail;
11039 }
11040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11041 return resultobj;
11042 fail:
11043 return NULL;
11044 }
11045
11046
11047 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11048 PyObject *resultobj;
11049 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11050 PyObject * obj0 = 0 ;
11051 char *kwnames[] = {
11052 (char *) "self", NULL
11053 };
11054
11055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11057 if (SWIG_arg_fail(1)) SWIG_fail;
11058 {
11059 PyThreadState* __tstate = wxPyBeginAllowThreads();
11060 (arg1)->CloseOutput();
11061
11062 wxPyEndAllowThreads(__tstate);
11063 if (PyErr_Occurred()) SWIG_fail;
11064 }
11065 Py_INCREF(Py_None); resultobj = Py_None;
11066 return resultobj;
11067 fail:
11068 return NULL;
11069 }
11070
11071
11072 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11073 PyObject *resultobj;
11074 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11075 bool result;
11076 PyObject * obj0 = 0 ;
11077 char *kwnames[] = {
11078 (char *) "self", NULL
11079 };
11080
11081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11083 if (SWIG_arg_fail(1)) SWIG_fail;
11084 {
11085 PyThreadState* __tstate = wxPyBeginAllowThreads();
11086 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11087
11088 wxPyEndAllowThreads(__tstate);
11089 if (PyErr_Occurred()) SWIG_fail;
11090 }
11091 {
11092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11093 }
11094 return resultobj;
11095 fail:
11096 return NULL;
11097 }
11098
11099
11100 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11101 PyObject *resultobj;
11102 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11103 bool result;
11104 PyObject * obj0 = 0 ;
11105 char *kwnames[] = {
11106 (char *) "self", NULL
11107 };
11108
11109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11111 if (SWIG_arg_fail(1)) SWIG_fail;
11112 {
11113 PyThreadState* __tstate = wxPyBeginAllowThreads();
11114 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11115
11116 wxPyEndAllowThreads(__tstate);
11117 if (PyErr_Occurred()) SWIG_fail;
11118 }
11119 {
11120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11121 }
11122 return resultobj;
11123 fail:
11124 return NULL;
11125 }
11126
11127
11128 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11129 PyObject *resultobj;
11130 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11131 bool result;
11132 PyObject * obj0 = 0 ;
11133 char *kwnames[] = {
11134 (char *) "self", NULL
11135 };
11136
11137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11139 if (SWIG_arg_fail(1)) SWIG_fail;
11140 {
11141 PyThreadState* __tstate = wxPyBeginAllowThreads();
11142 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11143
11144 wxPyEndAllowThreads(__tstate);
11145 if (PyErr_Occurred()) SWIG_fail;
11146 }
11147 {
11148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11149 }
11150 return resultobj;
11151 fail:
11152 return NULL;
11153 }
11154
11155
11156 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11157 PyObject *obj;
11158 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11159 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11160 Py_INCREF(obj);
11161 return Py_BuildValue((char *)"");
11162 }
11163 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11164 PyObject *resultobj;
11165 int arg1 = (int) 0 ;
11166 int arg2 = (int) 0 ;
11167 int arg3 = (int) 0 ;
11168 wxProcessEvent *result;
11169 PyObject * obj0 = 0 ;
11170 PyObject * obj1 = 0 ;
11171 PyObject * obj2 = 0 ;
11172 char *kwnames[] = {
11173 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11174 };
11175
11176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11177 if (obj0) {
11178 {
11179 arg1 = (int)(SWIG_As_int(obj0));
11180 if (SWIG_arg_fail(1)) SWIG_fail;
11181 }
11182 }
11183 if (obj1) {
11184 {
11185 arg2 = (int)(SWIG_As_int(obj1));
11186 if (SWIG_arg_fail(2)) SWIG_fail;
11187 }
11188 }
11189 if (obj2) {
11190 {
11191 arg3 = (int)(SWIG_As_int(obj2));
11192 if (SWIG_arg_fail(3)) SWIG_fail;
11193 }
11194 }
11195 {
11196 PyThreadState* __tstate = wxPyBeginAllowThreads();
11197 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11198
11199 wxPyEndAllowThreads(__tstate);
11200 if (PyErr_Occurred()) SWIG_fail;
11201 }
11202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11203 return resultobj;
11204 fail:
11205 return NULL;
11206 }
11207
11208
11209 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11210 PyObject *resultobj;
11211 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11212 int result;
11213 PyObject * obj0 = 0 ;
11214 char *kwnames[] = {
11215 (char *) "self", NULL
11216 };
11217
11218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11220 if (SWIG_arg_fail(1)) SWIG_fail;
11221 {
11222 PyThreadState* __tstate = wxPyBeginAllowThreads();
11223 result = (int)(arg1)->GetPid();
11224
11225 wxPyEndAllowThreads(__tstate);
11226 if (PyErr_Occurred()) SWIG_fail;
11227 }
11228 {
11229 resultobj = SWIG_From_int((int)(result));
11230 }
11231 return resultobj;
11232 fail:
11233 return NULL;
11234 }
11235
11236
11237 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11238 PyObject *resultobj;
11239 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11240 int result;
11241 PyObject * obj0 = 0 ;
11242 char *kwnames[] = {
11243 (char *) "self", NULL
11244 };
11245
11246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11248 if (SWIG_arg_fail(1)) SWIG_fail;
11249 {
11250 PyThreadState* __tstate = wxPyBeginAllowThreads();
11251 result = (int)(arg1)->GetExitCode();
11252
11253 wxPyEndAllowThreads(__tstate);
11254 if (PyErr_Occurred()) SWIG_fail;
11255 }
11256 {
11257 resultobj = SWIG_From_int((int)(result));
11258 }
11259 return resultobj;
11260 fail:
11261 return NULL;
11262 }
11263
11264
11265 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11266 PyObject *resultobj;
11267 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11268 int arg2 ;
11269 PyObject * obj0 = 0 ;
11270 PyObject * obj1 = 0 ;
11271 char *kwnames[] = {
11272 (char *) "self",(char *) "m_pid", NULL
11273 };
11274
11275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11277 if (SWIG_arg_fail(1)) SWIG_fail;
11278 {
11279 arg2 = (int)(SWIG_As_int(obj1));
11280 if (SWIG_arg_fail(2)) SWIG_fail;
11281 }
11282 if (arg1) (arg1)->m_pid = arg2;
11283
11284 Py_INCREF(Py_None); resultobj = Py_None;
11285 return resultobj;
11286 fail:
11287 return NULL;
11288 }
11289
11290
11291 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11292 PyObject *resultobj;
11293 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11294 int result;
11295 PyObject * obj0 = 0 ;
11296 char *kwnames[] = {
11297 (char *) "self", NULL
11298 };
11299
11300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11302 if (SWIG_arg_fail(1)) SWIG_fail;
11303 result = (int) ((arg1)->m_pid);
11304
11305 {
11306 resultobj = SWIG_From_int((int)(result));
11307 }
11308 return resultobj;
11309 fail:
11310 return NULL;
11311 }
11312
11313
11314 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11315 PyObject *resultobj;
11316 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11317 int arg2 ;
11318 PyObject * obj0 = 0 ;
11319 PyObject * obj1 = 0 ;
11320 char *kwnames[] = {
11321 (char *) "self",(char *) "m_exitcode", NULL
11322 };
11323
11324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11326 if (SWIG_arg_fail(1)) SWIG_fail;
11327 {
11328 arg2 = (int)(SWIG_As_int(obj1));
11329 if (SWIG_arg_fail(2)) SWIG_fail;
11330 }
11331 if (arg1) (arg1)->m_exitcode = arg2;
11332
11333 Py_INCREF(Py_None); resultobj = Py_None;
11334 return resultobj;
11335 fail:
11336 return NULL;
11337 }
11338
11339
11340 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11341 PyObject *resultobj;
11342 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11343 int result;
11344 PyObject * obj0 = 0 ;
11345 char *kwnames[] = {
11346 (char *) "self", NULL
11347 };
11348
11349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11351 if (SWIG_arg_fail(1)) SWIG_fail;
11352 result = (int) ((arg1)->m_exitcode);
11353
11354 {
11355 resultobj = SWIG_From_int((int)(result));
11356 }
11357 return resultobj;
11358 fail:
11359 return NULL;
11360 }
11361
11362
11363 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11364 PyObject *obj;
11365 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11366 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11367 Py_INCREF(obj);
11368 return Py_BuildValue((char *)"");
11369 }
11370 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11371 PyObject *resultobj;
11372 wxString *arg1 = 0 ;
11373 int arg2 = (int) wxEXEC_ASYNC ;
11374 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11375 long result;
11376 bool temp1 = false ;
11377 PyObject * obj0 = 0 ;
11378 PyObject * obj1 = 0 ;
11379 PyObject * obj2 = 0 ;
11380 char *kwnames[] = {
11381 (char *) "command",(char *) "flags",(char *) "process", NULL
11382 };
11383
11384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11385 {
11386 arg1 = wxString_in_helper(obj0);
11387 if (arg1 == NULL) SWIG_fail;
11388 temp1 = true;
11389 }
11390 if (obj1) {
11391 {
11392 arg2 = (int)(SWIG_As_int(obj1));
11393 if (SWIG_arg_fail(2)) SWIG_fail;
11394 }
11395 }
11396 if (obj2) {
11397 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11398 if (SWIG_arg_fail(3)) SWIG_fail;
11399 }
11400 {
11401 if (!wxPyCheckForApp()) SWIG_fail;
11402 PyThreadState* __tstate = wxPyBeginAllowThreads();
11403 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11404
11405 wxPyEndAllowThreads(__tstate);
11406 if (PyErr_Occurred()) SWIG_fail;
11407 }
11408 {
11409 resultobj = SWIG_From_long((long)(result));
11410 }
11411 {
11412 if (temp1)
11413 delete arg1;
11414 }
11415 return resultobj;
11416 fail:
11417 {
11418 if (temp1)
11419 delete arg1;
11420 }
11421 return NULL;
11422 }
11423
11424
11425 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11426 PyObject *resultobj;
11427 long arg1 ;
11428 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11429 wxKillError *arg3 = (wxKillError *) 0 ;
11430 int arg4 = (int) wxKILL_NOCHILDREN ;
11431 int result;
11432 wxKillError temp3 ;
11433 PyObject * obj0 = 0 ;
11434 PyObject * obj1 = 0 ;
11435 PyObject * obj2 = 0 ;
11436 char *kwnames[] = {
11437 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11438 };
11439
11440 {
11441 arg3 = &temp3;
11442 }
11443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11444 {
11445 arg1 = (long)(SWIG_As_long(obj0));
11446 if (SWIG_arg_fail(1)) SWIG_fail;
11447 }
11448 if (obj1) {
11449 {
11450 arg2 = (wxSignal)(SWIG_As_int(obj1));
11451 if (SWIG_arg_fail(2)) SWIG_fail;
11452 }
11453 }
11454 if (obj2) {
11455 {
11456 arg4 = (int)(SWIG_As_int(obj2));
11457 if (SWIG_arg_fail(4)) SWIG_fail;
11458 }
11459 }
11460 {
11461 PyThreadState* __tstate = wxPyBeginAllowThreads();
11462 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11463
11464 wxPyEndAllowThreads(__tstate);
11465 if (PyErr_Occurred()) SWIG_fail;
11466 }
11467 {
11468 resultobj = SWIG_From_int((int)(result));
11469 }
11470 {
11471 PyObject* o;
11472 o = PyInt_FromLong((long) (*arg3));
11473 resultobj = t_output_helper(resultobj, o);
11474 }
11475 return resultobj;
11476 fail:
11477 return NULL;
11478 }
11479
11480
11481 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11482 PyObject *resultobj;
11483 int arg1 = (int) wxJOYSTICK1 ;
11484 wxJoystick *result;
11485 PyObject * obj0 = 0 ;
11486 char *kwnames[] = {
11487 (char *) "joystick", NULL
11488 };
11489
11490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11491 if (obj0) {
11492 {
11493 arg1 = (int)(SWIG_As_int(obj0));
11494 if (SWIG_arg_fail(1)) SWIG_fail;
11495 }
11496 }
11497 {
11498 if (!wxPyCheckForApp()) SWIG_fail;
11499 PyThreadState* __tstate = wxPyBeginAllowThreads();
11500 result = (wxJoystick *)new wxJoystick(arg1);
11501
11502 wxPyEndAllowThreads(__tstate);
11503 if (PyErr_Occurred()) SWIG_fail;
11504 }
11505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11506 return resultobj;
11507 fail:
11508 return NULL;
11509 }
11510
11511
11512 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11513 PyObject *resultobj;
11514 wxJoystick *arg1 = (wxJoystick *) 0 ;
11515 PyObject * obj0 = 0 ;
11516 char *kwnames[] = {
11517 (char *) "self", NULL
11518 };
11519
11520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11522 if (SWIG_arg_fail(1)) SWIG_fail;
11523 {
11524 PyThreadState* __tstate = wxPyBeginAllowThreads();
11525 delete arg1;
11526
11527 wxPyEndAllowThreads(__tstate);
11528 if (PyErr_Occurred()) SWIG_fail;
11529 }
11530 Py_INCREF(Py_None); resultobj = Py_None;
11531 return resultobj;
11532 fail:
11533 return NULL;
11534 }
11535
11536
11537 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11538 PyObject *resultobj;
11539 wxJoystick *arg1 = (wxJoystick *) 0 ;
11540 wxPoint result;
11541 PyObject * obj0 = 0 ;
11542 char *kwnames[] = {
11543 (char *) "self", NULL
11544 };
11545
11546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11548 if (SWIG_arg_fail(1)) SWIG_fail;
11549 {
11550 PyThreadState* __tstate = wxPyBeginAllowThreads();
11551 result = (arg1)->GetPosition();
11552
11553 wxPyEndAllowThreads(__tstate);
11554 if (PyErr_Occurred()) SWIG_fail;
11555 }
11556 {
11557 wxPoint * resultptr;
11558 resultptr = new wxPoint((wxPoint &)(result));
11559 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11560 }
11561 return resultobj;
11562 fail:
11563 return NULL;
11564 }
11565
11566
11567 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11568 PyObject *resultobj;
11569 wxJoystick *arg1 = (wxJoystick *) 0 ;
11570 int result;
11571 PyObject * obj0 = 0 ;
11572 char *kwnames[] = {
11573 (char *) "self", NULL
11574 };
11575
11576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11578 if (SWIG_arg_fail(1)) SWIG_fail;
11579 {
11580 PyThreadState* __tstate = wxPyBeginAllowThreads();
11581 result = (int)(arg1)->GetZPosition();
11582
11583 wxPyEndAllowThreads(__tstate);
11584 if (PyErr_Occurred()) SWIG_fail;
11585 }
11586 {
11587 resultobj = SWIG_From_int((int)(result));
11588 }
11589 return resultobj;
11590 fail:
11591 return NULL;
11592 }
11593
11594
11595 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11596 PyObject *resultobj;
11597 wxJoystick *arg1 = (wxJoystick *) 0 ;
11598 int result;
11599 PyObject * obj0 = 0 ;
11600 char *kwnames[] = {
11601 (char *) "self", NULL
11602 };
11603
11604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11606 if (SWIG_arg_fail(1)) SWIG_fail;
11607 {
11608 PyThreadState* __tstate = wxPyBeginAllowThreads();
11609 result = (int)(arg1)->GetButtonState();
11610
11611 wxPyEndAllowThreads(__tstate);
11612 if (PyErr_Occurred()) SWIG_fail;
11613 }
11614 {
11615 resultobj = SWIG_From_int((int)(result));
11616 }
11617 return resultobj;
11618 fail:
11619 return NULL;
11620 }
11621
11622
11623 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11624 PyObject *resultobj;
11625 wxJoystick *arg1 = (wxJoystick *) 0 ;
11626 int result;
11627 PyObject * obj0 = 0 ;
11628 char *kwnames[] = {
11629 (char *) "self", NULL
11630 };
11631
11632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11634 if (SWIG_arg_fail(1)) SWIG_fail;
11635 {
11636 PyThreadState* __tstate = wxPyBeginAllowThreads();
11637 result = (int)(arg1)->GetPOVPosition();
11638
11639 wxPyEndAllowThreads(__tstate);
11640 if (PyErr_Occurred()) SWIG_fail;
11641 }
11642 {
11643 resultobj = SWIG_From_int((int)(result));
11644 }
11645 return resultobj;
11646 fail:
11647 return NULL;
11648 }
11649
11650
11651 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11652 PyObject *resultobj;
11653 wxJoystick *arg1 = (wxJoystick *) 0 ;
11654 int result;
11655 PyObject * obj0 = 0 ;
11656 char *kwnames[] = {
11657 (char *) "self", NULL
11658 };
11659
11660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11662 if (SWIG_arg_fail(1)) SWIG_fail;
11663 {
11664 PyThreadState* __tstate = wxPyBeginAllowThreads();
11665 result = (int)(arg1)->GetPOVCTSPosition();
11666
11667 wxPyEndAllowThreads(__tstate);
11668 if (PyErr_Occurred()) SWIG_fail;
11669 }
11670 {
11671 resultobj = SWIG_From_int((int)(result));
11672 }
11673 return resultobj;
11674 fail:
11675 return NULL;
11676 }
11677
11678
11679 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11680 PyObject *resultobj;
11681 wxJoystick *arg1 = (wxJoystick *) 0 ;
11682 int result;
11683 PyObject * obj0 = 0 ;
11684 char *kwnames[] = {
11685 (char *) "self", NULL
11686 };
11687
11688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11690 if (SWIG_arg_fail(1)) SWIG_fail;
11691 {
11692 PyThreadState* __tstate = wxPyBeginAllowThreads();
11693 result = (int)(arg1)->GetRudderPosition();
11694
11695 wxPyEndAllowThreads(__tstate);
11696 if (PyErr_Occurred()) SWIG_fail;
11697 }
11698 {
11699 resultobj = SWIG_From_int((int)(result));
11700 }
11701 return resultobj;
11702 fail:
11703 return NULL;
11704 }
11705
11706
11707 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11708 PyObject *resultobj;
11709 wxJoystick *arg1 = (wxJoystick *) 0 ;
11710 int result;
11711 PyObject * obj0 = 0 ;
11712 char *kwnames[] = {
11713 (char *) "self", NULL
11714 };
11715
11716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11718 if (SWIG_arg_fail(1)) SWIG_fail;
11719 {
11720 PyThreadState* __tstate = wxPyBeginAllowThreads();
11721 result = (int)(arg1)->GetUPosition();
11722
11723 wxPyEndAllowThreads(__tstate);
11724 if (PyErr_Occurred()) SWIG_fail;
11725 }
11726 {
11727 resultobj = SWIG_From_int((int)(result));
11728 }
11729 return resultobj;
11730 fail:
11731 return NULL;
11732 }
11733
11734
11735 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11736 PyObject *resultobj;
11737 wxJoystick *arg1 = (wxJoystick *) 0 ;
11738 int result;
11739 PyObject * obj0 = 0 ;
11740 char *kwnames[] = {
11741 (char *) "self", NULL
11742 };
11743
11744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11746 if (SWIG_arg_fail(1)) SWIG_fail;
11747 {
11748 PyThreadState* __tstate = wxPyBeginAllowThreads();
11749 result = (int)(arg1)->GetVPosition();
11750
11751 wxPyEndAllowThreads(__tstate);
11752 if (PyErr_Occurred()) SWIG_fail;
11753 }
11754 {
11755 resultobj = SWIG_From_int((int)(result));
11756 }
11757 return resultobj;
11758 fail:
11759 return NULL;
11760 }
11761
11762
11763 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11764 PyObject *resultobj;
11765 wxJoystick *arg1 = (wxJoystick *) 0 ;
11766 int result;
11767 PyObject * obj0 = 0 ;
11768 char *kwnames[] = {
11769 (char *) "self", NULL
11770 };
11771
11772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11774 if (SWIG_arg_fail(1)) SWIG_fail;
11775 {
11776 PyThreadState* __tstate = wxPyBeginAllowThreads();
11777 result = (int)(arg1)->GetMovementThreshold();
11778
11779 wxPyEndAllowThreads(__tstate);
11780 if (PyErr_Occurred()) SWIG_fail;
11781 }
11782 {
11783 resultobj = SWIG_From_int((int)(result));
11784 }
11785 return resultobj;
11786 fail:
11787 return NULL;
11788 }
11789
11790
11791 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11792 PyObject *resultobj;
11793 wxJoystick *arg1 = (wxJoystick *) 0 ;
11794 int arg2 ;
11795 PyObject * obj0 = 0 ;
11796 PyObject * obj1 = 0 ;
11797 char *kwnames[] = {
11798 (char *) "self",(char *) "threshold", NULL
11799 };
11800
11801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11803 if (SWIG_arg_fail(1)) SWIG_fail;
11804 {
11805 arg2 = (int)(SWIG_As_int(obj1));
11806 if (SWIG_arg_fail(2)) SWIG_fail;
11807 }
11808 {
11809 PyThreadState* __tstate = wxPyBeginAllowThreads();
11810 (arg1)->SetMovementThreshold(arg2);
11811
11812 wxPyEndAllowThreads(__tstate);
11813 if (PyErr_Occurred()) SWIG_fail;
11814 }
11815 Py_INCREF(Py_None); resultobj = Py_None;
11816 return resultobj;
11817 fail:
11818 return NULL;
11819 }
11820
11821
11822 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11823 PyObject *resultobj;
11824 wxJoystick *arg1 = (wxJoystick *) 0 ;
11825 bool result;
11826 PyObject * obj0 = 0 ;
11827 char *kwnames[] = {
11828 (char *) "self", NULL
11829 };
11830
11831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11833 if (SWIG_arg_fail(1)) SWIG_fail;
11834 {
11835 PyThreadState* __tstate = wxPyBeginAllowThreads();
11836 result = (bool)(arg1)->IsOk();
11837
11838 wxPyEndAllowThreads(__tstate);
11839 if (PyErr_Occurred()) SWIG_fail;
11840 }
11841 {
11842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11843 }
11844 return resultobj;
11845 fail:
11846 return NULL;
11847 }
11848
11849
11850 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11851 PyObject *resultobj;
11852 wxJoystick *arg1 = (wxJoystick *) 0 ;
11853 int result;
11854 PyObject * obj0 = 0 ;
11855 char *kwnames[] = {
11856 (char *) "self", NULL
11857 };
11858
11859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11861 if (SWIG_arg_fail(1)) SWIG_fail;
11862 {
11863 PyThreadState* __tstate = wxPyBeginAllowThreads();
11864 result = (int)(arg1)->GetNumberJoysticks();
11865
11866 wxPyEndAllowThreads(__tstate);
11867 if (PyErr_Occurred()) SWIG_fail;
11868 }
11869 {
11870 resultobj = SWIG_From_int((int)(result));
11871 }
11872 return resultobj;
11873 fail:
11874 return NULL;
11875 }
11876
11877
11878 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11879 PyObject *resultobj;
11880 wxJoystick *arg1 = (wxJoystick *) 0 ;
11881 int result;
11882 PyObject * obj0 = 0 ;
11883 char *kwnames[] = {
11884 (char *) "self", NULL
11885 };
11886
11887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11889 if (SWIG_arg_fail(1)) SWIG_fail;
11890 {
11891 PyThreadState* __tstate = wxPyBeginAllowThreads();
11892 result = (int)(arg1)->GetManufacturerId();
11893
11894 wxPyEndAllowThreads(__tstate);
11895 if (PyErr_Occurred()) SWIG_fail;
11896 }
11897 {
11898 resultobj = SWIG_From_int((int)(result));
11899 }
11900 return resultobj;
11901 fail:
11902 return NULL;
11903 }
11904
11905
11906 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11907 PyObject *resultobj;
11908 wxJoystick *arg1 = (wxJoystick *) 0 ;
11909 int result;
11910 PyObject * obj0 = 0 ;
11911 char *kwnames[] = {
11912 (char *) "self", NULL
11913 };
11914
11915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11917 if (SWIG_arg_fail(1)) SWIG_fail;
11918 {
11919 PyThreadState* __tstate = wxPyBeginAllowThreads();
11920 result = (int)(arg1)->GetProductId();
11921
11922 wxPyEndAllowThreads(__tstate);
11923 if (PyErr_Occurred()) SWIG_fail;
11924 }
11925 {
11926 resultobj = SWIG_From_int((int)(result));
11927 }
11928 return resultobj;
11929 fail:
11930 return NULL;
11931 }
11932
11933
11934 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11935 PyObject *resultobj;
11936 wxJoystick *arg1 = (wxJoystick *) 0 ;
11937 wxString result;
11938 PyObject * obj0 = 0 ;
11939 char *kwnames[] = {
11940 (char *) "self", NULL
11941 };
11942
11943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11945 if (SWIG_arg_fail(1)) SWIG_fail;
11946 {
11947 PyThreadState* __tstate = wxPyBeginAllowThreads();
11948 result = (arg1)->GetProductName();
11949
11950 wxPyEndAllowThreads(__tstate);
11951 if (PyErr_Occurred()) SWIG_fail;
11952 }
11953 {
11954 #if wxUSE_UNICODE
11955 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11956 #else
11957 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11958 #endif
11959 }
11960 return resultobj;
11961 fail:
11962 return NULL;
11963 }
11964
11965
11966 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
11967 PyObject *resultobj;
11968 wxJoystick *arg1 = (wxJoystick *) 0 ;
11969 int result;
11970 PyObject * obj0 = 0 ;
11971 char *kwnames[] = {
11972 (char *) "self", NULL
11973 };
11974
11975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
11976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11977 if (SWIG_arg_fail(1)) SWIG_fail;
11978 {
11979 PyThreadState* __tstate = wxPyBeginAllowThreads();
11980 result = (int)(arg1)->GetXMin();
11981
11982 wxPyEndAllowThreads(__tstate);
11983 if (PyErr_Occurred()) SWIG_fail;
11984 }
11985 {
11986 resultobj = SWIG_From_int((int)(result));
11987 }
11988 return resultobj;
11989 fail:
11990 return NULL;
11991 }
11992
11993
11994 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
11995 PyObject *resultobj;
11996 wxJoystick *arg1 = (wxJoystick *) 0 ;
11997 int result;
11998 PyObject * obj0 = 0 ;
11999 char *kwnames[] = {
12000 (char *) "self", NULL
12001 };
12002
12003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12005 if (SWIG_arg_fail(1)) SWIG_fail;
12006 {
12007 PyThreadState* __tstate = wxPyBeginAllowThreads();
12008 result = (int)(arg1)->GetYMin();
12009
12010 wxPyEndAllowThreads(__tstate);
12011 if (PyErr_Occurred()) SWIG_fail;
12012 }
12013 {
12014 resultobj = SWIG_From_int((int)(result));
12015 }
12016 return resultobj;
12017 fail:
12018 return NULL;
12019 }
12020
12021
12022 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12023 PyObject *resultobj;
12024 wxJoystick *arg1 = (wxJoystick *) 0 ;
12025 int result;
12026 PyObject * obj0 = 0 ;
12027 char *kwnames[] = {
12028 (char *) "self", NULL
12029 };
12030
12031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12033 if (SWIG_arg_fail(1)) SWIG_fail;
12034 {
12035 PyThreadState* __tstate = wxPyBeginAllowThreads();
12036 result = (int)(arg1)->GetZMin();
12037
12038 wxPyEndAllowThreads(__tstate);
12039 if (PyErr_Occurred()) SWIG_fail;
12040 }
12041 {
12042 resultobj = SWIG_From_int((int)(result));
12043 }
12044 return resultobj;
12045 fail:
12046 return NULL;
12047 }
12048
12049
12050 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12051 PyObject *resultobj;
12052 wxJoystick *arg1 = (wxJoystick *) 0 ;
12053 int result;
12054 PyObject * obj0 = 0 ;
12055 char *kwnames[] = {
12056 (char *) "self", NULL
12057 };
12058
12059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12061 if (SWIG_arg_fail(1)) SWIG_fail;
12062 {
12063 PyThreadState* __tstate = wxPyBeginAllowThreads();
12064 result = (int)(arg1)->GetXMax();
12065
12066 wxPyEndAllowThreads(__tstate);
12067 if (PyErr_Occurred()) SWIG_fail;
12068 }
12069 {
12070 resultobj = SWIG_From_int((int)(result));
12071 }
12072 return resultobj;
12073 fail:
12074 return NULL;
12075 }
12076
12077
12078 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12079 PyObject *resultobj;
12080 wxJoystick *arg1 = (wxJoystick *) 0 ;
12081 int result;
12082 PyObject * obj0 = 0 ;
12083 char *kwnames[] = {
12084 (char *) "self", NULL
12085 };
12086
12087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12089 if (SWIG_arg_fail(1)) SWIG_fail;
12090 {
12091 PyThreadState* __tstate = wxPyBeginAllowThreads();
12092 result = (int)(arg1)->GetYMax();
12093
12094 wxPyEndAllowThreads(__tstate);
12095 if (PyErr_Occurred()) SWIG_fail;
12096 }
12097 {
12098 resultobj = SWIG_From_int((int)(result));
12099 }
12100 return resultobj;
12101 fail:
12102 return NULL;
12103 }
12104
12105
12106 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12107 PyObject *resultobj;
12108 wxJoystick *arg1 = (wxJoystick *) 0 ;
12109 int result;
12110 PyObject * obj0 = 0 ;
12111 char *kwnames[] = {
12112 (char *) "self", NULL
12113 };
12114
12115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12117 if (SWIG_arg_fail(1)) SWIG_fail;
12118 {
12119 PyThreadState* __tstate = wxPyBeginAllowThreads();
12120 result = (int)(arg1)->GetZMax();
12121
12122 wxPyEndAllowThreads(__tstate);
12123 if (PyErr_Occurred()) SWIG_fail;
12124 }
12125 {
12126 resultobj = SWIG_From_int((int)(result));
12127 }
12128 return resultobj;
12129 fail:
12130 return NULL;
12131 }
12132
12133
12134 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12135 PyObject *resultobj;
12136 wxJoystick *arg1 = (wxJoystick *) 0 ;
12137 int result;
12138 PyObject * obj0 = 0 ;
12139 char *kwnames[] = {
12140 (char *) "self", NULL
12141 };
12142
12143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12145 if (SWIG_arg_fail(1)) SWIG_fail;
12146 {
12147 PyThreadState* __tstate = wxPyBeginAllowThreads();
12148 result = (int)(arg1)->GetNumberButtons();
12149
12150 wxPyEndAllowThreads(__tstate);
12151 if (PyErr_Occurred()) SWIG_fail;
12152 }
12153 {
12154 resultobj = SWIG_From_int((int)(result));
12155 }
12156 return resultobj;
12157 fail:
12158 return NULL;
12159 }
12160
12161
12162 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12163 PyObject *resultobj;
12164 wxJoystick *arg1 = (wxJoystick *) 0 ;
12165 int result;
12166 PyObject * obj0 = 0 ;
12167 char *kwnames[] = {
12168 (char *) "self", NULL
12169 };
12170
12171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12173 if (SWIG_arg_fail(1)) SWIG_fail;
12174 {
12175 PyThreadState* __tstate = wxPyBeginAllowThreads();
12176 result = (int)(arg1)->GetNumberAxes();
12177
12178 wxPyEndAllowThreads(__tstate);
12179 if (PyErr_Occurred()) SWIG_fail;
12180 }
12181 {
12182 resultobj = SWIG_From_int((int)(result));
12183 }
12184 return resultobj;
12185 fail:
12186 return NULL;
12187 }
12188
12189
12190 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12191 PyObject *resultobj;
12192 wxJoystick *arg1 = (wxJoystick *) 0 ;
12193 int result;
12194 PyObject * obj0 = 0 ;
12195 char *kwnames[] = {
12196 (char *) "self", NULL
12197 };
12198
12199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12201 if (SWIG_arg_fail(1)) SWIG_fail;
12202 {
12203 PyThreadState* __tstate = wxPyBeginAllowThreads();
12204 result = (int)(arg1)->GetMaxButtons();
12205
12206 wxPyEndAllowThreads(__tstate);
12207 if (PyErr_Occurred()) SWIG_fail;
12208 }
12209 {
12210 resultobj = SWIG_From_int((int)(result));
12211 }
12212 return resultobj;
12213 fail:
12214 return NULL;
12215 }
12216
12217
12218 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12219 PyObject *resultobj;
12220 wxJoystick *arg1 = (wxJoystick *) 0 ;
12221 int result;
12222 PyObject * obj0 = 0 ;
12223 char *kwnames[] = {
12224 (char *) "self", NULL
12225 };
12226
12227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12229 if (SWIG_arg_fail(1)) SWIG_fail;
12230 {
12231 PyThreadState* __tstate = wxPyBeginAllowThreads();
12232 result = (int)(arg1)->GetMaxAxes();
12233
12234 wxPyEndAllowThreads(__tstate);
12235 if (PyErr_Occurred()) SWIG_fail;
12236 }
12237 {
12238 resultobj = SWIG_From_int((int)(result));
12239 }
12240 return resultobj;
12241 fail:
12242 return NULL;
12243 }
12244
12245
12246 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12247 PyObject *resultobj;
12248 wxJoystick *arg1 = (wxJoystick *) 0 ;
12249 int result;
12250 PyObject * obj0 = 0 ;
12251 char *kwnames[] = {
12252 (char *) "self", NULL
12253 };
12254
12255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12257 if (SWIG_arg_fail(1)) SWIG_fail;
12258 {
12259 PyThreadState* __tstate = wxPyBeginAllowThreads();
12260 result = (int)(arg1)->GetPollingMin();
12261
12262 wxPyEndAllowThreads(__tstate);
12263 if (PyErr_Occurred()) SWIG_fail;
12264 }
12265 {
12266 resultobj = SWIG_From_int((int)(result));
12267 }
12268 return resultobj;
12269 fail:
12270 return NULL;
12271 }
12272
12273
12274 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12275 PyObject *resultobj;
12276 wxJoystick *arg1 = (wxJoystick *) 0 ;
12277 int result;
12278 PyObject * obj0 = 0 ;
12279 char *kwnames[] = {
12280 (char *) "self", NULL
12281 };
12282
12283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12285 if (SWIG_arg_fail(1)) SWIG_fail;
12286 {
12287 PyThreadState* __tstate = wxPyBeginAllowThreads();
12288 result = (int)(arg1)->GetPollingMax();
12289
12290 wxPyEndAllowThreads(__tstate);
12291 if (PyErr_Occurred()) SWIG_fail;
12292 }
12293 {
12294 resultobj = SWIG_From_int((int)(result));
12295 }
12296 return resultobj;
12297 fail:
12298 return NULL;
12299 }
12300
12301
12302 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12303 PyObject *resultobj;
12304 wxJoystick *arg1 = (wxJoystick *) 0 ;
12305 int result;
12306 PyObject * obj0 = 0 ;
12307 char *kwnames[] = {
12308 (char *) "self", NULL
12309 };
12310
12311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12313 if (SWIG_arg_fail(1)) SWIG_fail;
12314 {
12315 PyThreadState* __tstate = wxPyBeginAllowThreads();
12316 result = (int)(arg1)->GetRudderMin();
12317
12318 wxPyEndAllowThreads(__tstate);
12319 if (PyErr_Occurred()) SWIG_fail;
12320 }
12321 {
12322 resultobj = SWIG_From_int((int)(result));
12323 }
12324 return resultobj;
12325 fail:
12326 return NULL;
12327 }
12328
12329
12330 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12331 PyObject *resultobj;
12332 wxJoystick *arg1 = (wxJoystick *) 0 ;
12333 int result;
12334 PyObject * obj0 = 0 ;
12335 char *kwnames[] = {
12336 (char *) "self", NULL
12337 };
12338
12339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12341 if (SWIG_arg_fail(1)) SWIG_fail;
12342 {
12343 PyThreadState* __tstate = wxPyBeginAllowThreads();
12344 result = (int)(arg1)->GetRudderMax();
12345
12346 wxPyEndAllowThreads(__tstate);
12347 if (PyErr_Occurred()) SWIG_fail;
12348 }
12349 {
12350 resultobj = SWIG_From_int((int)(result));
12351 }
12352 return resultobj;
12353 fail:
12354 return NULL;
12355 }
12356
12357
12358 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12359 PyObject *resultobj;
12360 wxJoystick *arg1 = (wxJoystick *) 0 ;
12361 int result;
12362 PyObject * obj0 = 0 ;
12363 char *kwnames[] = {
12364 (char *) "self", NULL
12365 };
12366
12367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12369 if (SWIG_arg_fail(1)) SWIG_fail;
12370 {
12371 PyThreadState* __tstate = wxPyBeginAllowThreads();
12372 result = (int)(arg1)->GetUMin();
12373
12374 wxPyEndAllowThreads(__tstate);
12375 if (PyErr_Occurred()) SWIG_fail;
12376 }
12377 {
12378 resultobj = SWIG_From_int((int)(result));
12379 }
12380 return resultobj;
12381 fail:
12382 return NULL;
12383 }
12384
12385
12386 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12387 PyObject *resultobj;
12388 wxJoystick *arg1 = (wxJoystick *) 0 ;
12389 int result;
12390 PyObject * obj0 = 0 ;
12391 char *kwnames[] = {
12392 (char *) "self", NULL
12393 };
12394
12395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12397 if (SWIG_arg_fail(1)) SWIG_fail;
12398 {
12399 PyThreadState* __tstate = wxPyBeginAllowThreads();
12400 result = (int)(arg1)->GetUMax();
12401
12402 wxPyEndAllowThreads(__tstate);
12403 if (PyErr_Occurred()) SWIG_fail;
12404 }
12405 {
12406 resultobj = SWIG_From_int((int)(result));
12407 }
12408 return resultobj;
12409 fail:
12410 return NULL;
12411 }
12412
12413
12414 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj;
12416 wxJoystick *arg1 = (wxJoystick *) 0 ;
12417 int result;
12418 PyObject * obj0 = 0 ;
12419 char *kwnames[] = {
12420 (char *) "self", NULL
12421 };
12422
12423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12425 if (SWIG_arg_fail(1)) SWIG_fail;
12426 {
12427 PyThreadState* __tstate = wxPyBeginAllowThreads();
12428 result = (int)(arg1)->GetVMin();
12429
12430 wxPyEndAllowThreads(__tstate);
12431 if (PyErr_Occurred()) SWIG_fail;
12432 }
12433 {
12434 resultobj = SWIG_From_int((int)(result));
12435 }
12436 return resultobj;
12437 fail:
12438 return NULL;
12439 }
12440
12441
12442 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12443 PyObject *resultobj;
12444 wxJoystick *arg1 = (wxJoystick *) 0 ;
12445 int result;
12446 PyObject * obj0 = 0 ;
12447 char *kwnames[] = {
12448 (char *) "self", NULL
12449 };
12450
12451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12453 if (SWIG_arg_fail(1)) SWIG_fail;
12454 {
12455 PyThreadState* __tstate = wxPyBeginAllowThreads();
12456 result = (int)(arg1)->GetVMax();
12457
12458 wxPyEndAllowThreads(__tstate);
12459 if (PyErr_Occurred()) SWIG_fail;
12460 }
12461 {
12462 resultobj = SWIG_From_int((int)(result));
12463 }
12464 return resultobj;
12465 fail:
12466 return NULL;
12467 }
12468
12469
12470 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12471 PyObject *resultobj;
12472 wxJoystick *arg1 = (wxJoystick *) 0 ;
12473 bool result;
12474 PyObject * obj0 = 0 ;
12475 char *kwnames[] = {
12476 (char *) "self", NULL
12477 };
12478
12479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12481 if (SWIG_arg_fail(1)) SWIG_fail;
12482 {
12483 PyThreadState* __tstate = wxPyBeginAllowThreads();
12484 result = (bool)(arg1)->HasRudder();
12485
12486 wxPyEndAllowThreads(__tstate);
12487 if (PyErr_Occurred()) SWIG_fail;
12488 }
12489 {
12490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12491 }
12492 return resultobj;
12493 fail:
12494 return NULL;
12495 }
12496
12497
12498 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12499 PyObject *resultobj;
12500 wxJoystick *arg1 = (wxJoystick *) 0 ;
12501 bool result;
12502 PyObject * obj0 = 0 ;
12503 char *kwnames[] = {
12504 (char *) "self", NULL
12505 };
12506
12507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12509 if (SWIG_arg_fail(1)) SWIG_fail;
12510 {
12511 PyThreadState* __tstate = wxPyBeginAllowThreads();
12512 result = (bool)(arg1)->HasZ();
12513
12514 wxPyEndAllowThreads(__tstate);
12515 if (PyErr_Occurred()) SWIG_fail;
12516 }
12517 {
12518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12519 }
12520 return resultobj;
12521 fail:
12522 return NULL;
12523 }
12524
12525
12526 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12527 PyObject *resultobj;
12528 wxJoystick *arg1 = (wxJoystick *) 0 ;
12529 bool result;
12530 PyObject * obj0 = 0 ;
12531 char *kwnames[] = {
12532 (char *) "self", NULL
12533 };
12534
12535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12537 if (SWIG_arg_fail(1)) SWIG_fail;
12538 {
12539 PyThreadState* __tstate = wxPyBeginAllowThreads();
12540 result = (bool)(arg1)->HasU();
12541
12542 wxPyEndAllowThreads(__tstate);
12543 if (PyErr_Occurred()) SWIG_fail;
12544 }
12545 {
12546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12547 }
12548 return resultobj;
12549 fail:
12550 return NULL;
12551 }
12552
12553
12554 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12555 PyObject *resultobj;
12556 wxJoystick *arg1 = (wxJoystick *) 0 ;
12557 bool result;
12558 PyObject * obj0 = 0 ;
12559 char *kwnames[] = {
12560 (char *) "self", NULL
12561 };
12562
12563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12565 if (SWIG_arg_fail(1)) SWIG_fail;
12566 {
12567 PyThreadState* __tstate = wxPyBeginAllowThreads();
12568 result = (bool)(arg1)->HasV();
12569
12570 wxPyEndAllowThreads(__tstate);
12571 if (PyErr_Occurred()) SWIG_fail;
12572 }
12573 {
12574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12575 }
12576 return resultobj;
12577 fail:
12578 return NULL;
12579 }
12580
12581
12582 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12583 PyObject *resultobj;
12584 wxJoystick *arg1 = (wxJoystick *) 0 ;
12585 bool result;
12586 PyObject * obj0 = 0 ;
12587 char *kwnames[] = {
12588 (char *) "self", NULL
12589 };
12590
12591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12593 if (SWIG_arg_fail(1)) SWIG_fail;
12594 {
12595 PyThreadState* __tstate = wxPyBeginAllowThreads();
12596 result = (bool)(arg1)->HasPOV();
12597
12598 wxPyEndAllowThreads(__tstate);
12599 if (PyErr_Occurred()) SWIG_fail;
12600 }
12601 {
12602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12603 }
12604 return resultobj;
12605 fail:
12606 return NULL;
12607 }
12608
12609
12610 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12611 PyObject *resultobj;
12612 wxJoystick *arg1 = (wxJoystick *) 0 ;
12613 bool result;
12614 PyObject * obj0 = 0 ;
12615 char *kwnames[] = {
12616 (char *) "self", NULL
12617 };
12618
12619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12621 if (SWIG_arg_fail(1)) SWIG_fail;
12622 {
12623 PyThreadState* __tstate = wxPyBeginAllowThreads();
12624 result = (bool)(arg1)->HasPOV4Dir();
12625
12626 wxPyEndAllowThreads(__tstate);
12627 if (PyErr_Occurred()) SWIG_fail;
12628 }
12629 {
12630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12631 }
12632 return resultobj;
12633 fail:
12634 return NULL;
12635 }
12636
12637
12638 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12639 PyObject *resultobj;
12640 wxJoystick *arg1 = (wxJoystick *) 0 ;
12641 bool result;
12642 PyObject * obj0 = 0 ;
12643 char *kwnames[] = {
12644 (char *) "self", NULL
12645 };
12646
12647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12649 if (SWIG_arg_fail(1)) SWIG_fail;
12650 {
12651 PyThreadState* __tstate = wxPyBeginAllowThreads();
12652 result = (bool)(arg1)->HasPOVCTS();
12653
12654 wxPyEndAllowThreads(__tstate);
12655 if (PyErr_Occurred()) SWIG_fail;
12656 }
12657 {
12658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12659 }
12660 return resultobj;
12661 fail:
12662 return NULL;
12663 }
12664
12665
12666 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12667 PyObject *resultobj;
12668 wxJoystick *arg1 = (wxJoystick *) 0 ;
12669 wxWindow *arg2 = (wxWindow *) 0 ;
12670 int arg3 = (int) 0 ;
12671 bool result;
12672 PyObject * obj0 = 0 ;
12673 PyObject * obj1 = 0 ;
12674 PyObject * obj2 = 0 ;
12675 char *kwnames[] = {
12676 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12677 };
12678
12679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12681 if (SWIG_arg_fail(1)) SWIG_fail;
12682 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12683 if (SWIG_arg_fail(2)) SWIG_fail;
12684 if (obj2) {
12685 {
12686 arg3 = (int)(SWIG_As_int(obj2));
12687 if (SWIG_arg_fail(3)) SWIG_fail;
12688 }
12689 }
12690 {
12691 PyThreadState* __tstate = wxPyBeginAllowThreads();
12692 result = (bool)(arg1)->SetCapture(arg2,arg3);
12693
12694 wxPyEndAllowThreads(__tstate);
12695 if (PyErr_Occurred()) SWIG_fail;
12696 }
12697 {
12698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12699 }
12700 return resultobj;
12701 fail:
12702 return NULL;
12703 }
12704
12705
12706 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12707 PyObject *resultobj;
12708 wxJoystick *arg1 = (wxJoystick *) 0 ;
12709 bool result;
12710 PyObject * obj0 = 0 ;
12711 char *kwnames[] = {
12712 (char *) "self", NULL
12713 };
12714
12715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12717 if (SWIG_arg_fail(1)) SWIG_fail;
12718 {
12719 PyThreadState* __tstate = wxPyBeginAllowThreads();
12720 result = (bool)(arg1)->ReleaseCapture();
12721
12722 wxPyEndAllowThreads(__tstate);
12723 if (PyErr_Occurred()) SWIG_fail;
12724 }
12725 {
12726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12727 }
12728 return resultobj;
12729 fail:
12730 return NULL;
12731 }
12732
12733
12734 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12735 PyObject *obj;
12736 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12737 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12738 Py_INCREF(obj);
12739 return Py_BuildValue((char *)"");
12740 }
12741 static PyObject *_wrap_JoystickEvent_m_pos_set(PyObject *, PyObject *args, PyObject *kwargs) {
12742 PyObject *resultobj;
12743 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12744 wxPoint *arg2 = (wxPoint *) 0 ;
12745 PyObject * obj0 = 0 ;
12746 PyObject * obj1 = 0 ;
12747 char *kwnames[] = {
12748 (char *) "self",(char *) "m_pos", NULL
12749 };
12750
12751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_pos_set",kwnames,&obj0,&obj1)) goto fail;
12752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12753 if (SWIG_arg_fail(1)) SWIG_fail;
12754 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12755 if (SWIG_arg_fail(2)) SWIG_fail;
12756 if (arg1) (arg1)->m_pos = *arg2;
12757
12758 Py_INCREF(Py_None); resultobj = Py_None;
12759 return resultobj;
12760 fail:
12761 return NULL;
12762 }
12763
12764
12765 static PyObject *_wrap_JoystickEvent_m_pos_get(PyObject *, PyObject *args, PyObject *kwargs) {
12766 PyObject *resultobj;
12767 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12768 wxPoint *result;
12769 PyObject * obj0 = 0 ;
12770 char *kwnames[] = {
12771 (char *) "self", NULL
12772 };
12773
12774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_pos_get",kwnames,&obj0)) goto fail;
12775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12776 if (SWIG_arg_fail(1)) SWIG_fail;
12777 result = (wxPoint *)& ((arg1)->m_pos);
12778
12779 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
12780 return resultobj;
12781 fail:
12782 return NULL;
12783 }
12784
12785
12786 static PyObject *_wrap_JoystickEvent_m_zPosition_set(PyObject *, PyObject *args, PyObject *kwargs) {
12787 PyObject *resultobj;
12788 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12789 int arg2 ;
12790 PyObject * obj0 = 0 ;
12791 PyObject * obj1 = 0 ;
12792 char *kwnames[] = {
12793 (char *) "self",(char *) "m_zPosition", NULL
12794 };
12795
12796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_zPosition_set",kwnames,&obj0,&obj1)) goto fail;
12797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12798 if (SWIG_arg_fail(1)) SWIG_fail;
12799 {
12800 arg2 = (int)(SWIG_As_int(obj1));
12801 if (SWIG_arg_fail(2)) SWIG_fail;
12802 }
12803 if (arg1) (arg1)->m_zPosition = arg2;
12804
12805 Py_INCREF(Py_None); resultobj = Py_None;
12806 return resultobj;
12807 fail:
12808 return NULL;
12809 }
12810
12811
12812 static PyObject *_wrap_JoystickEvent_m_zPosition_get(PyObject *, PyObject *args, PyObject *kwargs) {
12813 PyObject *resultobj;
12814 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12815 int result;
12816 PyObject * obj0 = 0 ;
12817 char *kwnames[] = {
12818 (char *) "self", NULL
12819 };
12820
12821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_zPosition_get",kwnames,&obj0)) goto fail;
12822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12823 if (SWIG_arg_fail(1)) SWIG_fail;
12824 result = (int) ((arg1)->m_zPosition);
12825
12826 {
12827 resultobj = SWIG_From_int((int)(result));
12828 }
12829 return resultobj;
12830 fail:
12831 return NULL;
12832 }
12833
12834
12835 static PyObject *_wrap_JoystickEvent_m_buttonChange_set(PyObject *, PyObject *args, PyObject *kwargs) {
12836 PyObject *resultobj;
12837 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12838 int arg2 ;
12839 PyObject * obj0 = 0 ;
12840 PyObject * obj1 = 0 ;
12841 char *kwnames[] = {
12842 (char *) "self",(char *) "m_buttonChange", NULL
12843 };
12844
12845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_buttonChange_set",kwnames,&obj0,&obj1)) goto fail;
12846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12847 if (SWIG_arg_fail(1)) SWIG_fail;
12848 {
12849 arg2 = (int)(SWIG_As_int(obj1));
12850 if (SWIG_arg_fail(2)) SWIG_fail;
12851 }
12852 if (arg1) (arg1)->m_buttonChange = arg2;
12853
12854 Py_INCREF(Py_None); resultobj = Py_None;
12855 return resultobj;
12856 fail:
12857 return NULL;
12858 }
12859
12860
12861 static PyObject *_wrap_JoystickEvent_m_buttonChange_get(PyObject *, PyObject *args, PyObject *kwargs) {
12862 PyObject *resultobj;
12863 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12864 int result;
12865 PyObject * obj0 = 0 ;
12866 char *kwnames[] = {
12867 (char *) "self", NULL
12868 };
12869
12870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_buttonChange_get",kwnames,&obj0)) goto fail;
12871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12872 if (SWIG_arg_fail(1)) SWIG_fail;
12873 result = (int) ((arg1)->m_buttonChange);
12874
12875 {
12876 resultobj = SWIG_From_int((int)(result));
12877 }
12878 return resultobj;
12879 fail:
12880 return NULL;
12881 }
12882
12883
12884 static PyObject *_wrap_JoystickEvent_m_buttonState_set(PyObject *, PyObject *args, PyObject *kwargs) {
12885 PyObject *resultobj;
12886 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12887 int arg2 ;
12888 PyObject * obj0 = 0 ;
12889 PyObject * obj1 = 0 ;
12890 char *kwnames[] = {
12891 (char *) "self",(char *) "m_buttonState", NULL
12892 };
12893
12894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_buttonState_set",kwnames,&obj0,&obj1)) goto fail;
12895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12896 if (SWIG_arg_fail(1)) SWIG_fail;
12897 {
12898 arg2 = (int)(SWIG_As_int(obj1));
12899 if (SWIG_arg_fail(2)) SWIG_fail;
12900 }
12901 if (arg1) (arg1)->m_buttonState = arg2;
12902
12903 Py_INCREF(Py_None); resultobj = Py_None;
12904 return resultobj;
12905 fail:
12906 return NULL;
12907 }
12908
12909
12910 static PyObject *_wrap_JoystickEvent_m_buttonState_get(PyObject *, PyObject *args, PyObject *kwargs) {
12911 PyObject *resultobj;
12912 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12913 int result;
12914 PyObject * obj0 = 0 ;
12915 char *kwnames[] = {
12916 (char *) "self", NULL
12917 };
12918
12919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_buttonState_get",kwnames,&obj0)) goto fail;
12920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12921 if (SWIG_arg_fail(1)) SWIG_fail;
12922 result = (int) ((arg1)->m_buttonState);
12923
12924 {
12925 resultobj = SWIG_From_int((int)(result));
12926 }
12927 return resultobj;
12928 fail:
12929 return NULL;
12930 }
12931
12932
12933 static PyObject *_wrap_JoystickEvent_m_joyStick_set(PyObject *, PyObject *args, PyObject *kwargs) {
12934 PyObject *resultobj;
12935 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12936 int arg2 ;
12937 PyObject * obj0 = 0 ;
12938 PyObject * obj1 = 0 ;
12939 char *kwnames[] = {
12940 (char *) "self",(char *) "m_joyStick", NULL
12941 };
12942
12943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_joyStick_set",kwnames,&obj0,&obj1)) goto fail;
12944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12945 if (SWIG_arg_fail(1)) SWIG_fail;
12946 {
12947 arg2 = (int)(SWIG_As_int(obj1));
12948 if (SWIG_arg_fail(2)) SWIG_fail;
12949 }
12950 if (arg1) (arg1)->m_joyStick = arg2;
12951
12952 Py_INCREF(Py_None); resultobj = Py_None;
12953 return resultobj;
12954 fail:
12955 return NULL;
12956 }
12957
12958
12959 static PyObject *_wrap_JoystickEvent_m_joyStick_get(PyObject *, PyObject *args, PyObject *kwargs) {
12960 PyObject *resultobj;
12961 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12962 int result;
12963 PyObject * obj0 = 0 ;
12964 char *kwnames[] = {
12965 (char *) "self", NULL
12966 };
12967
12968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_joyStick_get",kwnames,&obj0)) goto fail;
12969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12970 if (SWIG_arg_fail(1)) SWIG_fail;
12971 result = (int) ((arg1)->m_joyStick);
12972
12973 {
12974 resultobj = SWIG_From_int((int)(result));
12975 }
12976 return resultobj;
12977 fail:
12978 return NULL;
12979 }
12980
12981
12982 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12983 PyObject *resultobj;
12984 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12985 int arg2 = (int) 0 ;
12986 int arg3 = (int) wxJOYSTICK1 ;
12987 int arg4 = (int) 0 ;
12988 wxJoystickEvent *result;
12989 PyObject * obj0 = 0 ;
12990 PyObject * obj1 = 0 ;
12991 PyObject * obj2 = 0 ;
12992 PyObject * obj3 = 0 ;
12993 char *kwnames[] = {
12994 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12995 };
12996
12997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12998 if (obj0) {
12999 {
13000 arg1 = (wxEventType)(SWIG_As_int(obj0));
13001 if (SWIG_arg_fail(1)) SWIG_fail;
13002 }
13003 }
13004 if (obj1) {
13005 {
13006 arg2 = (int)(SWIG_As_int(obj1));
13007 if (SWIG_arg_fail(2)) SWIG_fail;
13008 }
13009 }
13010 if (obj2) {
13011 {
13012 arg3 = (int)(SWIG_As_int(obj2));
13013 if (SWIG_arg_fail(3)) SWIG_fail;
13014 }
13015 }
13016 if (obj3) {
13017 {
13018 arg4 = (int)(SWIG_As_int(obj3));
13019 if (SWIG_arg_fail(4)) SWIG_fail;
13020 }
13021 }
13022 {
13023 PyThreadState* __tstate = wxPyBeginAllowThreads();
13024 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
13025
13026 wxPyEndAllowThreads(__tstate);
13027 if (PyErr_Occurred()) SWIG_fail;
13028 }
13029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
13030 return resultobj;
13031 fail:
13032 return NULL;
13033 }
13034
13035
13036 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13037 PyObject *resultobj;
13038 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13039 wxPoint result;
13040 PyObject * obj0 = 0 ;
13041 char *kwnames[] = {
13042 (char *) "self", NULL
13043 };
13044
13045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
13046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13047 if (SWIG_arg_fail(1)) SWIG_fail;
13048 {
13049 PyThreadState* __tstate = wxPyBeginAllowThreads();
13050 result = ((wxJoystickEvent const *)arg1)->GetPosition();
13051
13052 wxPyEndAllowThreads(__tstate);
13053 if (PyErr_Occurred()) SWIG_fail;
13054 }
13055 {
13056 wxPoint * resultptr;
13057 resultptr = new wxPoint((wxPoint &)(result));
13058 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
13059 }
13060 return resultobj;
13061 fail:
13062 return NULL;
13063 }
13064
13065
13066 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13067 PyObject *resultobj;
13068 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13069 int result;
13070 PyObject * obj0 = 0 ;
13071 char *kwnames[] = {
13072 (char *) "self", NULL
13073 };
13074
13075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
13076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13077 if (SWIG_arg_fail(1)) SWIG_fail;
13078 {
13079 PyThreadState* __tstate = wxPyBeginAllowThreads();
13080 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
13081
13082 wxPyEndAllowThreads(__tstate);
13083 if (PyErr_Occurred()) SWIG_fail;
13084 }
13085 {
13086 resultobj = SWIG_From_int((int)(result));
13087 }
13088 return resultobj;
13089 fail:
13090 return NULL;
13091 }
13092
13093
13094 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13095 PyObject *resultobj;
13096 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13097 int result;
13098 PyObject * obj0 = 0 ;
13099 char *kwnames[] = {
13100 (char *) "self", NULL
13101 };
13102
13103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
13104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13105 if (SWIG_arg_fail(1)) SWIG_fail;
13106 {
13107 PyThreadState* __tstate = wxPyBeginAllowThreads();
13108 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13109
13110 wxPyEndAllowThreads(__tstate);
13111 if (PyErr_Occurred()) SWIG_fail;
13112 }
13113 {
13114 resultobj = SWIG_From_int((int)(result));
13115 }
13116 return resultobj;
13117 fail:
13118 return NULL;
13119 }
13120
13121
13122 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13123 PyObject *resultobj;
13124 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13125 int result;
13126 PyObject * obj0 = 0 ;
13127 char *kwnames[] = {
13128 (char *) "self", NULL
13129 };
13130
13131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13133 if (SWIG_arg_fail(1)) SWIG_fail;
13134 {
13135 PyThreadState* __tstate = wxPyBeginAllowThreads();
13136 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13137
13138 wxPyEndAllowThreads(__tstate);
13139 if (PyErr_Occurred()) SWIG_fail;
13140 }
13141 {
13142 resultobj = SWIG_From_int((int)(result));
13143 }
13144 return resultobj;
13145 fail:
13146 return NULL;
13147 }
13148
13149
13150 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13151 PyObject *resultobj;
13152 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13153 int result;
13154 PyObject * obj0 = 0 ;
13155 char *kwnames[] = {
13156 (char *) "self", NULL
13157 };
13158
13159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13161 if (SWIG_arg_fail(1)) SWIG_fail;
13162 {
13163 PyThreadState* __tstate = wxPyBeginAllowThreads();
13164 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13165
13166 wxPyEndAllowThreads(__tstate);
13167 if (PyErr_Occurred()) SWIG_fail;
13168 }
13169 {
13170 resultobj = SWIG_From_int((int)(result));
13171 }
13172 return resultobj;
13173 fail:
13174 return NULL;
13175 }
13176
13177
13178 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13179 PyObject *resultobj;
13180 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13181 int arg2 ;
13182 PyObject * obj0 = 0 ;
13183 PyObject * obj1 = 0 ;
13184 char *kwnames[] = {
13185 (char *) "self",(char *) "stick", NULL
13186 };
13187
13188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13190 if (SWIG_arg_fail(1)) SWIG_fail;
13191 {
13192 arg2 = (int)(SWIG_As_int(obj1));
13193 if (SWIG_arg_fail(2)) SWIG_fail;
13194 }
13195 {
13196 PyThreadState* __tstate = wxPyBeginAllowThreads();
13197 (arg1)->SetJoystick(arg2);
13198
13199 wxPyEndAllowThreads(__tstate);
13200 if (PyErr_Occurred()) SWIG_fail;
13201 }
13202 Py_INCREF(Py_None); resultobj = Py_None;
13203 return resultobj;
13204 fail:
13205 return NULL;
13206 }
13207
13208
13209 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13210 PyObject *resultobj;
13211 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13212 int arg2 ;
13213 PyObject * obj0 = 0 ;
13214 PyObject * obj1 = 0 ;
13215 char *kwnames[] = {
13216 (char *) "self",(char *) "state", NULL
13217 };
13218
13219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13221 if (SWIG_arg_fail(1)) SWIG_fail;
13222 {
13223 arg2 = (int)(SWIG_As_int(obj1));
13224 if (SWIG_arg_fail(2)) SWIG_fail;
13225 }
13226 {
13227 PyThreadState* __tstate = wxPyBeginAllowThreads();
13228 (arg1)->SetButtonState(arg2);
13229
13230 wxPyEndAllowThreads(__tstate);
13231 if (PyErr_Occurred()) SWIG_fail;
13232 }
13233 Py_INCREF(Py_None); resultobj = Py_None;
13234 return resultobj;
13235 fail:
13236 return NULL;
13237 }
13238
13239
13240 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13241 PyObject *resultobj;
13242 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13243 int arg2 ;
13244 PyObject * obj0 = 0 ;
13245 PyObject * obj1 = 0 ;
13246 char *kwnames[] = {
13247 (char *) "self",(char *) "change", NULL
13248 };
13249
13250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13252 if (SWIG_arg_fail(1)) SWIG_fail;
13253 {
13254 arg2 = (int)(SWIG_As_int(obj1));
13255 if (SWIG_arg_fail(2)) SWIG_fail;
13256 }
13257 {
13258 PyThreadState* __tstate = wxPyBeginAllowThreads();
13259 (arg1)->SetButtonChange(arg2);
13260
13261 wxPyEndAllowThreads(__tstate);
13262 if (PyErr_Occurred()) SWIG_fail;
13263 }
13264 Py_INCREF(Py_None); resultobj = Py_None;
13265 return resultobj;
13266 fail:
13267 return NULL;
13268 }
13269
13270
13271 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13272 PyObject *resultobj;
13273 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13274 wxPoint *arg2 = 0 ;
13275 wxPoint temp2 ;
13276 PyObject * obj0 = 0 ;
13277 PyObject * obj1 = 0 ;
13278 char *kwnames[] = {
13279 (char *) "self",(char *) "pos", NULL
13280 };
13281
13282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13284 if (SWIG_arg_fail(1)) SWIG_fail;
13285 {
13286 arg2 = &temp2;
13287 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13288 }
13289 {
13290 PyThreadState* __tstate = wxPyBeginAllowThreads();
13291 (arg1)->SetPosition((wxPoint const &)*arg2);
13292
13293 wxPyEndAllowThreads(__tstate);
13294 if (PyErr_Occurred()) SWIG_fail;
13295 }
13296 Py_INCREF(Py_None); resultobj = Py_None;
13297 return resultobj;
13298 fail:
13299 return NULL;
13300 }
13301
13302
13303 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13304 PyObject *resultobj;
13305 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13306 int arg2 ;
13307 PyObject * obj0 = 0 ;
13308 PyObject * obj1 = 0 ;
13309 char *kwnames[] = {
13310 (char *) "self",(char *) "zPos", NULL
13311 };
13312
13313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13315 if (SWIG_arg_fail(1)) SWIG_fail;
13316 {
13317 arg2 = (int)(SWIG_As_int(obj1));
13318 if (SWIG_arg_fail(2)) SWIG_fail;
13319 }
13320 {
13321 PyThreadState* __tstate = wxPyBeginAllowThreads();
13322 (arg1)->SetZPosition(arg2);
13323
13324 wxPyEndAllowThreads(__tstate);
13325 if (PyErr_Occurred()) SWIG_fail;
13326 }
13327 Py_INCREF(Py_None); resultobj = Py_None;
13328 return resultobj;
13329 fail:
13330 return NULL;
13331 }
13332
13333
13334 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13335 PyObject *resultobj;
13336 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13337 bool result;
13338 PyObject * obj0 = 0 ;
13339 char *kwnames[] = {
13340 (char *) "self", NULL
13341 };
13342
13343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13345 if (SWIG_arg_fail(1)) SWIG_fail;
13346 {
13347 PyThreadState* __tstate = wxPyBeginAllowThreads();
13348 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13349
13350 wxPyEndAllowThreads(__tstate);
13351 if (PyErr_Occurred()) SWIG_fail;
13352 }
13353 {
13354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13355 }
13356 return resultobj;
13357 fail:
13358 return NULL;
13359 }
13360
13361
13362 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13363 PyObject *resultobj;
13364 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13365 bool result;
13366 PyObject * obj0 = 0 ;
13367 char *kwnames[] = {
13368 (char *) "self", NULL
13369 };
13370
13371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13373 if (SWIG_arg_fail(1)) SWIG_fail;
13374 {
13375 PyThreadState* __tstate = wxPyBeginAllowThreads();
13376 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13377
13378 wxPyEndAllowThreads(__tstate);
13379 if (PyErr_Occurred()) SWIG_fail;
13380 }
13381 {
13382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13383 }
13384 return resultobj;
13385 fail:
13386 return NULL;
13387 }
13388
13389
13390 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13391 PyObject *resultobj;
13392 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13393 bool result;
13394 PyObject * obj0 = 0 ;
13395 char *kwnames[] = {
13396 (char *) "self", NULL
13397 };
13398
13399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13401 if (SWIG_arg_fail(1)) SWIG_fail;
13402 {
13403 PyThreadState* __tstate = wxPyBeginAllowThreads();
13404 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13405
13406 wxPyEndAllowThreads(__tstate);
13407 if (PyErr_Occurred()) SWIG_fail;
13408 }
13409 {
13410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13411 }
13412 return resultobj;
13413 fail:
13414 return NULL;
13415 }
13416
13417
13418 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13419 PyObject *resultobj;
13420 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13421 int arg2 = (int) wxJOY_BUTTON_ANY ;
13422 bool result;
13423 PyObject * obj0 = 0 ;
13424 PyObject * obj1 = 0 ;
13425 char *kwnames[] = {
13426 (char *) "self",(char *) "but", NULL
13427 };
13428
13429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13431 if (SWIG_arg_fail(1)) SWIG_fail;
13432 if (obj1) {
13433 {
13434 arg2 = (int)(SWIG_As_int(obj1));
13435 if (SWIG_arg_fail(2)) SWIG_fail;
13436 }
13437 }
13438 {
13439 PyThreadState* __tstate = wxPyBeginAllowThreads();
13440 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13441
13442 wxPyEndAllowThreads(__tstate);
13443 if (PyErr_Occurred()) SWIG_fail;
13444 }
13445 {
13446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13447 }
13448 return resultobj;
13449 fail:
13450 return NULL;
13451 }
13452
13453
13454 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13455 PyObject *resultobj;
13456 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13457 int arg2 = (int) wxJOY_BUTTON_ANY ;
13458 bool result;
13459 PyObject * obj0 = 0 ;
13460 PyObject * obj1 = 0 ;
13461 char *kwnames[] = {
13462 (char *) "self",(char *) "but", NULL
13463 };
13464
13465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13467 if (SWIG_arg_fail(1)) SWIG_fail;
13468 if (obj1) {
13469 {
13470 arg2 = (int)(SWIG_As_int(obj1));
13471 if (SWIG_arg_fail(2)) SWIG_fail;
13472 }
13473 }
13474 {
13475 PyThreadState* __tstate = wxPyBeginAllowThreads();
13476 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13477
13478 wxPyEndAllowThreads(__tstate);
13479 if (PyErr_Occurred()) SWIG_fail;
13480 }
13481 {
13482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13483 }
13484 return resultobj;
13485 fail:
13486 return NULL;
13487 }
13488
13489
13490 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13491 PyObject *resultobj;
13492 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13493 int arg2 = (int) wxJOY_BUTTON_ANY ;
13494 bool result;
13495 PyObject * obj0 = 0 ;
13496 PyObject * obj1 = 0 ;
13497 char *kwnames[] = {
13498 (char *) "self",(char *) "but", NULL
13499 };
13500
13501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13503 if (SWIG_arg_fail(1)) SWIG_fail;
13504 if (obj1) {
13505 {
13506 arg2 = (int)(SWIG_As_int(obj1));
13507 if (SWIG_arg_fail(2)) SWIG_fail;
13508 }
13509 }
13510 {
13511 PyThreadState* __tstate = wxPyBeginAllowThreads();
13512 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13513
13514 wxPyEndAllowThreads(__tstate);
13515 if (PyErr_Occurred()) SWIG_fail;
13516 }
13517 {
13518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13519 }
13520 return resultobj;
13521 fail:
13522 return NULL;
13523 }
13524
13525
13526 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13527 PyObject *obj;
13528 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13529 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13530 Py_INCREF(obj);
13531 return Py_BuildValue((char *)"");
13532 }
13533 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13534 PyObject *resultobj;
13535 wxString const &arg1_defvalue = wxPyEmptyString ;
13536 wxString *arg1 = (wxString *) &arg1_defvalue ;
13537 wxSound *result;
13538 bool temp1 = false ;
13539 PyObject * obj0 = 0 ;
13540 char *kwnames[] = {
13541 (char *) "fileName", NULL
13542 };
13543
13544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13545 if (obj0) {
13546 {
13547 arg1 = wxString_in_helper(obj0);
13548 if (arg1 == NULL) SWIG_fail;
13549 temp1 = true;
13550 }
13551 }
13552 {
13553 if (!wxPyCheckForApp()) SWIG_fail;
13554 PyThreadState* __tstate = wxPyBeginAllowThreads();
13555 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13556
13557 wxPyEndAllowThreads(__tstate);
13558 if (PyErr_Occurred()) SWIG_fail;
13559 }
13560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13561 {
13562 if (temp1)
13563 delete arg1;
13564 }
13565 return resultobj;
13566 fail:
13567 {
13568 if (temp1)
13569 delete arg1;
13570 }
13571 return NULL;
13572 }
13573
13574
13575 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13576 PyObject *resultobj;
13577 PyObject *arg1 = (PyObject *) 0 ;
13578 wxSound *result;
13579 PyObject * obj0 = 0 ;
13580 char *kwnames[] = {
13581 (char *) "data", NULL
13582 };
13583
13584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13585 arg1 = obj0;
13586 {
13587 if (!wxPyCheckForApp()) SWIG_fail;
13588 PyThreadState* __tstate = wxPyBeginAllowThreads();
13589 result = (wxSound *)new_wxSound(arg1);
13590
13591 wxPyEndAllowThreads(__tstate);
13592 if (PyErr_Occurred()) SWIG_fail;
13593 }
13594 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13595 return resultobj;
13596 fail:
13597 return NULL;
13598 }
13599
13600
13601 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13602 PyObject *resultobj;
13603 wxSound *arg1 = (wxSound *) 0 ;
13604 PyObject * obj0 = 0 ;
13605 char *kwnames[] = {
13606 (char *) "self", NULL
13607 };
13608
13609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13611 if (SWIG_arg_fail(1)) SWIG_fail;
13612 {
13613 PyThreadState* __tstate = wxPyBeginAllowThreads();
13614 delete arg1;
13615
13616 wxPyEndAllowThreads(__tstate);
13617 if (PyErr_Occurred()) SWIG_fail;
13618 }
13619 Py_INCREF(Py_None); resultobj = Py_None;
13620 return resultobj;
13621 fail:
13622 return NULL;
13623 }
13624
13625
13626 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13627 PyObject *resultobj;
13628 wxSound *arg1 = (wxSound *) 0 ;
13629 wxString *arg2 = 0 ;
13630 bool result;
13631 bool temp2 = false ;
13632 PyObject * obj0 = 0 ;
13633 PyObject * obj1 = 0 ;
13634 char *kwnames[] = {
13635 (char *) "self",(char *) "fileName", NULL
13636 };
13637
13638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13640 if (SWIG_arg_fail(1)) SWIG_fail;
13641 {
13642 arg2 = wxString_in_helper(obj1);
13643 if (arg2 == NULL) SWIG_fail;
13644 temp2 = true;
13645 }
13646 {
13647 PyThreadState* __tstate = wxPyBeginAllowThreads();
13648 result = (bool)(arg1)->Create((wxString const &)*arg2);
13649
13650 wxPyEndAllowThreads(__tstate);
13651 if (PyErr_Occurred()) SWIG_fail;
13652 }
13653 {
13654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13655 }
13656 {
13657 if (temp2)
13658 delete arg2;
13659 }
13660 return resultobj;
13661 fail:
13662 {
13663 if (temp2)
13664 delete arg2;
13665 }
13666 return NULL;
13667 }
13668
13669
13670 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13671 PyObject *resultobj;
13672 wxSound *arg1 = (wxSound *) 0 ;
13673 PyObject *arg2 = (PyObject *) 0 ;
13674 bool result;
13675 PyObject * obj0 = 0 ;
13676 PyObject * obj1 = 0 ;
13677 char *kwnames[] = {
13678 (char *) "self",(char *) "data", NULL
13679 };
13680
13681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13683 if (SWIG_arg_fail(1)) SWIG_fail;
13684 arg2 = obj1;
13685 {
13686 PyThreadState* __tstate = wxPyBeginAllowThreads();
13687 result = (bool)wxSound_CreateFromData(arg1,arg2);
13688
13689 wxPyEndAllowThreads(__tstate);
13690 if (PyErr_Occurred()) SWIG_fail;
13691 }
13692 {
13693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13694 }
13695 return resultobj;
13696 fail:
13697 return NULL;
13698 }
13699
13700
13701 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13702 PyObject *resultobj;
13703 wxSound *arg1 = (wxSound *) 0 ;
13704 bool result;
13705 PyObject * obj0 = 0 ;
13706 char *kwnames[] = {
13707 (char *) "self", NULL
13708 };
13709
13710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13712 if (SWIG_arg_fail(1)) SWIG_fail;
13713 {
13714 PyThreadState* __tstate = wxPyBeginAllowThreads();
13715 result = (bool)(arg1)->IsOk();
13716
13717 wxPyEndAllowThreads(__tstate);
13718 if (PyErr_Occurred()) SWIG_fail;
13719 }
13720 {
13721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13722 }
13723 return resultobj;
13724 fail:
13725 return NULL;
13726 }
13727
13728
13729 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13730 PyObject *resultobj;
13731 wxSound *arg1 = (wxSound *) 0 ;
13732 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13733 bool result;
13734 PyObject * obj0 = 0 ;
13735 PyObject * obj1 = 0 ;
13736 char *kwnames[] = {
13737 (char *) "self",(char *) "flags", NULL
13738 };
13739
13740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13742 if (SWIG_arg_fail(1)) SWIG_fail;
13743 if (obj1) {
13744 {
13745 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13746 if (SWIG_arg_fail(2)) SWIG_fail;
13747 }
13748 }
13749 {
13750 if (!wxPyCheckForApp()) SWIG_fail;
13751 PyThreadState* __tstate = wxPyBeginAllowThreads();
13752 result = (bool)((wxSound const *)arg1)->Play(arg2);
13753
13754 wxPyEndAllowThreads(__tstate);
13755 if (PyErr_Occurred()) SWIG_fail;
13756 }
13757 {
13758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13759 }
13760 return resultobj;
13761 fail:
13762 return NULL;
13763 }
13764
13765
13766 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13767 PyObject *resultobj;
13768 wxString *arg1 = 0 ;
13769 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13770 bool result;
13771 bool temp1 = false ;
13772 PyObject * obj0 = 0 ;
13773 PyObject * obj1 = 0 ;
13774 char *kwnames[] = {
13775 (char *) "filename",(char *) "flags", NULL
13776 };
13777
13778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13779 {
13780 arg1 = wxString_in_helper(obj0);
13781 if (arg1 == NULL) SWIG_fail;
13782 temp1 = true;
13783 }
13784 if (obj1) {
13785 {
13786 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13787 if (SWIG_arg_fail(2)) SWIG_fail;
13788 }
13789 }
13790 {
13791 if (!wxPyCheckForApp()) SWIG_fail;
13792 PyThreadState* __tstate = wxPyBeginAllowThreads();
13793 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13794
13795 wxPyEndAllowThreads(__tstate);
13796 if (PyErr_Occurred()) SWIG_fail;
13797 }
13798 {
13799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13800 }
13801 {
13802 if (temp1)
13803 delete arg1;
13804 }
13805 return resultobj;
13806 fail:
13807 {
13808 if (temp1)
13809 delete arg1;
13810 }
13811 return NULL;
13812 }
13813
13814
13815 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13816 PyObject *resultobj;
13817 char *kwnames[] = {
13818 NULL
13819 };
13820
13821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13822 {
13823 if (!wxPyCheckForApp()) SWIG_fail;
13824 PyThreadState* __tstate = wxPyBeginAllowThreads();
13825 wxSound::Stop();
13826
13827 wxPyEndAllowThreads(__tstate);
13828 if (PyErr_Occurred()) SWIG_fail;
13829 }
13830 Py_INCREF(Py_None); resultobj = Py_None;
13831 return resultobj;
13832 fail:
13833 return NULL;
13834 }
13835
13836
13837 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13838 PyObject *obj;
13839 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13840 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13841 Py_INCREF(obj);
13842 return Py_BuildValue((char *)"");
13843 }
13844 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13845 PyObject *resultobj;
13846 wxString *arg1 = 0 ;
13847 wxString *arg2 = 0 ;
13848 wxString *arg3 = 0 ;
13849 wxString *arg4 = 0 ;
13850 wxFileTypeInfo *result;
13851 bool temp1 = false ;
13852 bool temp2 = false ;
13853 bool temp3 = false ;
13854 bool temp4 = false ;
13855 PyObject * obj0 = 0 ;
13856 PyObject * obj1 = 0 ;
13857 PyObject * obj2 = 0 ;
13858 PyObject * obj3 = 0 ;
13859 char *kwnames[] = {
13860 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13861 };
13862
13863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13864 {
13865 arg1 = wxString_in_helper(obj0);
13866 if (arg1 == NULL) SWIG_fail;
13867 temp1 = true;
13868 }
13869 {
13870 arg2 = wxString_in_helper(obj1);
13871 if (arg2 == NULL) SWIG_fail;
13872 temp2 = true;
13873 }
13874 {
13875 arg3 = wxString_in_helper(obj2);
13876 if (arg3 == NULL) SWIG_fail;
13877 temp3 = true;
13878 }
13879 {
13880 arg4 = wxString_in_helper(obj3);
13881 if (arg4 == NULL) SWIG_fail;
13882 temp4 = true;
13883 }
13884 {
13885 PyThreadState* __tstate = wxPyBeginAllowThreads();
13886 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13887
13888 wxPyEndAllowThreads(__tstate);
13889 if (PyErr_Occurred()) SWIG_fail;
13890 }
13891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13892 {
13893 if (temp1)
13894 delete arg1;
13895 }
13896 {
13897 if (temp2)
13898 delete arg2;
13899 }
13900 {
13901 if (temp3)
13902 delete arg3;
13903 }
13904 {
13905 if (temp4)
13906 delete arg4;
13907 }
13908 return resultobj;
13909 fail:
13910 {
13911 if (temp1)
13912 delete arg1;
13913 }
13914 {
13915 if (temp2)
13916 delete arg2;
13917 }
13918 {
13919 if (temp3)
13920 delete arg3;
13921 }
13922 {
13923 if (temp4)
13924 delete arg4;
13925 }
13926 return NULL;
13927 }
13928
13929
13930 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13931 PyObject *resultobj;
13932 wxArrayString *arg1 = 0 ;
13933 wxFileTypeInfo *result;
13934 bool temp1 = false ;
13935 PyObject * obj0 = 0 ;
13936 char *kwnames[] = {
13937 (char *) "sArray", NULL
13938 };
13939
13940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13941 {
13942 if (! PySequence_Check(obj0)) {
13943 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13944 SWIG_fail;
13945 }
13946 arg1 = new wxArrayString;
13947 temp1 = true;
13948 int i, len=PySequence_Length(obj0);
13949 for (i=0; i<len; i++) {
13950 PyObject* item = PySequence_GetItem(obj0, i);
13951 #if wxUSE_UNICODE
13952 PyObject* str = PyObject_Unicode(item);
13953 #else
13954 PyObject* str = PyObject_Str(item);
13955 #endif
13956 if (PyErr_Occurred()) SWIG_fail;
13957 arg1->Add(Py2wxString(str));
13958 Py_DECREF(item);
13959 Py_DECREF(str);
13960 }
13961 }
13962 {
13963 PyThreadState* __tstate = wxPyBeginAllowThreads();
13964 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13965
13966 wxPyEndAllowThreads(__tstate);
13967 if (PyErr_Occurred()) SWIG_fail;
13968 }
13969 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13970 {
13971 if (temp1) delete arg1;
13972 }
13973 return resultobj;
13974 fail:
13975 {
13976 if (temp1) delete arg1;
13977 }
13978 return NULL;
13979 }
13980
13981
13982 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13983 PyObject *resultobj;
13984 wxFileTypeInfo *result;
13985 char *kwnames[] = {
13986 NULL
13987 };
13988
13989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13990 {
13991 PyThreadState* __tstate = wxPyBeginAllowThreads();
13992 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13993
13994 wxPyEndAllowThreads(__tstate);
13995 if (PyErr_Occurred()) SWIG_fail;
13996 }
13997 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13998 return resultobj;
13999 fail:
14000 return NULL;
14001 }
14002
14003
14004 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
14005 PyObject *resultobj;
14006 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14007 bool result;
14008 PyObject * obj0 = 0 ;
14009 char *kwnames[] = {
14010 (char *) "self", NULL
14011 };
14012
14013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
14014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14015 if (SWIG_arg_fail(1)) SWIG_fail;
14016 {
14017 PyThreadState* __tstate = wxPyBeginAllowThreads();
14018 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
14019
14020 wxPyEndAllowThreads(__tstate);
14021 if (PyErr_Occurred()) SWIG_fail;
14022 }
14023 {
14024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14025 }
14026 return resultobj;
14027 fail:
14028 return NULL;
14029 }
14030
14031
14032 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14033 PyObject *resultobj;
14034 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14035 wxString *arg2 = 0 ;
14036 int arg3 = (int) 0 ;
14037 bool temp2 = false ;
14038 PyObject * obj0 = 0 ;
14039 PyObject * obj1 = 0 ;
14040 PyObject * obj2 = 0 ;
14041 char *kwnames[] = {
14042 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
14043 };
14044
14045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14047 if (SWIG_arg_fail(1)) SWIG_fail;
14048 {
14049 arg2 = wxString_in_helper(obj1);
14050 if (arg2 == NULL) SWIG_fail;
14051 temp2 = true;
14052 }
14053 if (obj2) {
14054 {
14055 arg3 = (int)(SWIG_As_int(obj2));
14056 if (SWIG_arg_fail(3)) SWIG_fail;
14057 }
14058 }
14059 {
14060 PyThreadState* __tstate = wxPyBeginAllowThreads();
14061 (arg1)->SetIcon((wxString const &)*arg2,arg3);
14062
14063 wxPyEndAllowThreads(__tstate);
14064 if (PyErr_Occurred()) SWIG_fail;
14065 }
14066 Py_INCREF(Py_None); resultobj = Py_None;
14067 {
14068 if (temp2)
14069 delete arg2;
14070 }
14071 return resultobj;
14072 fail:
14073 {
14074 if (temp2)
14075 delete arg2;
14076 }
14077 return NULL;
14078 }
14079
14080
14081 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14082 PyObject *resultobj;
14083 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14084 wxString *arg2 = 0 ;
14085 bool temp2 = false ;
14086 PyObject * obj0 = 0 ;
14087 PyObject * obj1 = 0 ;
14088 char *kwnames[] = {
14089 (char *) "self",(char *) "shortDesc", NULL
14090 };
14091
14092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
14093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14094 if (SWIG_arg_fail(1)) SWIG_fail;
14095 {
14096 arg2 = wxString_in_helper(obj1);
14097 if (arg2 == NULL) SWIG_fail;
14098 temp2 = true;
14099 }
14100 {
14101 PyThreadState* __tstate = wxPyBeginAllowThreads();
14102 (arg1)->SetShortDesc((wxString const &)*arg2);
14103
14104 wxPyEndAllowThreads(__tstate);
14105 if (PyErr_Occurred()) SWIG_fail;
14106 }
14107 Py_INCREF(Py_None); resultobj = Py_None;
14108 {
14109 if (temp2)
14110 delete arg2;
14111 }
14112 return resultobj;
14113 fail:
14114 {
14115 if (temp2)
14116 delete arg2;
14117 }
14118 return NULL;
14119 }
14120
14121
14122 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14123 PyObject *resultobj;
14124 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14125 wxString *result;
14126 PyObject * obj0 = 0 ;
14127 char *kwnames[] = {
14128 (char *) "self", NULL
14129 };
14130
14131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14133 if (SWIG_arg_fail(1)) SWIG_fail;
14134 {
14135 PyThreadState* __tstate = wxPyBeginAllowThreads();
14136 {
14137 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14138 result = (wxString *) &_result_ref;
14139 }
14140
14141 wxPyEndAllowThreads(__tstate);
14142 if (PyErr_Occurred()) SWIG_fail;
14143 }
14144 {
14145 #if wxUSE_UNICODE
14146 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14147 #else
14148 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14149 #endif
14150 }
14151 return resultobj;
14152 fail:
14153 return NULL;
14154 }
14155
14156
14157 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14158 PyObject *resultobj;
14159 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14160 wxString *result;
14161 PyObject * obj0 = 0 ;
14162 char *kwnames[] = {
14163 (char *) "self", NULL
14164 };
14165
14166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14168 if (SWIG_arg_fail(1)) SWIG_fail;
14169 {
14170 PyThreadState* __tstate = wxPyBeginAllowThreads();
14171 {
14172 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14173 result = (wxString *) &_result_ref;
14174 }
14175
14176 wxPyEndAllowThreads(__tstate);
14177 if (PyErr_Occurred()) SWIG_fail;
14178 }
14179 {
14180 #if wxUSE_UNICODE
14181 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14182 #else
14183 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14184 #endif
14185 }
14186 return resultobj;
14187 fail:
14188 return NULL;
14189 }
14190
14191
14192 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14193 PyObject *resultobj;
14194 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14195 wxString *result;
14196 PyObject * obj0 = 0 ;
14197 char *kwnames[] = {
14198 (char *) "self", NULL
14199 };
14200
14201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14203 if (SWIG_arg_fail(1)) SWIG_fail;
14204 {
14205 PyThreadState* __tstate = wxPyBeginAllowThreads();
14206 {
14207 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14208 result = (wxString *) &_result_ref;
14209 }
14210
14211 wxPyEndAllowThreads(__tstate);
14212 if (PyErr_Occurred()) SWIG_fail;
14213 }
14214 {
14215 #if wxUSE_UNICODE
14216 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14217 #else
14218 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14219 #endif
14220 }
14221 return resultobj;
14222 fail:
14223 return NULL;
14224 }
14225
14226
14227 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14228 PyObject *resultobj;
14229 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14230 wxString *result;
14231 PyObject * obj0 = 0 ;
14232 char *kwnames[] = {
14233 (char *) "self", NULL
14234 };
14235
14236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14238 if (SWIG_arg_fail(1)) SWIG_fail;
14239 {
14240 PyThreadState* __tstate = wxPyBeginAllowThreads();
14241 {
14242 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14243 result = (wxString *) &_result_ref;
14244 }
14245
14246 wxPyEndAllowThreads(__tstate);
14247 if (PyErr_Occurred()) SWIG_fail;
14248 }
14249 {
14250 #if wxUSE_UNICODE
14251 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14252 #else
14253 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14254 #endif
14255 }
14256 return resultobj;
14257 fail:
14258 return NULL;
14259 }
14260
14261
14262 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14263 PyObject *resultobj;
14264 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14265 wxString *result;
14266 PyObject * obj0 = 0 ;
14267 char *kwnames[] = {
14268 (char *) "self", NULL
14269 };
14270
14271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14273 if (SWIG_arg_fail(1)) SWIG_fail;
14274 {
14275 PyThreadState* __tstate = wxPyBeginAllowThreads();
14276 {
14277 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14278 result = (wxString *) &_result_ref;
14279 }
14280
14281 wxPyEndAllowThreads(__tstate);
14282 if (PyErr_Occurred()) SWIG_fail;
14283 }
14284 {
14285 #if wxUSE_UNICODE
14286 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14287 #else
14288 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14289 #endif
14290 }
14291 return resultobj;
14292 fail:
14293 return NULL;
14294 }
14295
14296
14297 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14298 PyObject *resultobj;
14299 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14300 wxArrayString *result;
14301 PyObject * obj0 = 0 ;
14302 char *kwnames[] = {
14303 (char *) "self", NULL
14304 };
14305
14306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14308 if (SWIG_arg_fail(1)) SWIG_fail;
14309 {
14310 PyThreadState* __tstate = wxPyBeginAllowThreads();
14311 {
14312 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14313 result = (wxArrayString *) &_result_ref;
14314 }
14315
14316 wxPyEndAllowThreads(__tstate);
14317 if (PyErr_Occurred()) SWIG_fail;
14318 }
14319 {
14320 resultobj = wxArrayString2PyList_helper(*result);
14321 }
14322 return resultobj;
14323 fail:
14324 return NULL;
14325 }
14326
14327
14328 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14329 PyObject *resultobj;
14330 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14331 int result;
14332 PyObject * obj0 = 0 ;
14333 char *kwnames[] = {
14334 (char *) "self", NULL
14335 };
14336
14337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14339 if (SWIG_arg_fail(1)) SWIG_fail;
14340 {
14341 PyThreadState* __tstate = wxPyBeginAllowThreads();
14342 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14343
14344 wxPyEndAllowThreads(__tstate);
14345 if (PyErr_Occurred()) SWIG_fail;
14346 }
14347 {
14348 resultobj = SWIG_From_int((int)(result));
14349 }
14350 return resultobj;
14351 fail:
14352 return NULL;
14353 }
14354
14355
14356 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14357 PyObject *resultobj;
14358 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14359 wxString *result;
14360 PyObject * obj0 = 0 ;
14361 char *kwnames[] = {
14362 (char *) "self", NULL
14363 };
14364
14365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14367 if (SWIG_arg_fail(1)) SWIG_fail;
14368 {
14369 PyThreadState* __tstate = wxPyBeginAllowThreads();
14370 {
14371 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14372 result = (wxString *) &_result_ref;
14373 }
14374
14375 wxPyEndAllowThreads(__tstate);
14376 if (PyErr_Occurred()) SWIG_fail;
14377 }
14378 {
14379 #if wxUSE_UNICODE
14380 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14381 #else
14382 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14383 #endif
14384 }
14385 return resultobj;
14386 fail:
14387 return NULL;
14388 }
14389
14390
14391 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14392 PyObject *resultobj;
14393 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14394 int result;
14395 PyObject * obj0 = 0 ;
14396 char *kwnames[] = {
14397 (char *) "self", NULL
14398 };
14399
14400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14402 if (SWIG_arg_fail(1)) SWIG_fail;
14403 {
14404 PyThreadState* __tstate = wxPyBeginAllowThreads();
14405 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14406
14407 wxPyEndAllowThreads(__tstate);
14408 if (PyErr_Occurred()) SWIG_fail;
14409 }
14410 {
14411 resultobj = SWIG_From_int((int)(result));
14412 }
14413 return resultobj;
14414 fail:
14415 return NULL;
14416 }
14417
14418
14419 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14420 PyObject *obj;
14421 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14422 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14423 Py_INCREF(obj);
14424 return Py_BuildValue((char *)"");
14425 }
14426 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14427 PyObject *resultobj;
14428 wxFileTypeInfo *arg1 = 0 ;
14429 wxFileType *result;
14430 PyObject * obj0 = 0 ;
14431 char *kwnames[] = {
14432 (char *) "ftInfo", NULL
14433 };
14434
14435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14436 {
14437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14438 if (SWIG_arg_fail(1)) SWIG_fail;
14439 if (arg1 == NULL) {
14440 SWIG_null_ref("wxFileTypeInfo");
14441 }
14442 if (SWIG_arg_fail(1)) SWIG_fail;
14443 }
14444 {
14445 PyThreadState* __tstate = wxPyBeginAllowThreads();
14446 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14447
14448 wxPyEndAllowThreads(__tstate);
14449 if (PyErr_Occurred()) SWIG_fail;
14450 }
14451 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14452 return resultobj;
14453 fail:
14454 return NULL;
14455 }
14456
14457
14458 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14459 PyObject *resultobj;
14460 wxFileType *arg1 = (wxFileType *) 0 ;
14461 PyObject * obj0 = 0 ;
14462 char *kwnames[] = {
14463 (char *) "self", NULL
14464 };
14465
14466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14468 if (SWIG_arg_fail(1)) SWIG_fail;
14469 {
14470 PyThreadState* __tstate = wxPyBeginAllowThreads();
14471 delete arg1;
14472
14473 wxPyEndAllowThreads(__tstate);
14474 if (PyErr_Occurred()) SWIG_fail;
14475 }
14476 Py_INCREF(Py_None); resultobj = Py_None;
14477 return resultobj;
14478 fail:
14479 return NULL;
14480 }
14481
14482
14483 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14484 PyObject *resultobj;
14485 wxFileType *arg1 = (wxFileType *) 0 ;
14486 PyObject *result;
14487 PyObject * obj0 = 0 ;
14488 char *kwnames[] = {
14489 (char *) "self", NULL
14490 };
14491
14492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14494 if (SWIG_arg_fail(1)) SWIG_fail;
14495 {
14496 PyThreadState* __tstate = wxPyBeginAllowThreads();
14497 result = (PyObject *)wxFileType_GetMimeType(arg1);
14498
14499 wxPyEndAllowThreads(__tstate);
14500 if (PyErr_Occurred()) SWIG_fail;
14501 }
14502 resultobj = result;
14503 return resultobj;
14504 fail:
14505 return NULL;
14506 }
14507
14508
14509 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14510 PyObject *resultobj;
14511 wxFileType *arg1 = (wxFileType *) 0 ;
14512 PyObject *result;
14513 PyObject * obj0 = 0 ;
14514 char *kwnames[] = {
14515 (char *) "self", NULL
14516 };
14517
14518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14520 if (SWIG_arg_fail(1)) SWIG_fail;
14521 {
14522 PyThreadState* __tstate = wxPyBeginAllowThreads();
14523 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14524
14525 wxPyEndAllowThreads(__tstate);
14526 if (PyErr_Occurred()) SWIG_fail;
14527 }
14528 resultobj = result;
14529 return resultobj;
14530 fail:
14531 return NULL;
14532 }
14533
14534
14535 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14536 PyObject *resultobj;
14537 wxFileType *arg1 = (wxFileType *) 0 ;
14538 PyObject *result;
14539 PyObject * obj0 = 0 ;
14540 char *kwnames[] = {
14541 (char *) "self", NULL
14542 };
14543
14544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14546 if (SWIG_arg_fail(1)) SWIG_fail;
14547 {
14548 PyThreadState* __tstate = wxPyBeginAllowThreads();
14549 result = (PyObject *)wxFileType_GetExtensions(arg1);
14550
14551 wxPyEndAllowThreads(__tstate);
14552 if (PyErr_Occurred()) SWIG_fail;
14553 }
14554 resultobj = result;
14555 return resultobj;
14556 fail:
14557 return NULL;
14558 }
14559
14560
14561 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14562 PyObject *resultobj;
14563 wxFileType *arg1 = (wxFileType *) 0 ;
14564 wxIcon *result;
14565 PyObject * obj0 = 0 ;
14566 char *kwnames[] = {
14567 (char *) "self", NULL
14568 };
14569
14570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14572 if (SWIG_arg_fail(1)) SWIG_fail;
14573 {
14574 PyThreadState* __tstate = wxPyBeginAllowThreads();
14575 result = (wxIcon *)wxFileType_GetIcon(arg1);
14576
14577 wxPyEndAllowThreads(__tstate);
14578 if (PyErr_Occurred()) SWIG_fail;
14579 }
14580 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14581 return resultobj;
14582 fail:
14583 return NULL;
14584 }
14585
14586
14587 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14588 PyObject *resultobj;
14589 wxFileType *arg1 = (wxFileType *) 0 ;
14590 PyObject *result;
14591 PyObject * obj0 = 0 ;
14592 char *kwnames[] = {
14593 (char *) "self", NULL
14594 };
14595
14596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14598 if (SWIG_arg_fail(1)) SWIG_fail;
14599 {
14600 PyThreadState* __tstate = wxPyBeginAllowThreads();
14601 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14602
14603 wxPyEndAllowThreads(__tstate);
14604 if (PyErr_Occurred()) SWIG_fail;
14605 }
14606 resultobj = result;
14607 return resultobj;
14608 fail:
14609 return NULL;
14610 }
14611
14612
14613 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14614 PyObject *resultobj;
14615 wxFileType *arg1 = (wxFileType *) 0 ;
14616 PyObject *result;
14617 PyObject * obj0 = 0 ;
14618 char *kwnames[] = {
14619 (char *) "self", NULL
14620 };
14621
14622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14624 if (SWIG_arg_fail(1)) SWIG_fail;
14625 {
14626 PyThreadState* __tstate = wxPyBeginAllowThreads();
14627 result = (PyObject *)wxFileType_GetDescription(arg1);
14628
14629 wxPyEndAllowThreads(__tstate);
14630 if (PyErr_Occurred()) SWIG_fail;
14631 }
14632 resultobj = result;
14633 return resultobj;
14634 fail:
14635 return NULL;
14636 }
14637
14638
14639 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14640 PyObject *resultobj;
14641 wxFileType *arg1 = (wxFileType *) 0 ;
14642 wxString *arg2 = 0 ;
14643 wxString const &arg3_defvalue = wxPyEmptyString ;
14644 wxString *arg3 = (wxString *) &arg3_defvalue ;
14645 PyObject *result;
14646 bool temp2 = false ;
14647 bool temp3 = false ;
14648 PyObject * obj0 = 0 ;
14649 PyObject * obj1 = 0 ;
14650 PyObject * obj2 = 0 ;
14651 char *kwnames[] = {
14652 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14653 };
14654
14655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14657 if (SWIG_arg_fail(1)) SWIG_fail;
14658 {
14659 arg2 = wxString_in_helper(obj1);
14660 if (arg2 == NULL) SWIG_fail;
14661 temp2 = true;
14662 }
14663 if (obj2) {
14664 {
14665 arg3 = wxString_in_helper(obj2);
14666 if (arg3 == NULL) SWIG_fail;
14667 temp3 = true;
14668 }
14669 }
14670 {
14671 PyThreadState* __tstate = wxPyBeginAllowThreads();
14672 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14673
14674 wxPyEndAllowThreads(__tstate);
14675 if (PyErr_Occurred()) SWIG_fail;
14676 }
14677 resultobj = result;
14678 {
14679 if (temp2)
14680 delete arg2;
14681 }
14682 {
14683 if (temp3)
14684 delete arg3;
14685 }
14686 return resultobj;
14687 fail:
14688 {
14689 if (temp2)
14690 delete arg2;
14691 }
14692 {
14693 if (temp3)
14694 delete arg3;
14695 }
14696 return NULL;
14697 }
14698
14699
14700 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14701 PyObject *resultobj;
14702 wxFileType *arg1 = (wxFileType *) 0 ;
14703 wxString *arg2 = 0 ;
14704 wxString const &arg3_defvalue = wxPyEmptyString ;
14705 wxString *arg3 = (wxString *) &arg3_defvalue ;
14706 PyObject *result;
14707 bool temp2 = false ;
14708 bool temp3 = false ;
14709 PyObject * obj0 = 0 ;
14710 PyObject * obj1 = 0 ;
14711 PyObject * obj2 = 0 ;
14712 char *kwnames[] = {
14713 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14714 };
14715
14716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14718 if (SWIG_arg_fail(1)) SWIG_fail;
14719 {
14720 arg2 = wxString_in_helper(obj1);
14721 if (arg2 == NULL) SWIG_fail;
14722 temp2 = true;
14723 }
14724 if (obj2) {
14725 {
14726 arg3 = wxString_in_helper(obj2);
14727 if (arg3 == NULL) SWIG_fail;
14728 temp3 = true;
14729 }
14730 }
14731 {
14732 PyThreadState* __tstate = wxPyBeginAllowThreads();
14733 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14734
14735 wxPyEndAllowThreads(__tstate);
14736 if (PyErr_Occurred()) SWIG_fail;
14737 }
14738 resultobj = result;
14739 {
14740 if (temp2)
14741 delete arg2;
14742 }
14743 {
14744 if (temp3)
14745 delete arg3;
14746 }
14747 return resultobj;
14748 fail:
14749 {
14750 if (temp2)
14751 delete arg2;
14752 }
14753 {
14754 if (temp3)
14755 delete arg3;
14756 }
14757 return NULL;
14758 }
14759
14760
14761 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14762 PyObject *resultobj;
14763 wxFileType *arg1 = (wxFileType *) 0 ;
14764 wxString *arg2 = 0 ;
14765 wxString const &arg3_defvalue = wxPyEmptyString ;
14766 wxString *arg3 = (wxString *) &arg3_defvalue ;
14767 PyObject *result;
14768 bool temp2 = false ;
14769 bool temp3 = false ;
14770 PyObject * obj0 = 0 ;
14771 PyObject * obj1 = 0 ;
14772 PyObject * obj2 = 0 ;
14773 char *kwnames[] = {
14774 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14775 };
14776
14777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14779 if (SWIG_arg_fail(1)) SWIG_fail;
14780 {
14781 arg2 = wxString_in_helper(obj1);
14782 if (arg2 == NULL) SWIG_fail;
14783 temp2 = true;
14784 }
14785 if (obj2) {
14786 {
14787 arg3 = wxString_in_helper(obj2);
14788 if (arg3 == NULL) SWIG_fail;
14789 temp3 = true;
14790 }
14791 }
14792 {
14793 PyThreadState* __tstate = wxPyBeginAllowThreads();
14794 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14795
14796 wxPyEndAllowThreads(__tstate);
14797 if (PyErr_Occurred()) SWIG_fail;
14798 }
14799 resultobj = result;
14800 {
14801 if (temp2)
14802 delete arg2;
14803 }
14804 {
14805 if (temp3)
14806 delete arg3;
14807 }
14808 return resultobj;
14809 fail:
14810 {
14811 if (temp2)
14812 delete arg2;
14813 }
14814 {
14815 if (temp3)
14816 delete arg3;
14817 }
14818 return NULL;
14819 }
14820
14821
14822 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14823 PyObject *resultobj;
14824 wxFileType *arg1 = (wxFileType *) 0 ;
14825 wxString *arg2 = 0 ;
14826 wxString *arg3 = 0 ;
14827 bool arg4 = (bool) true ;
14828 bool result;
14829 bool temp2 = false ;
14830 bool temp3 = false ;
14831 PyObject * obj0 = 0 ;
14832 PyObject * obj1 = 0 ;
14833 PyObject * obj2 = 0 ;
14834 PyObject * obj3 = 0 ;
14835 char *kwnames[] = {
14836 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14837 };
14838
14839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14841 if (SWIG_arg_fail(1)) SWIG_fail;
14842 {
14843 arg2 = wxString_in_helper(obj1);
14844 if (arg2 == NULL) SWIG_fail;
14845 temp2 = true;
14846 }
14847 {
14848 arg3 = wxString_in_helper(obj2);
14849 if (arg3 == NULL) SWIG_fail;
14850 temp3 = true;
14851 }
14852 if (obj3) {
14853 {
14854 arg4 = (bool)(SWIG_As_bool(obj3));
14855 if (SWIG_arg_fail(4)) SWIG_fail;
14856 }
14857 }
14858 {
14859 PyThreadState* __tstate = wxPyBeginAllowThreads();
14860 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14861
14862 wxPyEndAllowThreads(__tstate);
14863 if (PyErr_Occurred()) SWIG_fail;
14864 }
14865 {
14866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14867 }
14868 {
14869 if (temp2)
14870 delete arg2;
14871 }
14872 {
14873 if (temp3)
14874 delete arg3;
14875 }
14876 return resultobj;
14877 fail:
14878 {
14879 if (temp2)
14880 delete arg2;
14881 }
14882 {
14883 if (temp3)
14884 delete arg3;
14885 }
14886 return NULL;
14887 }
14888
14889
14890 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14891 PyObject *resultobj;
14892 wxFileType *arg1 = (wxFileType *) 0 ;
14893 wxString const &arg2_defvalue = wxPyEmptyString ;
14894 wxString *arg2 = (wxString *) &arg2_defvalue ;
14895 int arg3 = (int) 0 ;
14896 bool result;
14897 bool temp2 = false ;
14898 PyObject * obj0 = 0 ;
14899 PyObject * obj1 = 0 ;
14900 PyObject * obj2 = 0 ;
14901 char *kwnames[] = {
14902 (char *) "self",(char *) "cmd",(char *) "index", NULL
14903 };
14904
14905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14907 if (SWIG_arg_fail(1)) SWIG_fail;
14908 if (obj1) {
14909 {
14910 arg2 = wxString_in_helper(obj1);
14911 if (arg2 == NULL) SWIG_fail;
14912 temp2 = true;
14913 }
14914 }
14915 if (obj2) {
14916 {
14917 arg3 = (int)(SWIG_As_int(obj2));
14918 if (SWIG_arg_fail(3)) SWIG_fail;
14919 }
14920 }
14921 {
14922 PyThreadState* __tstate = wxPyBeginAllowThreads();
14923 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14924
14925 wxPyEndAllowThreads(__tstate);
14926 if (PyErr_Occurred()) SWIG_fail;
14927 }
14928 {
14929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14930 }
14931 {
14932 if (temp2)
14933 delete arg2;
14934 }
14935 return resultobj;
14936 fail:
14937 {
14938 if (temp2)
14939 delete arg2;
14940 }
14941 return NULL;
14942 }
14943
14944
14945 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14946 PyObject *resultobj;
14947 wxFileType *arg1 = (wxFileType *) 0 ;
14948 bool result;
14949 PyObject * obj0 = 0 ;
14950 char *kwnames[] = {
14951 (char *) "self", NULL
14952 };
14953
14954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14956 if (SWIG_arg_fail(1)) SWIG_fail;
14957 {
14958 PyThreadState* __tstate = wxPyBeginAllowThreads();
14959 result = (bool)(arg1)->Unassociate();
14960
14961 wxPyEndAllowThreads(__tstate);
14962 if (PyErr_Occurred()) SWIG_fail;
14963 }
14964 {
14965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14966 }
14967 return resultobj;
14968 fail:
14969 return NULL;
14970 }
14971
14972
14973 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14974 PyObject *resultobj;
14975 wxString *arg1 = 0 ;
14976 wxString *arg2 = 0 ;
14977 wxString const &arg3_defvalue = wxPyEmptyString ;
14978 wxString *arg3 = (wxString *) &arg3_defvalue ;
14979 wxString result;
14980 bool temp1 = false ;
14981 bool temp2 = false ;
14982 bool temp3 = false ;
14983 PyObject * obj0 = 0 ;
14984 PyObject * obj1 = 0 ;
14985 PyObject * obj2 = 0 ;
14986 char *kwnames[] = {
14987 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14988 };
14989
14990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14991 {
14992 arg1 = wxString_in_helper(obj0);
14993 if (arg1 == NULL) SWIG_fail;
14994 temp1 = true;
14995 }
14996 {
14997 arg2 = wxString_in_helper(obj1);
14998 if (arg2 == NULL) SWIG_fail;
14999 temp2 = true;
15000 }
15001 if (obj2) {
15002 {
15003 arg3 = wxString_in_helper(obj2);
15004 if (arg3 == NULL) SWIG_fail;
15005 temp3 = true;
15006 }
15007 }
15008 {
15009 PyThreadState* __tstate = wxPyBeginAllowThreads();
15010 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15011
15012 wxPyEndAllowThreads(__tstate);
15013 if (PyErr_Occurred()) SWIG_fail;
15014 }
15015 {
15016 #if wxUSE_UNICODE
15017 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15018 #else
15019 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15020 #endif
15021 }
15022 {
15023 if (temp1)
15024 delete arg1;
15025 }
15026 {
15027 if (temp2)
15028 delete arg2;
15029 }
15030 {
15031 if (temp3)
15032 delete arg3;
15033 }
15034 return resultobj;
15035 fail:
15036 {
15037 if (temp1)
15038 delete arg1;
15039 }
15040 {
15041 if (temp2)
15042 delete arg2;
15043 }
15044 {
15045 if (temp3)
15046 delete arg3;
15047 }
15048 return NULL;
15049 }
15050
15051
15052 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
15053 PyObject *obj;
15054 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15055 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
15056 Py_INCREF(obj);
15057 return Py_BuildValue((char *)"");
15058 }
15059 static int _wrap_TheMimeTypesManager_set(PyObject *) {
15060 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
15061 return 1;
15062 }
15063
15064
15065 static PyObject *_wrap_TheMimeTypesManager_get(void) {
15066 PyObject *pyobj;
15067
15068 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
15069 return pyobj;
15070 }
15071
15072
15073 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
15074 PyObject *resultobj;
15075 wxString *arg1 = 0 ;
15076 wxString *arg2 = 0 ;
15077 bool result;
15078 bool temp1 = false ;
15079 bool temp2 = false ;
15080 PyObject * obj0 = 0 ;
15081 PyObject * obj1 = 0 ;
15082 char *kwnames[] = {
15083 (char *) "mimeType",(char *) "wildcard", NULL
15084 };
15085
15086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
15087 {
15088 arg1 = wxString_in_helper(obj0);
15089 if (arg1 == NULL) SWIG_fail;
15090 temp1 = true;
15091 }
15092 {
15093 arg2 = wxString_in_helper(obj1);
15094 if (arg2 == NULL) SWIG_fail;
15095 temp2 = true;
15096 }
15097 {
15098 PyThreadState* __tstate = wxPyBeginAllowThreads();
15099 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
15100
15101 wxPyEndAllowThreads(__tstate);
15102 if (PyErr_Occurred()) SWIG_fail;
15103 }
15104 {
15105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15106 }
15107 {
15108 if (temp1)
15109 delete arg1;
15110 }
15111 {
15112 if (temp2)
15113 delete arg2;
15114 }
15115 return resultobj;
15116 fail:
15117 {
15118 if (temp1)
15119 delete arg1;
15120 }
15121 {
15122 if (temp2)
15123 delete arg2;
15124 }
15125 return NULL;
15126 }
15127
15128
15129 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15130 PyObject *resultobj;
15131 wxMimeTypesManager *result;
15132 char *kwnames[] = {
15133 NULL
15134 };
15135
15136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15137 {
15138 PyThreadState* __tstate = wxPyBeginAllowThreads();
15139 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15140
15141 wxPyEndAllowThreads(__tstate);
15142 if (PyErr_Occurred()) SWIG_fail;
15143 }
15144 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15145 return resultobj;
15146 fail:
15147 return NULL;
15148 }
15149
15150
15151 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15152 PyObject *resultobj;
15153 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15154 int arg2 = (int) wxMAILCAP_ALL ;
15155 wxString const &arg3_defvalue = wxPyEmptyString ;
15156 wxString *arg3 = (wxString *) &arg3_defvalue ;
15157 bool temp3 = false ;
15158 PyObject * obj0 = 0 ;
15159 PyObject * obj1 = 0 ;
15160 PyObject * obj2 = 0 ;
15161 char *kwnames[] = {
15162 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15163 };
15164
15165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15167 if (SWIG_arg_fail(1)) SWIG_fail;
15168 if (obj1) {
15169 {
15170 arg2 = (int)(SWIG_As_int(obj1));
15171 if (SWIG_arg_fail(2)) SWIG_fail;
15172 }
15173 }
15174 if (obj2) {
15175 {
15176 arg3 = wxString_in_helper(obj2);
15177 if (arg3 == NULL) SWIG_fail;
15178 temp3 = true;
15179 }
15180 }
15181 {
15182 PyThreadState* __tstate = wxPyBeginAllowThreads();
15183 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15184
15185 wxPyEndAllowThreads(__tstate);
15186 if (PyErr_Occurred()) SWIG_fail;
15187 }
15188 Py_INCREF(Py_None); resultobj = Py_None;
15189 {
15190 if (temp3)
15191 delete arg3;
15192 }
15193 return resultobj;
15194 fail:
15195 {
15196 if (temp3)
15197 delete arg3;
15198 }
15199 return NULL;
15200 }
15201
15202
15203 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15204 PyObject *resultobj;
15205 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15206 PyObject * obj0 = 0 ;
15207 char *kwnames[] = {
15208 (char *) "self", NULL
15209 };
15210
15211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15213 if (SWIG_arg_fail(1)) SWIG_fail;
15214 {
15215 PyThreadState* __tstate = wxPyBeginAllowThreads();
15216 (arg1)->ClearData();
15217
15218 wxPyEndAllowThreads(__tstate);
15219 if (PyErr_Occurred()) SWIG_fail;
15220 }
15221 Py_INCREF(Py_None); resultobj = Py_None;
15222 return resultobj;
15223 fail:
15224 return NULL;
15225 }
15226
15227
15228 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15229 PyObject *resultobj;
15230 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15231 wxString *arg2 = 0 ;
15232 wxFileType *result;
15233 bool temp2 = false ;
15234 PyObject * obj0 = 0 ;
15235 PyObject * obj1 = 0 ;
15236 char *kwnames[] = {
15237 (char *) "self",(char *) "ext", NULL
15238 };
15239
15240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15242 if (SWIG_arg_fail(1)) SWIG_fail;
15243 {
15244 arg2 = wxString_in_helper(obj1);
15245 if (arg2 == NULL) SWIG_fail;
15246 temp2 = true;
15247 }
15248 {
15249 PyThreadState* __tstate = wxPyBeginAllowThreads();
15250 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15251
15252 wxPyEndAllowThreads(__tstate);
15253 if (PyErr_Occurred()) SWIG_fail;
15254 }
15255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15256 {
15257 if (temp2)
15258 delete arg2;
15259 }
15260 return resultobj;
15261 fail:
15262 {
15263 if (temp2)
15264 delete arg2;
15265 }
15266 return NULL;
15267 }
15268
15269
15270 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15271 PyObject *resultobj;
15272 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15273 wxString *arg2 = 0 ;
15274 wxFileType *result;
15275 bool temp2 = false ;
15276 PyObject * obj0 = 0 ;
15277 PyObject * obj1 = 0 ;
15278 char *kwnames[] = {
15279 (char *) "self",(char *) "mimeType", NULL
15280 };
15281
15282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15284 if (SWIG_arg_fail(1)) SWIG_fail;
15285 {
15286 arg2 = wxString_in_helper(obj1);
15287 if (arg2 == NULL) SWIG_fail;
15288 temp2 = true;
15289 }
15290 {
15291 PyThreadState* __tstate = wxPyBeginAllowThreads();
15292 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15293
15294 wxPyEndAllowThreads(__tstate);
15295 if (PyErr_Occurred()) SWIG_fail;
15296 }
15297 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15298 {
15299 if (temp2)
15300 delete arg2;
15301 }
15302 return resultobj;
15303 fail:
15304 {
15305 if (temp2)
15306 delete arg2;
15307 }
15308 return NULL;
15309 }
15310
15311
15312 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15313 PyObject *resultobj;
15314 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15315 wxString *arg2 = 0 ;
15316 bool arg3 = (bool) false ;
15317 bool result;
15318 bool temp2 = false ;
15319 PyObject * obj0 = 0 ;
15320 PyObject * obj1 = 0 ;
15321 PyObject * obj2 = 0 ;
15322 char *kwnames[] = {
15323 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15324 };
15325
15326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15328 if (SWIG_arg_fail(1)) SWIG_fail;
15329 {
15330 arg2 = wxString_in_helper(obj1);
15331 if (arg2 == NULL) SWIG_fail;
15332 temp2 = true;
15333 }
15334 if (obj2) {
15335 {
15336 arg3 = (bool)(SWIG_As_bool(obj2));
15337 if (SWIG_arg_fail(3)) SWIG_fail;
15338 }
15339 }
15340 {
15341 PyThreadState* __tstate = wxPyBeginAllowThreads();
15342 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15343
15344 wxPyEndAllowThreads(__tstate);
15345 if (PyErr_Occurred()) SWIG_fail;
15346 }
15347 {
15348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15349 }
15350 {
15351 if (temp2)
15352 delete arg2;
15353 }
15354 return resultobj;
15355 fail:
15356 {
15357 if (temp2)
15358 delete arg2;
15359 }
15360 return NULL;
15361 }
15362
15363
15364 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15365 PyObject *resultobj;
15366 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15367 wxString *arg2 = 0 ;
15368 bool result;
15369 bool temp2 = false ;
15370 PyObject * obj0 = 0 ;
15371 PyObject * obj1 = 0 ;
15372 char *kwnames[] = {
15373 (char *) "self",(char *) "filename", NULL
15374 };
15375
15376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15378 if (SWIG_arg_fail(1)) SWIG_fail;
15379 {
15380 arg2 = wxString_in_helper(obj1);
15381 if (arg2 == NULL) SWIG_fail;
15382 temp2 = true;
15383 }
15384 {
15385 PyThreadState* __tstate = wxPyBeginAllowThreads();
15386 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15387
15388 wxPyEndAllowThreads(__tstate);
15389 if (PyErr_Occurred()) SWIG_fail;
15390 }
15391 {
15392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15393 }
15394 {
15395 if (temp2)
15396 delete arg2;
15397 }
15398 return resultobj;
15399 fail:
15400 {
15401 if (temp2)
15402 delete arg2;
15403 }
15404 return NULL;
15405 }
15406
15407
15408 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15409 PyObject *resultobj;
15410 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15411 PyObject *result;
15412 PyObject * obj0 = 0 ;
15413 char *kwnames[] = {
15414 (char *) "self", NULL
15415 };
15416
15417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15419 if (SWIG_arg_fail(1)) SWIG_fail;
15420 {
15421 PyThreadState* __tstate = wxPyBeginAllowThreads();
15422 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15423
15424 wxPyEndAllowThreads(__tstate);
15425 if (PyErr_Occurred()) SWIG_fail;
15426 }
15427 resultobj = result;
15428 return resultobj;
15429 fail:
15430 return NULL;
15431 }
15432
15433
15434 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15435 PyObject *resultobj;
15436 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15437 wxFileTypeInfo *arg2 = 0 ;
15438 PyObject * obj0 = 0 ;
15439 PyObject * obj1 = 0 ;
15440 char *kwnames[] = {
15441 (char *) "self",(char *) "ft", NULL
15442 };
15443
15444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15446 if (SWIG_arg_fail(1)) SWIG_fail;
15447 {
15448 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15449 if (SWIG_arg_fail(2)) SWIG_fail;
15450 if (arg2 == NULL) {
15451 SWIG_null_ref("wxFileTypeInfo");
15452 }
15453 if (SWIG_arg_fail(2)) SWIG_fail;
15454 }
15455 {
15456 PyThreadState* __tstate = wxPyBeginAllowThreads();
15457 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15458
15459 wxPyEndAllowThreads(__tstate);
15460 if (PyErr_Occurred()) SWIG_fail;
15461 }
15462 Py_INCREF(Py_None); resultobj = Py_None;
15463 return resultobj;
15464 fail:
15465 return NULL;
15466 }
15467
15468
15469 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15470 PyObject *resultobj;
15471 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15472 wxFileTypeInfo *arg2 = 0 ;
15473 wxFileType *result;
15474 PyObject * obj0 = 0 ;
15475 PyObject * obj1 = 0 ;
15476 char *kwnames[] = {
15477 (char *) "self",(char *) "ftInfo", NULL
15478 };
15479
15480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15482 if (SWIG_arg_fail(1)) SWIG_fail;
15483 {
15484 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15485 if (SWIG_arg_fail(2)) SWIG_fail;
15486 if (arg2 == NULL) {
15487 SWIG_null_ref("wxFileTypeInfo");
15488 }
15489 if (SWIG_arg_fail(2)) SWIG_fail;
15490 }
15491 {
15492 PyThreadState* __tstate = wxPyBeginAllowThreads();
15493 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15494
15495 wxPyEndAllowThreads(__tstate);
15496 if (PyErr_Occurred()) SWIG_fail;
15497 }
15498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15499 return resultobj;
15500 fail:
15501 return NULL;
15502 }
15503
15504
15505 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15506 PyObject *resultobj;
15507 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15508 wxFileType *arg2 = (wxFileType *) 0 ;
15509 bool result;
15510 PyObject * obj0 = 0 ;
15511 PyObject * obj1 = 0 ;
15512 char *kwnames[] = {
15513 (char *) "self",(char *) "ft", NULL
15514 };
15515
15516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15518 if (SWIG_arg_fail(1)) SWIG_fail;
15519 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15520 if (SWIG_arg_fail(2)) SWIG_fail;
15521 {
15522 PyThreadState* __tstate = wxPyBeginAllowThreads();
15523 result = (bool)(arg1)->Unassociate(arg2);
15524
15525 wxPyEndAllowThreads(__tstate);
15526 if (PyErr_Occurred()) SWIG_fail;
15527 }
15528 {
15529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15530 }
15531 return resultobj;
15532 fail:
15533 return NULL;
15534 }
15535
15536
15537 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15538 PyObject *resultobj;
15539 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15540 PyObject * obj0 = 0 ;
15541 char *kwnames[] = {
15542 (char *) "self", NULL
15543 };
15544
15545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15547 if (SWIG_arg_fail(1)) SWIG_fail;
15548 {
15549 PyThreadState* __tstate = wxPyBeginAllowThreads();
15550 delete arg1;
15551
15552 wxPyEndAllowThreads(__tstate);
15553 if (PyErr_Occurred()) SWIG_fail;
15554 }
15555 Py_INCREF(Py_None); resultobj = Py_None;
15556 return resultobj;
15557 fail:
15558 return NULL;
15559 }
15560
15561
15562 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15563 PyObject *obj;
15564 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15565 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15566 Py_INCREF(obj);
15567 return Py_BuildValue((char *)"");
15568 }
15569 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15570 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15571 return 1;
15572 }
15573
15574
15575 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15576 PyObject *pyobj;
15577
15578 {
15579 #if wxUSE_UNICODE
15580 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15581 #else
15582 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15583 #endif
15584 }
15585 return pyobj;
15586 }
15587
15588
15589 static int _wrap_ART_MENU_set(PyObject *) {
15590 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15591 return 1;
15592 }
15593
15594
15595 static PyObject *_wrap_ART_MENU_get(void) {
15596 PyObject *pyobj;
15597
15598 {
15599 #if wxUSE_UNICODE
15600 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15601 #else
15602 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15603 #endif
15604 }
15605 return pyobj;
15606 }
15607
15608
15609 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15610 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15611 return 1;
15612 }
15613
15614
15615 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15616 PyObject *pyobj;
15617
15618 {
15619 #if wxUSE_UNICODE
15620 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15621 #else
15622 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15623 #endif
15624 }
15625 return pyobj;
15626 }
15627
15628
15629 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15630 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15631 return 1;
15632 }
15633
15634
15635 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15636 PyObject *pyobj;
15637
15638 {
15639 #if wxUSE_UNICODE
15640 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15641 #else
15642 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15643 #endif
15644 }
15645 return pyobj;
15646 }
15647
15648
15649 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15650 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15651 return 1;
15652 }
15653
15654
15655 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15656 PyObject *pyobj;
15657
15658 {
15659 #if wxUSE_UNICODE
15660 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15661 #else
15662 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15663 #endif
15664 }
15665 return pyobj;
15666 }
15667
15668
15669 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15670 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15671 return 1;
15672 }
15673
15674
15675 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15676 PyObject *pyobj;
15677
15678 {
15679 #if wxUSE_UNICODE
15680 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15681 #else
15682 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15683 #endif
15684 }
15685 return pyobj;
15686 }
15687
15688
15689 static int _wrap_ART_BUTTON_set(PyObject *) {
15690 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15691 return 1;
15692 }
15693
15694
15695 static PyObject *_wrap_ART_BUTTON_get(void) {
15696 PyObject *pyobj;
15697
15698 {
15699 #if wxUSE_UNICODE
15700 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15701 #else
15702 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15703 #endif
15704 }
15705 return pyobj;
15706 }
15707
15708
15709 static int _wrap_ART_OTHER_set(PyObject *) {
15710 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15711 return 1;
15712 }
15713
15714
15715 static PyObject *_wrap_ART_OTHER_get(void) {
15716 PyObject *pyobj;
15717
15718 {
15719 #if wxUSE_UNICODE
15720 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15721 #else
15722 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15723 #endif
15724 }
15725 return pyobj;
15726 }
15727
15728
15729 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15730 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15731 return 1;
15732 }
15733
15734
15735 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15736 PyObject *pyobj;
15737
15738 {
15739 #if wxUSE_UNICODE
15740 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15741 #else
15742 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15743 #endif
15744 }
15745 return pyobj;
15746 }
15747
15748
15749 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15750 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15751 return 1;
15752 }
15753
15754
15755 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15756 PyObject *pyobj;
15757
15758 {
15759 #if wxUSE_UNICODE
15760 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15761 #else
15762 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15763 #endif
15764 }
15765 return pyobj;
15766 }
15767
15768
15769 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15770 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15771 return 1;
15772 }
15773
15774
15775 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15776 PyObject *pyobj;
15777
15778 {
15779 #if wxUSE_UNICODE
15780 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15781 #else
15782 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15783 #endif
15784 }
15785 return pyobj;
15786 }
15787
15788
15789 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15790 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15791 return 1;
15792 }
15793
15794
15795 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15796 PyObject *pyobj;
15797
15798 {
15799 #if wxUSE_UNICODE
15800 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15801 #else
15802 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15803 #endif
15804 }
15805 return pyobj;
15806 }
15807
15808
15809 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15810 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15811 return 1;
15812 }
15813
15814
15815 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15816 PyObject *pyobj;
15817
15818 {
15819 #if wxUSE_UNICODE
15820 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15821 #else
15822 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15823 #endif
15824 }
15825 return pyobj;
15826 }
15827
15828
15829 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15830 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15831 return 1;
15832 }
15833
15834
15835 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15836 PyObject *pyobj;
15837
15838 {
15839 #if wxUSE_UNICODE
15840 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15841 #else
15842 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15843 #endif
15844 }
15845 return pyobj;
15846 }
15847
15848
15849 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15850 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15851 return 1;
15852 }
15853
15854
15855 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15856 PyObject *pyobj;
15857
15858 {
15859 #if wxUSE_UNICODE
15860 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15861 #else
15862 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15863 #endif
15864 }
15865 return pyobj;
15866 }
15867
15868
15869 static int _wrap_ART_GO_BACK_set(PyObject *) {
15870 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15871 return 1;
15872 }
15873
15874
15875 static PyObject *_wrap_ART_GO_BACK_get(void) {
15876 PyObject *pyobj;
15877
15878 {
15879 #if wxUSE_UNICODE
15880 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15881 #else
15882 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15883 #endif
15884 }
15885 return pyobj;
15886 }
15887
15888
15889 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15890 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15891 return 1;
15892 }
15893
15894
15895 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15896 PyObject *pyobj;
15897
15898 {
15899 #if wxUSE_UNICODE
15900 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15901 #else
15902 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15903 #endif
15904 }
15905 return pyobj;
15906 }
15907
15908
15909 static int _wrap_ART_GO_UP_set(PyObject *) {
15910 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15911 return 1;
15912 }
15913
15914
15915 static PyObject *_wrap_ART_GO_UP_get(void) {
15916 PyObject *pyobj;
15917
15918 {
15919 #if wxUSE_UNICODE
15920 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15921 #else
15922 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15923 #endif
15924 }
15925 return pyobj;
15926 }
15927
15928
15929 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15930 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15931 return 1;
15932 }
15933
15934
15935 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15936 PyObject *pyobj;
15937
15938 {
15939 #if wxUSE_UNICODE
15940 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15941 #else
15942 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15943 #endif
15944 }
15945 return pyobj;
15946 }
15947
15948
15949 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15950 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15951 return 1;
15952 }
15953
15954
15955 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15956 PyObject *pyobj;
15957
15958 {
15959 #if wxUSE_UNICODE
15960 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15961 #else
15962 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15963 #endif
15964 }
15965 return pyobj;
15966 }
15967
15968
15969 static int _wrap_ART_GO_HOME_set(PyObject *) {
15970 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15971 return 1;
15972 }
15973
15974
15975 static PyObject *_wrap_ART_GO_HOME_get(void) {
15976 PyObject *pyobj;
15977
15978 {
15979 #if wxUSE_UNICODE
15980 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15981 #else
15982 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15983 #endif
15984 }
15985 return pyobj;
15986 }
15987
15988
15989 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15990 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15991 return 1;
15992 }
15993
15994
15995 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15996 PyObject *pyobj;
15997
15998 {
15999 #if wxUSE_UNICODE
16000 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
16001 #else
16002 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
16003 #endif
16004 }
16005 return pyobj;
16006 }
16007
16008
16009 static int _wrap_ART_PRINT_set(PyObject *) {
16010 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
16011 return 1;
16012 }
16013
16014
16015 static PyObject *_wrap_ART_PRINT_get(void) {
16016 PyObject *pyobj;
16017
16018 {
16019 #if wxUSE_UNICODE
16020 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16021 #else
16022 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16023 #endif
16024 }
16025 return pyobj;
16026 }
16027
16028
16029 static int _wrap_ART_HELP_set(PyObject *) {
16030 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
16031 return 1;
16032 }
16033
16034
16035 static PyObject *_wrap_ART_HELP_get(void) {
16036 PyObject *pyobj;
16037
16038 {
16039 #if wxUSE_UNICODE
16040 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16041 #else
16042 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16043 #endif
16044 }
16045 return pyobj;
16046 }
16047
16048
16049 static int _wrap_ART_TIP_set(PyObject *) {
16050 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
16051 return 1;
16052 }
16053
16054
16055 static PyObject *_wrap_ART_TIP_get(void) {
16056 PyObject *pyobj;
16057
16058 {
16059 #if wxUSE_UNICODE
16060 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16061 #else
16062 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16063 #endif
16064 }
16065 return pyobj;
16066 }
16067
16068
16069 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16070 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16071 return 1;
16072 }
16073
16074
16075 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16076 PyObject *pyobj;
16077
16078 {
16079 #if wxUSE_UNICODE
16080 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16081 #else
16082 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16083 #endif
16084 }
16085 return pyobj;
16086 }
16087
16088
16089 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16090 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16091 return 1;
16092 }
16093
16094
16095 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16096 PyObject *pyobj;
16097
16098 {
16099 #if wxUSE_UNICODE
16100 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16101 #else
16102 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16103 #endif
16104 }
16105 return pyobj;
16106 }
16107
16108
16109 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16110 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16111 return 1;
16112 }
16113
16114
16115 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16116 PyObject *pyobj;
16117
16118 {
16119 #if wxUSE_UNICODE
16120 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16121 #else
16122 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16123 #endif
16124 }
16125 return pyobj;
16126 }
16127
16128
16129 static int _wrap_ART_HARDDISK_set(PyObject *) {
16130 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16131 return 1;
16132 }
16133
16134
16135 static PyObject *_wrap_ART_HARDDISK_get(void) {
16136 PyObject *pyobj;
16137
16138 {
16139 #if wxUSE_UNICODE
16140 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16141 #else
16142 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16143 #endif
16144 }
16145 return pyobj;
16146 }
16147
16148
16149 static int _wrap_ART_FLOPPY_set(PyObject *) {
16150 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16151 return 1;
16152 }
16153
16154
16155 static PyObject *_wrap_ART_FLOPPY_get(void) {
16156 PyObject *pyobj;
16157
16158 {
16159 #if wxUSE_UNICODE
16160 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16161 #else
16162 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16163 #endif
16164 }
16165 return pyobj;
16166 }
16167
16168
16169 static int _wrap_ART_CDROM_set(PyObject *) {
16170 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16171 return 1;
16172 }
16173
16174
16175 static PyObject *_wrap_ART_CDROM_get(void) {
16176 PyObject *pyobj;
16177
16178 {
16179 #if wxUSE_UNICODE
16180 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16181 #else
16182 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16183 #endif
16184 }
16185 return pyobj;
16186 }
16187
16188
16189 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16190 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16191 return 1;
16192 }
16193
16194
16195 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16196 PyObject *pyobj;
16197
16198 {
16199 #if wxUSE_UNICODE
16200 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16201 #else
16202 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16203 #endif
16204 }
16205 return pyobj;
16206 }
16207
16208
16209 static int _wrap_ART_FOLDER_set(PyObject *) {
16210 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16211 return 1;
16212 }
16213
16214
16215 static PyObject *_wrap_ART_FOLDER_get(void) {
16216 PyObject *pyobj;
16217
16218 {
16219 #if wxUSE_UNICODE
16220 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16221 #else
16222 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16223 #endif
16224 }
16225 return pyobj;
16226 }
16227
16228
16229 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16230 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16231 return 1;
16232 }
16233
16234
16235 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16236 PyObject *pyobj;
16237
16238 {
16239 #if wxUSE_UNICODE
16240 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16241 #else
16242 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16243 #endif
16244 }
16245 return pyobj;
16246 }
16247
16248
16249 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16250 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16251 return 1;
16252 }
16253
16254
16255 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16256 PyObject *pyobj;
16257
16258 {
16259 #if wxUSE_UNICODE
16260 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16261 #else
16262 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16263 #endif
16264 }
16265 return pyobj;
16266 }
16267
16268
16269 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16270 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16271 return 1;
16272 }
16273
16274
16275 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16276 PyObject *pyobj;
16277
16278 {
16279 #if wxUSE_UNICODE
16280 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16281 #else
16282 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16283 #endif
16284 }
16285 return pyobj;
16286 }
16287
16288
16289 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16290 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16291 return 1;
16292 }
16293
16294
16295 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16296 PyObject *pyobj;
16297
16298 {
16299 #if wxUSE_UNICODE
16300 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16301 #else
16302 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16303 #endif
16304 }
16305 return pyobj;
16306 }
16307
16308
16309 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16310 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16311 return 1;
16312 }
16313
16314
16315 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16316 PyObject *pyobj;
16317
16318 {
16319 #if wxUSE_UNICODE
16320 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16321 #else
16322 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16323 #endif
16324 }
16325 return pyobj;
16326 }
16327
16328
16329 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16330 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16331 return 1;
16332 }
16333
16334
16335 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16336 PyObject *pyobj;
16337
16338 {
16339 #if wxUSE_UNICODE
16340 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16341 #else
16342 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16343 #endif
16344 }
16345 return pyobj;
16346 }
16347
16348
16349 static int _wrap_ART_ERROR_set(PyObject *) {
16350 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16351 return 1;
16352 }
16353
16354
16355 static PyObject *_wrap_ART_ERROR_get(void) {
16356 PyObject *pyobj;
16357
16358 {
16359 #if wxUSE_UNICODE
16360 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16361 #else
16362 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16363 #endif
16364 }
16365 return pyobj;
16366 }
16367
16368
16369 static int _wrap_ART_QUESTION_set(PyObject *) {
16370 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16371 return 1;
16372 }
16373
16374
16375 static PyObject *_wrap_ART_QUESTION_get(void) {
16376 PyObject *pyobj;
16377
16378 {
16379 #if wxUSE_UNICODE
16380 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16381 #else
16382 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16383 #endif
16384 }
16385 return pyobj;
16386 }
16387
16388
16389 static int _wrap_ART_WARNING_set(PyObject *) {
16390 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16391 return 1;
16392 }
16393
16394
16395 static PyObject *_wrap_ART_WARNING_get(void) {
16396 PyObject *pyobj;
16397
16398 {
16399 #if wxUSE_UNICODE
16400 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16401 #else
16402 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16403 #endif
16404 }
16405 return pyobj;
16406 }
16407
16408
16409 static int _wrap_ART_INFORMATION_set(PyObject *) {
16410 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16411 return 1;
16412 }
16413
16414
16415 static PyObject *_wrap_ART_INFORMATION_get(void) {
16416 PyObject *pyobj;
16417
16418 {
16419 #if wxUSE_UNICODE
16420 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16421 #else
16422 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16423 #endif
16424 }
16425 return pyobj;
16426 }
16427
16428
16429 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16430 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16431 return 1;
16432 }
16433
16434
16435 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16436 PyObject *pyobj;
16437
16438 {
16439 #if wxUSE_UNICODE
16440 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16441 #else
16442 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16443 #endif
16444 }
16445 return pyobj;
16446 }
16447
16448
16449 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16450 PyObject *resultobj;
16451 wxPyArtProvider *result;
16452 char *kwnames[] = {
16453 NULL
16454 };
16455
16456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16457 {
16458 if (!wxPyCheckForApp()) SWIG_fail;
16459 PyThreadState* __tstate = wxPyBeginAllowThreads();
16460 result = (wxPyArtProvider *)new wxPyArtProvider();
16461
16462 wxPyEndAllowThreads(__tstate);
16463 if (PyErr_Occurred()) SWIG_fail;
16464 }
16465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16466 return resultobj;
16467 fail:
16468 return NULL;
16469 }
16470
16471
16472 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16473 PyObject *resultobj;
16474 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16475 PyObject *arg2 = (PyObject *) 0 ;
16476 PyObject *arg3 = (PyObject *) 0 ;
16477 PyObject * obj0 = 0 ;
16478 PyObject * obj1 = 0 ;
16479 PyObject * obj2 = 0 ;
16480 char *kwnames[] = {
16481 (char *) "self",(char *) "self",(char *) "_class", NULL
16482 };
16483
16484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16486 if (SWIG_arg_fail(1)) SWIG_fail;
16487 arg2 = obj1;
16488 arg3 = obj2;
16489 {
16490 PyThreadState* __tstate = wxPyBeginAllowThreads();
16491 (arg1)->_setCallbackInfo(arg2,arg3);
16492
16493 wxPyEndAllowThreads(__tstate);
16494 if (PyErr_Occurred()) SWIG_fail;
16495 }
16496 Py_INCREF(Py_None); resultobj = Py_None;
16497 return resultobj;
16498 fail:
16499 return NULL;
16500 }
16501
16502
16503 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16504 PyObject *resultobj;
16505 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16506 PyObject * obj0 = 0 ;
16507 char *kwnames[] = {
16508 (char *) "provider", NULL
16509 };
16510
16511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16513 if (SWIG_arg_fail(1)) SWIG_fail;
16514 {
16515 PyThreadState* __tstate = wxPyBeginAllowThreads();
16516 wxPyArtProvider::PushProvider(arg1);
16517
16518 wxPyEndAllowThreads(__tstate);
16519 if (PyErr_Occurred()) SWIG_fail;
16520 }
16521 Py_INCREF(Py_None); resultobj = Py_None;
16522 return resultobj;
16523 fail:
16524 return NULL;
16525 }
16526
16527
16528 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16529 PyObject *resultobj;
16530 bool result;
16531 char *kwnames[] = {
16532 NULL
16533 };
16534
16535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16536 {
16537 PyThreadState* __tstate = wxPyBeginAllowThreads();
16538 result = (bool)wxPyArtProvider::PopProvider();
16539
16540 wxPyEndAllowThreads(__tstate);
16541 if (PyErr_Occurred()) SWIG_fail;
16542 }
16543 {
16544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16545 }
16546 return resultobj;
16547 fail:
16548 return NULL;
16549 }
16550
16551
16552 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16553 PyObject *resultobj;
16554 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16555 bool result;
16556 PyObject * obj0 = 0 ;
16557 char *kwnames[] = {
16558 (char *) "provider", NULL
16559 };
16560
16561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16563 if (SWIG_arg_fail(1)) SWIG_fail;
16564 {
16565 PyThreadState* __tstate = wxPyBeginAllowThreads();
16566 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16567
16568 wxPyEndAllowThreads(__tstate);
16569 if (PyErr_Occurred()) SWIG_fail;
16570 }
16571 {
16572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16573 }
16574 return resultobj;
16575 fail:
16576 return NULL;
16577 }
16578
16579
16580 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16581 PyObject *resultobj;
16582 wxString *arg1 = 0 ;
16583 wxString const &arg2_defvalue = wxPyART_OTHER ;
16584 wxString *arg2 = (wxString *) &arg2_defvalue ;
16585 wxSize const &arg3_defvalue = wxDefaultSize ;
16586 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16587 wxBitmap result;
16588 bool temp1 = false ;
16589 bool temp2 = false ;
16590 wxSize temp3 ;
16591 PyObject * obj0 = 0 ;
16592 PyObject * obj1 = 0 ;
16593 PyObject * obj2 = 0 ;
16594 char *kwnames[] = {
16595 (char *) "id",(char *) "client",(char *) "size", NULL
16596 };
16597
16598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16599 {
16600 arg1 = wxString_in_helper(obj0);
16601 if (arg1 == NULL) SWIG_fail;
16602 temp1 = true;
16603 }
16604 if (obj1) {
16605 {
16606 arg2 = wxString_in_helper(obj1);
16607 if (arg2 == NULL) SWIG_fail;
16608 temp2 = true;
16609 }
16610 }
16611 if (obj2) {
16612 {
16613 arg3 = &temp3;
16614 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16615 }
16616 }
16617 {
16618 if (!wxPyCheckForApp()) SWIG_fail;
16619 PyThreadState* __tstate = wxPyBeginAllowThreads();
16620 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16621
16622 wxPyEndAllowThreads(__tstate);
16623 if (PyErr_Occurred()) SWIG_fail;
16624 }
16625 {
16626 wxBitmap * resultptr;
16627 resultptr = new wxBitmap((wxBitmap &)(result));
16628 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16629 }
16630 {
16631 if (temp1)
16632 delete arg1;
16633 }
16634 {
16635 if (temp2)
16636 delete arg2;
16637 }
16638 return resultobj;
16639 fail:
16640 {
16641 if (temp1)
16642 delete arg1;
16643 }
16644 {
16645 if (temp2)
16646 delete arg2;
16647 }
16648 return NULL;
16649 }
16650
16651
16652 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16653 PyObject *resultobj;
16654 wxString *arg1 = 0 ;
16655 wxString const &arg2_defvalue = wxPyART_OTHER ;
16656 wxString *arg2 = (wxString *) &arg2_defvalue ;
16657 wxSize const &arg3_defvalue = wxDefaultSize ;
16658 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16659 wxIcon result;
16660 bool temp1 = false ;
16661 bool temp2 = false ;
16662 wxSize temp3 ;
16663 PyObject * obj0 = 0 ;
16664 PyObject * obj1 = 0 ;
16665 PyObject * obj2 = 0 ;
16666 char *kwnames[] = {
16667 (char *) "id",(char *) "client",(char *) "size", NULL
16668 };
16669
16670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16671 {
16672 arg1 = wxString_in_helper(obj0);
16673 if (arg1 == NULL) SWIG_fail;
16674 temp1 = true;
16675 }
16676 if (obj1) {
16677 {
16678 arg2 = wxString_in_helper(obj1);
16679 if (arg2 == NULL) SWIG_fail;
16680 temp2 = true;
16681 }
16682 }
16683 if (obj2) {
16684 {
16685 arg3 = &temp3;
16686 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16687 }
16688 }
16689 {
16690 if (!wxPyCheckForApp()) SWIG_fail;
16691 PyThreadState* __tstate = wxPyBeginAllowThreads();
16692 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16693
16694 wxPyEndAllowThreads(__tstate);
16695 if (PyErr_Occurred()) SWIG_fail;
16696 }
16697 {
16698 wxIcon * resultptr;
16699 resultptr = new wxIcon((wxIcon &)(result));
16700 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16701 }
16702 {
16703 if (temp1)
16704 delete arg1;
16705 }
16706 {
16707 if (temp2)
16708 delete arg2;
16709 }
16710 return resultobj;
16711 fail:
16712 {
16713 if (temp1)
16714 delete arg1;
16715 }
16716 {
16717 if (temp2)
16718 delete arg2;
16719 }
16720 return NULL;
16721 }
16722
16723
16724 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16725 PyObject *resultobj;
16726 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16727 PyObject * obj0 = 0 ;
16728 char *kwnames[] = {
16729 (char *) "self", NULL
16730 };
16731
16732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16734 if (SWIG_arg_fail(1)) SWIG_fail;
16735 {
16736 PyThreadState* __tstate = wxPyBeginAllowThreads();
16737 wxPyArtProvider_Destroy(arg1);
16738
16739 wxPyEndAllowThreads(__tstate);
16740 if (PyErr_Occurred()) SWIG_fail;
16741 }
16742 Py_INCREF(Py_None); resultobj = Py_None;
16743 return resultobj;
16744 fail:
16745 return NULL;
16746 }
16747
16748
16749 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16750 PyObject *obj;
16751 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16752 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16753 Py_INCREF(obj);
16754 return Py_BuildValue((char *)"");
16755 }
16756 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16757 PyObject *resultobj;
16758 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16759 PyObject * obj0 = 0 ;
16760 char *kwnames[] = {
16761 (char *) "self", NULL
16762 };
16763
16764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16766 if (SWIG_arg_fail(1)) SWIG_fail;
16767 {
16768 PyThreadState* __tstate = wxPyBeginAllowThreads();
16769 delete arg1;
16770
16771 wxPyEndAllowThreads(__tstate);
16772 if (PyErr_Occurred()) SWIG_fail;
16773 }
16774 Py_INCREF(Py_None); resultobj = Py_None;
16775 return resultobj;
16776 fail:
16777 return NULL;
16778 }
16779
16780
16781 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16782 PyObject *resultobj;
16783 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16784 wxConfigBase *result;
16785 PyObject * obj0 = 0 ;
16786 char *kwnames[] = {
16787 (char *) "config", NULL
16788 };
16789
16790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16792 if (SWIG_arg_fail(1)) SWIG_fail;
16793 {
16794 PyThreadState* __tstate = wxPyBeginAllowThreads();
16795 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16796
16797 wxPyEndAllowThreads(__tstate);
16798 if (PyErr_Occurred()) SWIG_fail;
16799 }
16800 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16801 return resultobj;
16802 fail:
16803 return NULL;
16804 }
16805
16806
16807 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16808 PyObject *resultobj;
16809 bool arg1 = (bool) true ;
16810 wxConfigBase *result;
16811 PyObject * obj0 = 0 ;
16812 char *kwnames[] = {
16813 (char *) "createOnDemand", NULL
16814 };
16815
16816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16817 if (obj0) {
16818 {
16819 arg1 = (bool)(SWIG_As_bool(obj0));
16820 if (SWIG_arg_fail(1)) SWIG_fail;
16821 }
16822 }
16823 {
16824 PyThreadState* __tstate = wxPyBeginAllowThreads();
16825 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16826
16827 wxPyEndAllowThreads(__tstate);
16828 if (PyErr_Occurred()) SWIG_fail;
16829 }
16830 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16831 return resultobj;
16832 fail:
16833 return NULL;
16834 }
16835
16836
16837 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16838 PyObject *resultobj;
16839 wxConfigBase *result;
16840 char *kwnames[] = {
16841 NULL
16842 };
16843
16844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16845 {
16846 PyThreadState* __tstate = wxPyBeginAllowThreads();
16847 result = (wxConfigBase *)wxConfigBase::Create();
16848
16849 wxPyEndAllowThreads(__tstate);
16850 if (PyErr_Occurred()) SWIG_fail;
16851 }
16852 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16853 return resultobj;
16854 fail:
16855 return NULL;
16856 }
16857
16858
16859 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16860 PyObject *resultobj;
16861 char *kwnames[] = {
16862 NULL
16863 };
16864
16865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16866 {
16867 PyThreadState* __tstate = wxPyBeginAllowThreads();
16868 wxConfigBase::DontCreateOnDemand();
16869
16870 wxPyEndAllowThreads(__tstate);
16871 if (PyErr_Occurred()) SWIG_fail;
16872 }
16873 Py_INCREF(Py_None); resultobj = Py_None;
16874 return resultobj;
16875 fail:
16876 return NULL;
16877 }
16878
16879
16880 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16881 PyObject *resultobj;
16882 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16883 wxString *arg2 = 0 ;
16884 bool temp2 = false ;
16885 PyObject * obj0 = 0 ;
16886 PyObject * obj1 = 0 ;
16887 char *kwnames[] = {
16888 (char *) "self",(char *) "path", NULL
16889 };
16890
16891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16893 if (SWIG_arg_fail(1)) SWIG_fail;
16894 {
16895 arg2 = wxString_in_helper(obj1);
16896 if (arg2 == NULL) SWIG_fail;
16897 temp2 = true;
16898 }
16899 {
16900 PyThreadState* __tstate = wxPyBeginAllowThreads();
16901 (arg1)->SetPath((wxString const &)*arg2);
16902
16903 wxPyEndAllowThreads(__tstate);
16904 if (PyErr_Occurred()) SWIG_fail;
16905 }
16906 Py_INCREF(Py_None); resultobj = Py_None;
16907 {
16908 if (temp2)
16909 delete arg2;
16910 }
16911 return resultobj;
16912 fail:
16913 {
16914 if (temp2)
16915 delete arg2;
16916 }
16917 return NULL;
16918 }
16919
16920
16921 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16922 PyObject *resultobj;
16923 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16924 wxString *result;
16925 PyObject * obj0 = 0 ;
16926 char *kwnames[] = {
16927 (char *) "self", NULL
16928 };
16929
16930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16932 if (SWIG_arg_fail(1)) SWIG_fail;
16933 {
16934 PyThreadState* __tstate = wxPyBeginAllowThreads();
16935 {
16936 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16937 result = (wxString *) &_result_ref;
16938 }
16939
16940 wxPyEndAllowThreads(__tstate);
16941 if (PyErr_Occurred()) SWIG_fail;
16942 }
16943 {
16944 #if wxUSE_UNICODE
16945 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16946 #else
16947 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16948 #endif
16949 }
16950 return resultobj;
16951 fail:
16952 return NULL;
16953 }
16954
16955
16956 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16957 PyObject *resultobj;
16958 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16959 PyObject *result;
16960 PyObject * obj0 = 0 ;
16961 char *kwnames[] = {
16962 (char *) "self", NULL
16963 };
16964
16965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16967 if (SWIG_arg_fail(1)) SWIG_fail;
16968 {
16969 PyThreadState* __tstate = wxPyBeginAllowThreads();
16970 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16971
16972 wxPyEndAllowThreads(__tstate);
16973 if (PyErr_Occurred()) SWIG_fail;
16974 }
16975 resultobj = result;
16976 return resultobj;
16977 fail:
16978 return NULL;
16979 }
16980
16981
16982 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16983 PyObject *resultobj;
16984 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16985 long arg2 ;
16986 PyObject *result;
16987 PyObject * obj0 = 0 ;
16988 PyObject * obj1 = 0 ;
16989 char *kwnames[] = {
16990 (char *) "self",(char *) "index", NULL
16991 };
16992
16993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
16994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16995 if (SWIG_arg_fail(1)) SWIG_fail;
16996 {
16997 arg2 = (long)(SWIG_As_long(obj1));
16998 if (SWIG_arg_fail(2)) SWIG_fail;
16999 }
17000 {
17001 PyThreadState* __tstate = wxPyBeginAllowThreads();
17002 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17003
17004 wxPyEndAllowThreads(__tstate);
17005 if (PyErr_Occurred()) SWIG_fail;
17006 }
17007 resultobj = result;
17008 return resultobj;
17009 fail:
17010 return NULL;
17011 }
17012
17013
17014 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17015 PyObject *resultobj;
17016 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17017 PyObject *result;
17018 PyObject * obj0 = 0 ;
17019 char *kwnames[] = {
17020 (char *) "self", NULL
17021 };
17022
17023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
17028 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17029
17030 wxPyEndAllowThreads(__tstate);
17031 if (PyErr_Occurred()) SWIG_fail;
17032 }
17033 resultobj = result;
17034 return resultobj;
17035 fail:
17036 return NULL;
17037 }
17038
17039
17040 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17041 PyObject *resultobj;
17042 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17043 long arg2 ;
17044 PyObject *result;
17045 PyObject * obj0 = 0 ;
17046 PyObject * obj1 = 0 ;
17047 char *kwnames[] = {
17048 (char *) "self",(char *) "index", NULL
17049 };
17050
17051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17053 if (SWIG_arg_fail(1)) SWIG_fail;
17054 {
17055 arg2 = (long)(SWIG_As_long(obj1));
17056 if (SWIG_arg_fail(2)) SWIG_fail;
17057 }
17058 {
17059 PyThreadState* __tstate = wxPyBeginAllowThreads();
17060 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17061
17062 wxPyEndAllowThreads(__tstate);
17063 if (PyErr_Occurred()) SWIG_fail;
17064 }
17065 resultobj = result;
17066 return resultobj;
17067 fail:
17068 return NULL;
17069 }
17070
17071
17072 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17073 PyObject *resultobj;
17074 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17075 bool arg2 = (bool) false ;
17076 size_t result;
17077 PyObject * obj0 = 0 ;
17078 PyObject * obj1 = 0 ;
17079 char *kwnames[] = {
17080 (char *) "self",(char *) "recursive", NULL
17081 };
17082
17083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17085 if (SWIG_arg_fail(1)) SWIG_fail;
17086 if (obj1) {
17087 {
17088 arg2 = (bool)(SWIG_As_bool(obj1));
17089 if (SWIG_arg_fail(2)) SWIG_fail;
17090 }
17091 }
17092 {
17093 PyThreadState* __tstate = wxPyBeginAllowThreads();
17094 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17095
17096 wxPyEndAllowThreads(__tstate);
17097 if (PyErr_Occurred()) SWIG_fail;
17098 }
17099 {
17100 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17101 }
17102 return resultobj;
17103 fail:
17104 return NULL;
17105 }
17106
17107
17108 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17109 PyObject *resultobj;
17110 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17111 bool arg2 = (bool) false ;
17112 size_t result;
17113 PyObject * obj0 = 0 ;
17114 PyObject * obj1 = 0 ;
17115 char *kwnames[] = {
17116 (char *) "self",(char *) "recursive", NULL
17117 };
17118
17119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17121 if (SWIG_arg_fail(1)) SWIG_fail;
17122 if (obj1) {
17123 {
17124 arg2 = (bool)(SWIG_As_bool(obj1));
17125 if (SWIG_arg_fail(2)) SWIG_fail;
17126 }
17127 }
17128 {
17129 PyThreadState* __tstate = wxPyBeginAllowThreads();
17130 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17131
17132 wxPyEndAllowThreads(__tstate);
17133 if (PyErr_Occurred()) SWIG_fail;
17134 }
17135 {
17136 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17137 }
17138 return resultobj;
17139 fail:
17140 return NULL;
17141 }
17142
17143
17144 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17145 PyObject *resultobj;
17146 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17147 wxString *arg2 = 0 ;
17148 bool result;
17149 bool temp2 = false ;
17150 PyObject * obj0 = 0 ;
17151 PyObject * obj1 = 0 ;
17152 char *kwnames[] = {
17153 (char *) "self",(char *) "name", NULL
17154 };
17155
17156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17158 if (SWIG_arg_fail(1)) SWIG_fail;
17159 {
17160 arg2 = wxString_in_helper(obj1);
17161 if (arg2 == NULL) SWIG_fail;
17162 temp2 = true;
17163 }
17164 {
17165 PyThreadState* __tstate = wxPyBeginAllowThreads();
17166 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17167
17168 wxPyEndAllowThreads(__tstate);
17169 if (PyErr_Occurred()) SWIG_fail;
17170 }
17171 {
17172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17173 }
17174 {
17175 if (temp2)
17176 delete arg2;
17177 }
17178 return resultobj;
17179 fail:
17180 {
17181 if (temp2)
17182 delete arg2;
17183 }
17184 return NULL;
17185 }
17186
17187
17188 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17189 PyObject *resultobj;
17190 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17191 wxString *arg2 = 0 ;
17192 bool result;
17193 bool temp2 = false ;
17194 PyObject * obj0 = 0 ;
17195 PyObject * obj1 = 0 ;
17196 char *kwnames[] = {
17197 (char *) "self",(char *) "name", NULL
17198 };
17199
17200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17202 if (SWIG_arg_fail(1)) SWIG_fail;
17203 {
17204 arg2 = wxString_in_helper(obj1);
17205 if (arg2 == NULL) SWIG_fail;
17206 temp2 = true;
17207 }
17208 {
17209 PyThreadState* __tstate = wxPyBeginAllowThreads();
17210 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17211
17212 wxPyEndAllowThreads(__tstate);
17213 if (PyErr_Occurred()) SWIG_fail;
17214 }
17215 {
17216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17217 }
17218 {
17219 if (temp2)
17220 delete arg2;
17221 }
17222 return resultobj;
17223 fail:
17224 {
17225 if (temp2)
17226 delete arg2;
17227 }
17228 return NULL;
17229 }
17230
17231
17232 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17233 PyObject *resultobj;
17234 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17235 wxString *arg2 = 0 ;
17236 bool result;
17237 bool temp2 = false ;
17238 PyObject * obj0 = 0 ;
17239 PyObject * obj1 = 0 ;
17240 char *kwnames[] = {
17241 (char *) "self",(char *) "name", NULL
17242 };
17243
17244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17246 if (SWIG_arg_fail(1)) SWIG_fail;
17247 {
17248 arg2 = wxString_in_helper(obj1);
17249 if (arg2 == NULL) SWIG_fail;
17250 temp2 = true;
17251 }
17252 {
17253 PyThreadState* __tstate = wxPyBeginAllowThreads();
17254 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17255
17256 wxPyEndAllowThreads(__tstate);
17257 if (PyErr_Occurred()) SWIG_fail;
17258 }
17259 {
17260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17261 }
17262 {
17263 if (temp2)
17264 delete arg2;
17265 }
17266 return resultobj;
17267 fail:
17268 {
17269 if (temp2)
17270 delete arg2;
17271 }
17272 return NULL;
17273 }
17274
17275
17276 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17277 PyObject *resultobj;
17278 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17279 wxString *arg2 = 0 ;
17280 wxConfigBase::EntryType result;
17281 bool temp2 = false ;
17282 PyObject * obj0 = 0 ;
17283 PyObject * obj1 = 0 ;
17284 char *kwnames[] = {
17285 (char *) "self",(char *) "name", NULL
17286 };
17287
17288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17290 if (SWIG_arg_fail(1)) SWIG_fail;
17291 {
17292 arg2 = wxString_in_helper(obj1);
17293 if (arg2 == NULL) SWIG_fail;
17294 temp2 = true;
17295 }
17296 {
17297 PyThreadState* __tstate = wxPyBeginAllowThreads();
17298 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17299
17300 wxPyEndAllowThreads(__tstate);
17301 if (PyErr_Occurred()) SWIG_fail;
17302 }
17303 resultobj = SWIG_From_int((result));
17304 {
17305 if (temp2)
17306 delete arg2;
17307 }
17308 return resultobj;
17309 fail:
17310 {
17311 if (temp2)
17312 delete arg2;
17313 }
17314 return NULL;
17315 }
17316
17317
17318 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17319 PyObject *resultobj;
17320 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17321 wxString *arg2 = 0 ;
17322 wxString const &arg3_defvalue = wxPyEmptyString ;
17323 wxString *arg3 = (wxString *) &arg3_defvalue ;
17324 wxString result;
17325 bool temp2 = false ;
17326 bool temp3 = false ;
17327 PyObject * obj0 = 0 ;
17328 PyObject * obj1 = 0 ;
17329 PyObject * obj2 = 0 ;
17330 char *kwnames[] = {
17331 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17332 };
17333
17334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17336 if (SWIG_arg_fail(1)) SWIG_fail;
17337 {
17338 arg2 = wxString_in_helper(obj1);
17339 if (arg2 == NULL) SWIG_fail;
17340 temp2 = true;
17341 }
17342 if (obj2) {
17343 {
17344 arg3 = wxString_in_helper(obj2);
17345 if (arg3 == NULL) SWIG_fail;
17346 temp3 = true;
17347 }
17348 }
17349 {
17350 PyThreadState* __tstate = wxPyBeginAllowThreads();
17351 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17352
17353 wxPyEndAllowThreads(__tstate);
17354 if (PyErr_Occurred()) SWIG_fail;
17355 }
17356 {
17357 #if wxUSE_UNICODE
17358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17359 #else
17360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17361 #endif
17362 }
17363 {
17364 if (temp2)
17365 delete arg2;
17366 }
17367 {
17368 if (temp3)
17369 delete arg3;
17370 }
17371 return resultobj;
17372 fail:
17373 {
17374 if (temp2)
17375 delete arg2;
17376 }
17377 {
17378 if (temp3)
17379 delete arg3;
17380 }
17381 return NULL;
17382 }
17383
17384
17385 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17386 PyObject *resultobj;
17387 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17388 wxString *arg2 = 0 ;
17389 long arg3 = (long) 0 ;
17390 long result;
17391 bool temp2 = false ;
17392 PyObject * obj0 = 0 ;
17393 PyObject * obj1 = 0 ;
17394 PyObject * obj2 = 0 ;
17395 char *kwnames[] = {
17396 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17397 };
17398
17399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17401 if (SWIG_arg_fail(1)) SWIG_fail;
17402 {
17403 arg2 = wxString_in_helper(obj1);
17404 if (arg2 == NULL) SWIG_fail;
17405 temp2 = true;
17406 }
17407 if (obj2) {
17408 {
17409 arg3 = (long)(SWIG_As_long(obj2));
17410 if (SWIG_arg_fail(3)) SWIG_fail;
17411 }
17412 }
17413 {
17414 PyThreadState* __tstate = wxPyBeginAllowThreads();
17415 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17416
17417 wxPyEndAllowThreads(__tstate);
17418 if (PyErr_Occurred()) SWIG_fail;
17419 }
17420 {
17421 resultobj = SWIG_From_long((long)(result));
17422 }
17423 {
17424 if (temp2)
17425 delete arg2;
17426 }
17427 return resultobj;
17428 fail:
17429 {
17430 if (temp2)
17431 delete arg2;
17432 }
17433 return NULL;
17434 }
17435
17436
17437 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17438 PyObject *resultobj;
17439 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17440 wxString *arg2 = 0 ;
17441 double arg3 = (double) 0.0 ;
17442 double result;
17443 bool temp2 = false ;
17444 PyObject * obj0 = 0 ;
17445 PyObject * obj1 = 0 ;
17446 PyObject * obj2 = 0 ;
17447 char *kwnames[] = {
17448 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17449 };
17450
17451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17453 if (SWIG_arg_fail(1)) SWIG_fail;
17454 {
17455 arg2 = wxString_in_helper(obj1);
17456 if (arg2 == NULL) SWIG_fail;
17457 temp2 = true;
17458 }
17459 if (obj2) {
17460 {
17461 arg3 = (double)(SWIG_As_double(obj2));
17462 if (SWIG_arg_fail(3)) SWIG_fail;
17463 }
17464 }
17465 {
17466 PyThreadState* __tstate = wxPyBeginAllowThreads();
17467 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17468
17469 wxPyEndAllowThreads(__tstate);
17470 if (PyErr_Occurred()) SWIG_fail;
17471 }
17472 {
17473 resultobj = SWIG_From_double((double)(result));
17474 }
17475 {
17476 if (temp2)
17477 delete arg2;
17478 }
17479 return resultobj;
17480 fail:
17481 {
17482 if (temp2)
17483 delete arg2;
17484 }
17485 return NULL;
17486 }
17487
17488
17489 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17490 PyObject *resultobj;
17491 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17492 wxString *arg2 = 0 ;
17493 bool arg3 = (bool) false ;
17494 bool result;
17495 bool temp2 = false ;
17496 PyObject * obj0 = 0 ;
17497 PyObject * obj1 = 0 ;
17498 PyObject * obj2 = 0 ;
17499 char *kwnames[] = {
17500 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17501 };
17502
17503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17505 if (SWIG_arg_fail(1)) SWIG_fail;
17506 {
17507 arg2 = wxString_in_helper(obj1);
17508 if (arg2 == NULL) SWIG_fail;
17509 temp2 = true;
17510 }
17511 if (obj2) {
17512 {
17513 arg3 = (bool)(SWIG_As_bool(obj2));
17514 if (SWIG_arg_fail(3)) SWIG_fail;
17515 }
17516 }
17517 {
17518 PyThreadState* __tstate = wxPyBeginAllowThreads();
17519 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17520
17521 wxPyEndAllowThreads(__tstate);
17522 if (PyErr_Occurred()) SWIG_fail;
17523 }
17524 {
17525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17526 }
17527 {
17528 if (temp2)
17529 delete arg2;
17530 }
17531 return resultobj;
17532 fail:
17533 {
17534 if (temp2)
17535 delete arg2;
17536 }
17537 return NULL;
17538 }
17539
17540
17541 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17542 PyObject *resultobj;
17543 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17544 wxString *arg2 = 0 ;
17545 wxString *arg3 = 0 ;
17546 bool result;
17547 bool temp2 = false ;
17548 bool temp3 = false ;
17549 PyObject * obj0 = 0 ;
17550 PyObject * obj1 = 0 ;
17551 PyObject * obj2 = 0 ;
17552 char *kwnames[] = {
17553 (char *) "self",(char *) "key",(char *) "value", NULL
17554 };
17555
17556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17558 if (SWIG_arg_fail(1)) SWIG_fail;
17559 {
17560 arg2 = wxString_in_helper(obj1);
17561 if (arg2 == NULL) SWIG_fail;
17562 temp2 = true;
17563 }
17564 {
17565 arg3 = wxString_in_helper(obj2);
17566 if (arg3 == NULL) SWIG_fail;
17567 temp3 = true;
17568 }
17569 {
17570 PyThreadState* __tstate = wxPyBeginAllowThreads();
17571 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17572
17573 wxPyEndAllowThreads(__tstate);
17574 if (PyErr_Occurred()) SWIG_fail;
17575 }
17576 {
17577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17578 }
17579 {
17580 if (temp2)
17581 delete arg2;
17582 }
17583 {
17584 if (temp3)
17585 delete arg3;
17586 }
17587 return resultobj;
17588 fail:
17589 {
17590 if (temp2)
17591 delete arg2;
17592 }
17593 {
17594 if (temp3)
17595 delete arg3;
17596 }
17597 return NULL;
17598 }
17599
17600
17601 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17602 PyObject *resultobj;
17603 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17604 wxString *arg2 = 0 ;
17605 long arg3 ;
17606 bool result;
17607 bool temp2 = false ;
17608 PyObject * obj0 = 0 ;
17609 PyObject * obj1 = 0 ;
17610 PyObject * obj2 = 0 ;
17611 char *kwnames[] = {
17612 (char *) "self",(char *) "key",(char *) "value", NULL
17613 };
17614
17615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17617 if (SWIG_arg_fail(1)) SWIG_fail;
17618 {
17619 arg2 = wxString_in_helper(obj1);
17620 if (arg2 == NULL) SWIG_fail;
17621 temp2 = true;
17622 }
17623 {
17624 arg3 = (long)(SWIG_As_long(obj2));
17625 if (SWIG_arg_fail(3)) SWIG_fail;
17626 }
17627 {
17628 PyThreadState* __tstate = wxPyBeginAllowThreads();
17629 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17630
17631 wxPyEndAllowThreads(__tstate);
17632 if (PyErr_Occurred()) SWIG_fail;
17633 }
17634 {
17635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17636 }
17637 {
17638 if (temp2)
17639 delete arg2;
17640 }
17641 return resultobj;
17642 fail:
17643 {
17644 if (temp2)
17645 delete arg2;
17646 }
17647 return NULL;
17648 }
17649
17650
17651 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17652 PyObject *resultobj;
17653 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17654 wxString *arg2 = 0 ;
17655 double arg3 ;
17656 bool result;
17657 bool temp2 = false ;
17658 PyObject * obj0 = 0 ;
17659 PyObject * obj1 = 0 ;
17660 PyObject * obj2 = 0 ;
17661 char *kwnames[] = {
17662 (char *) "self",(char *) "key",(char *) "value", NULL
17663 };
17664
17665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17667 if (SWIG_arg_fail(1)) SWIG_fail;
17668 {
17669 arg2 = wxString_in_helper(obj1);
17670 if (arg2 == NULL) SWIG_fail;
17671 temp2 = true;
17672 }
17673 {
17674 arg3 = (double)(SWIG_As_double(obj2));
17675 if (SWIG_arg_fail(3)) SWIG_fail;
17676 }
17677 {
17678 PyThreadState* __tstate = wxPyBeginAllowThreads();
17679 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17680
17681 wxPyEndAllowThreads(__tstate);
17682 if (PyErr_Occurred()) SWIG_fail;
17683 }
17684 {
17685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17686 }
17687 {
17688 if (temp2)
17689 delete arg2;
17690 }
17691 return resultobj;
17692 fail:
17693 {
17694 if (temp2)
17695 delete arg2;
17696 }
17697 return NULL;
17698 }
17699
17700
17701 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17702 PyObject *resultobj;
17703 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17704 wxString *arg2 = 0 ;
17705 bool arg3 ;
17706 bool result;
17707 bool temp2 = false ;
17708 PyObject * obj0 = 0 ;
17709 PyObject * obj1 = 0 ;
17710 PyObject * obj2 = 0 ;
17711 char *kwnames[] = {
17712 (char *) "self",(char *) "key",(char *) "value", NULL
17713 };
17714
17715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17717 if (SWIG_arg_fail(1)) SWIG_fail;
17718 {
17719 arg2 = wxString_in_helper(obj1);
17720 if (arg2 == NULL) SWIG_fail;
17721 temp2 = true;
17722 }
17723 {
17724 arg3 = (bool)(SWIG_As_bool(obj2));
17725 if (SWIG_arg_fail(3)) SWIG_fail;
17726 }
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17730
17731 wxPyEndAllowThreads(__tstate);
17732 if (PyErr_Occurred()) SWIG_fail;
17733 }
17734 {
17735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17736 }
17737 {
17738 if (temp2)
17739 delete arg2;
17740 }
17741 return resultobj;
17742 fail:
17743 {
17744 if (temp2)
17745 delete arg2;
17746 }
17747 return NULL;
17748 }
17749
17750
17751 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17752 PyObject *resultobj;
17753 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17754 bool arg2 = (bool) false ;
17755 bool result;
17756 PyObject * obj0 = 0 ;
17757 PyObject * obj1 = 0 ;
17758 char *kwnames[] = {
17759 (char *) "self",(char *) "currentOnly", NULL
17760 };
17761
17762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17764 if (SWIG_arg_fail(1)) SWIG_fail;
17765 if (obj1) {
17766 {
17767 arg2 = (bool)(SWIG_As_bool(obj1));
17768 if (SWIG_arg_fail(2)) SWIG_fail;
17769 }
17770 }
17771 {
17772 PyThreadState* __tstate = wxPyBeginAllowThreads();
17773 result = (bool)(arg1)->Flush(arg2);
17774
17775 wxPyEndAllowThreads(__tstate);
17776 if (PyErr_Occurred()) SWIG_fail;
17777 }
17778 {
17779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17780 }
17781 return resultobj;
17782 fail:
17783 return NULL;
17784 }
17785
17786
17787 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17788 PyObject *resultobj;
17789 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17790 wxString *arg2 = 0 ;
17791 wxString *arg3 = 0 ;
17792 bool result;
17793 bool temp2 = false ;
17794 bool temp3 = false ;
17795 PyObject * obj0 = 0 ;
17796 PyObject * obj1 = 0 ;
17797 PyObject * obj2 = 0 ;
17798 char *kwnames[] = {
17799 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17800 };
17801
17802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17804 if (SWIG_arg_fail(1)) SWIG_fail;
17805 {
17806 arg2 = wxString_in_helper(obj1);
17807 if (arg2 == NULL) SWIG_fail;
17808 temp2 = true;
17809 }
17810 {
17811 arg3 = wxString_in_helper(obj2);
17812 if (arg3 == NULL) SWIG_fail;
17813 temp3 = true;
17814 }
17815 {
17816 PyThreadState* __tstate = wxPyBeginAllowThreads();
17817 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17818
17819 wxPyEndAllowThreads(__tstate);
17820 if (PyErr_Occurred()) SWIG_fail;
17821 }
17822 {
17823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17824 }
17825 {
17826 if (temp2)
17827 delete arg2;
17828 }
17829 {
17830 if (temp3)
17831 delete arg3;
17832 }
17833 return resultobj;
17834 fail:
17835 {
17836 if (temp2)
17837 delete arg2;
17838 }
17839 {
17840 if (temp3)
17841 delete arg3;
17842 }
17843 return NULL;
17844 }
17845
17846
17847 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17848 PyObject *resultobj;
17849 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17850 wxString *arg2 = 0 ;
17851 wxString *arg3 = 0 ;
17852 bool result;
17853 bool temp2 = false ;
17854 bool temp3 = false ;
17855 PyObject * obj0 = 0 ;
17856 PyObject * obj1 = 0 ;
17857 PyObject * obj2 = 0 ;
17858 char *kwnames[] = {
17859 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17860 };
17861
17862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17864 if (SWIG_arg_fail(1)) SWIG_fail;
17865 {
17866 arg2 = wxString_in_helper(obj1);
17867 if (arg2 == NULL) SWIG_fail;
17868 temp2 = true;
17869 }
17870 {
17871 arg3 = wxString_in_helper(obj2);
17872 if (arg3 == NULL) SWIG_fail;
17873 temp3 = true;
17874 }
17875 {
17876 PyThreadState* __tstate = wxPyBeginAllowThreads();
17877 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17878
17879 wxPyEndAllowThreads(__tstate);
17880 if (PyErr_Occurred()) SWIG_fail;
17881 }
17882 {
17883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17884 }
17885 {
17886 if (temp2)
17887 delete arg2;
17888 }
17889 {
17890 if (temp3)
17891 delete arg3;
17892 }
17893 return resultobj;
17894 fail:
17895 {
17896 if (temp2)
17897 delete arg2;
17898 }
17899 {
17900 if (temp3)
17901 delete arg3;
17902 }
17903 return NULL;
17904 }
17905
17906
17907 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17908 PyObject *resultobj;
17909 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17910 wxString *arg2 = 0 ;
17911 bool arg3 = (bool) true ;
17912 bool result;
17913 bool temp2 = false ;
17914 PyObject * obj0 = 0 ;
17915 PyObject * obj1 = 0 ;
17916 PyObject * obj2 = 0 ;
17917 char *kwnames[] = {
17918 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17919 };
17920
17921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17923 if (SWIG_arg_fail(1)) SWIG_fail;
17924 {
17925 arg2 = wxString_in_helper(obj1);
17926 if (arg2 == NULL) SWIG_fail;
17927 temp2 = true;
17928 }
17929 if (obj2) {
17930 {
17931 arg3 = (bool)(SWIG_As_bool(obj2));
17932 if (SWIG_arg_fail(3)) SWIG_fail;
17933 }
17934 }
17935 {
17936 PyThreadState* __tstate = wxPyBeginAllowThreads();
17937 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17938
17939 wxPyEndAllowThreads(__tstate);
17940 if (PyErr_Occurred()) SWIG_fail;
17941 }
17942 {
17943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17944 }
17945 {
17946 if (temp2)
17947 delete arg2;
17948 }
17949 return resultobj;
17950 fail:
17951 {
17952 if (temp2)
17953 delete arg2;
17954 }
17955 return NULL;
17956 }
17957
17958
17959 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17960 PyObject *resultobj;
17961 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17962 wxString *arg2 = 0 ;
17963 bool result;
17964 bool temp2 = false ;
17965 PyObject * obj0 = 0 ;
17966 PyObject * obj1 = 0 ;
17967 char *kwnames[] = {
17968 (char *) "self",(char *) "key", NULL
17969 };
17970
17971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17973 if (SWIG_arg_fail(1)) SWIG_fail;
17974 {
17975 arg2 = wxString_in_helper(obj1);
17976 if (arg2 == NULL) SWIG_fail;
17977 temp2 = true;
17978 }
17979 {
17980 PyThreadState* __tstate = wxPyBeginAllowThreads();
17981 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17982
17983 wxPyEndAllowThreads(__tstate);
17984 if (PyErr_Occurred()) SWIG_fail;
17985 }
17986 {
17987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17988 }
17989 {
17990 if (temp2)
17991 delete arg2;
17992 }
17993 return resultobj;
17994 fail:
17995 {
17996 if (temp2)
17997 delete arg2;
17998 }
17999 return NULL;
18000 }
18001
18002
18003 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18004 PyObject *resultobj;
18005 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18006 bool result;
18007 PyObject * obj0 = 0 ;
18008 char *kwnames[] = {
18009 (char *) "self", NULL
18010 };
18011
18012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18014 if (SWIG_arg_fail(1)) SWIG_fail;
18015 {
18016 PyThreadState* __tstate = wxPyBeginAllowThreads();
18017 result = (bool)(arg1)->DeleteAll();
18018
18019 wxPyEndAllowThreads(__tstate);
18020 if (PyErr_Occurred()) SWIG_fail;
18021 }
18022 {
18023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18024 }
18025 return resultobj;
18026 fail:
18027 return NULL;
18028 }
18029
18030
18031 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18032 PyObject *resultobj;
18033 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18034 bool arg2 = (bool) true ;
18035 PyObject * obj0 = 0 ;
18036 PyObject * obj1 = 0 ;
18037 char *kwnames[] = {
18038 (char *) "self",(char *) "doIt", NULL
18039 };
18040
18041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18043 if (SWIG_arg_fail(1)) SWIG_fail;
18044 if (obj1) {
18045 {
18046 arg2 = (bool)(SWIG_As_bool(obj1));
18047 if (SWIG_arg_fail(2)) SWIG_fail;
18048 }
18049 }
18050 {
18051 PyThreadState* __tstate = wxPyBeginAllowThreads();
18052 (arg1)->SetExpandEnvVars(arg2);
18053
18054 wxPyEndAllowThreads(__tstate);
18055 if (PyErr_Occurred()) SWIG_fail;
18056 }
18057 Py_INCREF(Py_None); resultobj = Py_None;
18058 return resultobj;
18059 fail:
18060 return NULL;
18061 }
18062
18063
18064 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18065 PyObject *resultobj;
18066 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18067 bool result;
18068 PyObject * obj0 = 0 ;
18069 char *kwnames[] = {
18070 (char *) "self", NULL
18071 };
18072
18073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18075 if (SWIG_arg_fail(1)) SWIG_fail;
18076 {
18077 PyThreadState* __tstate = wxPyBeginAllowThreads();
18078 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18079
18080 wxPyEndAllowThreads(__tstate);
18081 if (PyErr_Occurred()) SWIG_fail;
18082 }
18083 {
18084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18085 }
18086 return resultobj;
18087 fail:
18088 return NULL;
18089 }
18090
18091
18092 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18093 PyObject *resultobj;
18094 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18095 bool arg2 = (bool) true ;
18096 PyObject * obj0 = 0 ;
18097 PyObject * obj1 = 0 ;
18098 char *kwnames[] = {
18099 (char *) "self",(char *) "doIt", NULL
18100 };
18101
18102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18104 if (SWIG_arg_fail(1)) SWIG_fail;
18105 if (obj1) {
18106 {
18107 arg2 = (bool)(SWIG_As_bool(obj1));
18108 if (SWIG_arg_fail(2)) SWIG_fail;
18109 }
18110 }
18111 {
18112 PyThreadState* __tstate = wxPyBeginAllowThreads();
18113 (arg1)->SetRecordDefaults(arg2);
18114
18115 wxPyEndAllowThreads(__tstate);
18116 if (PyErr_Occurred()) SWIG_fail;
18117 }
18118 Py_INCREF(Py_None); resultobj = Py_None;
18119 return resultobj;
18120 fail:
18121 return NULL;
18122 }
18123
18124
18125 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18126 PyObject *resultobj;
18127 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18128 bool result;
18129 PyObject * obj0 = 0 ;
18130 char *kwnames[] = {
18131 (char *) "self", NULL
18132 };
18133
18134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18136 if (SWIG_arg_fail(1)) SWIG_fail;
18137 {
18138 PyThreadState* __tstate = wxPyBeginAllowThreads();
18139 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18140
18141 wxPyEndAllowThreads(__tstate);
18142 if (PyErr_Occurred()) SWIG_fail;
18143 }
18144 {
18145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18146 }
18147 return resultobj;
18148 fail:
18149 return NULL;
18150 }
18151
18152
18153 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18154 PyObject *resultobj;
18155 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18156 wxString *arg2 = 0 ;
18157 wxString result;
18158 bool temp2 = false ;
18159 PyObject * obj0 = 0 ;
18160 PyObject * obj1 = 0 ;
18161 char *kwnames[] = {
18162 (char *) "self",(char *) "str", NULL
18163 };
18164
18165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18167 if (SWIG_arg_fail(1)) SWIG_fail;
18168 {
18169 arg2 = wxString_in_helper(obj1);
18170 if (arg2 == NULL) SWIG_fail;
18171 temp2 = true;
18172 }
18173 {
18174 PyThreadState* __tstate = wxPyBeginAllowThreads();
18175 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18176
18177 wxPyEndAllowThreads(__tstate);
18178 if (PyErr_Occurred()) SWIG_fail;
18179 }
18180 {
18181 #if wxUSE_UNICODE
18182 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18183 #else
18184 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18185 #endif
18186 }
18187 {
18188 if (temp2)
18189 delete arg2;
18190 }
18191 return resultobj;
18192 fail:
18193 {
18194 if (temp2)
18195 delete arg2;
18196 }
18197 return NULL;
18198 }
18199
18200
18201 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18202 PyObject *resultobj;
18203 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18204 wxString result;
18205 PyObject * obj0 = 0 ;
18206 char *kwnames[] = {
18207 (char *) "self", NULL
18208 };
18209
18210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18212 if (SWIG_arg_fail(1)) SWIG_fail;
18213 {
18214 PyThreadState* __tstate = wxPyBeginAllowThreads();
18215 result = ((wxConfigBase const *)arg1)->GetAppName();
18216
18217 wxPyEndAllowThreads(__tstate);
18218 if (PyErr_Occurred()) SWIG_fail;
18219 }
18220 {
18221 #if wxUSE_UNICODE
18222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18223 #else
18224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18225 #endif
18226 }
18227 return resultobj;
18228 fail:
18229 return NULL;
18230 }
18231
18232
18233 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18234 PyObject *resultobj;
18235 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18236 wxString result;
18237 PyObject * obj0 = 0 ;
18238 char *kwnames[] = {
18239 (char *) "self", NULL
18240 };
18241
18242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18244 if (SWIG_arg_fail(1)) SWIG_fail;
18245 {
18246 PyThreadState* __tstate = wxPyBeginAllowThreads();
18247 result = ((wxConfigBase const *)arg1)->GetVendorName();
18248
18249 wxPyEndAllowThreads(__tstate);
18250 if (PyErr_Occurred()) SWIG_fail;
18251 }
18252 {
18253 #if wxUSE_UNICODE
18254 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18255 #else
18256 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18257 #endif
18258 }
18259 return resultobj;
18260 fail:
18261 return NULL;
18262 }
18263
18264
18265 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18266 PyObject *resultobj;
18267 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18268 wxString *arg2 = 0 ;
18269 bool temp2 = false ;
18270 PyObject * obj0 = 0 ;
18271 PyObject * obj1 = 0 ;
18272 char *kwnames[] = {
18273 (char *) "self",(char *) "appName", NULL
18274 };
18275
18276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18278 if (SWIG_arg_fail(1)) SWIG_fail;
18279 {
18280 arg2 = wxString_in_helper(obj1);
18281 if (arg2 == NULL) SWIG_fail;
18282 temp2 = true;
18283 }
18284 {
18285 PyThreadState* __tstate = wxPyBeginAllowThreads();
18286 (arg1)->SetAppName((wxString const &)*arg2);
18287
18288 wxPyEndAllowThreads(__tstate);
18289 if (PyErr_Occurred()) SWIG_fail;
18290 }
18291 Py_INCREF(Py_None); resultobj = Py_None;
18292 {
18293 if (temp2)
18294 delete arg2;
18295 }
18296 return resultobj;
18297 fail:
18298 {
18299 if (temp2)
18300 delete arg2;
18301 }
18302 return NULL;
18303 }
18304
18305
18306 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18307 PyObject *resultobj;
18308 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18309 wxString *arg2 = 0 ;
18310 bool temp2 = false ;
18311 PyObject * obj0 = 0 ;
18312 PyObject * obj1 = 0 ;
18313 char *kwnames[] = {
18314 (char *) "self",(char *) "vendorName", NULL
18315 };
18316
18317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18319 if (SWIG_arg_fail(1)) SWIG_fail;
18320 {
18321 arg2 = wxString_in_helper(obj1);
18322 if (arg2 == NULL) SWIG_fail;
18323 temp2 = true;
18324 }
18325 {
18326 PyThreadState* __tstate = wxPyBeginAllowThreads();
18327 (arg1)->SetVendorName((wxString const &)*arg2);
18328
18329 wxPyEndAllowThreads(__tstate);
18330 if (PyErr_Occurred()) SWIG_fail;
18331 }
18332 Py_INCREF(Py_None); resultobj = Py_None;
18333 {
18334 if (temp2)
18335 delete arg2;
18336 }
18337 return resultobj;
18338 fail:
18339 {
18340 if (temp2)
18341 delete arg2;
18342 }
18343 return NULL;
18344 }
18345
18346
18347 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18348 PyObject *resultobj;
18349 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18350 long arg2 ;
18351 PyObject * obj0 = 0 ;
18352 PyObject * obj1 = 0 ;
18353 char *kwnames[] = {
18354 (char *) "self",(char *) "style", NULL
18355 };
18356
18357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18359 if (SWIG_arg_fail(1)) SWIG_fail;
18360 {
18361 arg2 = (long)(SWIG_As_long(obj1));
18362 if (SWIG_arg_fail(2)) SWIG_fail;
18363 }
18364 {
18365 PyThreadState* __tstate = wxPyBeginAllowThreads();
18366 (arg1)->SetStyle(arg2);
18367
18368 wxPyEndAllowThreads(__tstate);
18369 if (PyErr_Occurred()) SWIG_fail;
18370 }
18371 Py_INCREF(Py_None); resultobj = Py_None;
18372 return resultobj;
18373 fail:
18374 return NULL;
18375 }
18376
18377
18378 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18379 PyObject *resultobj;
18380 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18381 long result;
18382 PyObject * obj0 = 0 ;
18383 char *kwnames[] = {
18384 (char *) "self", NULL
18385 };
18386
18387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18389 if (SWIG_arg_fail(1)) SWIG_fail;
18390 {
18391 PyThreadState* __tstate = wxPyBeginAllowThreads();
18392 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18393
18394 wxPyEndAllowThreads(__tstate);
18395 if (PyErr_Occurred()) SWIG_fail;
18396 }
18397 {
18398 resultobj = SWIG_From_long((long)(result));
18399 }
18400 return resultobj;
18401 fail:
18402 return NULL;
18403 }
18404
18405
18406 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18407 PyObject *obj;
18408 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18409 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18410 Py_INCREF(obj);
18411 return Py_BuildValue((char *)"");
18412 }
18413 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18414 PyObject *resultobj;
18415 wxString const &arg1_defvalue = wxPyEmptyString ;
18416 wxString *arg1 = (wxString *) &arg1_defvalue ;
18417 wxString const &arg2_defvalue = wxPyEmptyString ;
18418 wxString *arg2 = (wxString *) &arg2_defvalue ;
18419 wxString const &arg3_defvalue = wxPyEmptyString ;
18420 wxString *arg3 = (wxString *) &arg3_defvalue ;
18421 wxString const &arg4_defvalue = wxPyEmptyString ;
18422 wxString *arg4 = (wxString *) &arg4_defvalue ;
18423 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18424 wxConfig *result;
18425 bool temp1 = false ;
18426 bool temp2 = false ;
18427 bool temp3 = false ;
18428 bool temp4 = false ;
18429 PyObject * obj0 = 0 ;
18430 PyObject * obj1 = 0 ;
18431 PyObject * obj2 = 0 ;
18432 PyObject * obj3 = 0 ;
18433 PyObject * obj4 = 0 ;
18434 char *kwnames[] = {
18435 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18436 };
18437
18438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18439 if (obj0) {
18440 {
18441 arg1 = wxString_in_helper(obj0);
18442 if (arg1 == NULL) SWIG_fail;
18443 temp1 = true;
18444 }
18445 }
18446 if (obj1) {
18447 {
18448 arg2 = wxString_in_helper(obj1);
18449 if (arg2 == NULL) SWIG_fail;
18450 temp2 = true;
18451 }
18452 }
18453 if (obj2) {
18454 {
18455 arg3 = wxString_in_helper(obj2);
18456 if (arg3 == NULL) SWIG_fail;
18457 temp3 = true;
18458 }
18459 }
18460 if (obj3) {
18461 {
18462 arg4 = wxString_in_helper(obj3);
18463 if (arg4 == NULL) SWIG_fail;
18464 temp4 = true;
18465 }
18466 }
18467 if (obj4) {
18468 {
18469 arg5 = (long)(SWIG_As_long(obj4));
18470 if (SWIG_arg_fail(5)) SWIG_fail;
18471 }
18472 }
18473 {
18474 PyThreadState* __tstate = wxPyBeginAllowThreads();
18475 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18476
18477 wxPyEndAllowThreads(__tstate);
18478 if (PyErr_Occurred()) SWIG_fail;
18479 }
18480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18481 {
18482 if (temp1)
18483 delete arg1;
18484 }
18485 {
18486 if (temp2)
18487 delete arg2;
18488 }
18489 {
18490 if (temp3)
18491 delete arg3;
18492 }
18493 {
18494 if (temp4)
18495 delete arg4;
18496 }
18497 return resultobj;
18498 fail:
18499 {
18500 if (temp1)
18501 delete arg1;
18502 }
18503 {
18504 if (temp2)
18505 delete arg2;
18506 }
18507 {
18508 if (temp3)
18509 delete arg3;
18510 }
18511 {
18512 if (temp4)
18513 delete arg4;
18514 }
18515 return NULL;
18516 }
18517
18518
18519 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18520 PyObject *resultobj;
18521 wxConfig *arg1 = (wxConfig *) 0 ;
18522 PyObject * obj0 = 0 ;
18523 char *kwnames[] = {
18524 (char *) "self", NULL
18525 };
18526
18527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18529 if (SWIG_arg_fail(1)) SWIG_fail;
18530 {
18531 PyThreadState* __tstate = wxPyBeginAllowThreads();
18532 delete arg1;
18533
18534 wxPyEndAllowThreads(__tstate);
18535 if (PyErr_Occurred()) SWIG_fail;
18536 }
18537 Py_INCREF(Py_None); resultobj = Py_None;
18538 return resultobj;
18539 fail:
18540 return NULL;
18541 }
18542
18543
18544 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18545 PyObject *obj;
18546 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18547 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18548 Py_INCREF(obj);
18549 return Py_BuildValue((char *)"");
18550 }
18551 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18552 PyObject *resultobj;
18553 wxString const &arg1_defvalue = wxPyEmptyString ;
18554 wxString *arg1 = (wxString *) &arg1_defvalue ;
18555 wxString const &arg2_defvalue = wxPyEmptyString ;
18556 wxString *arg2 = (wxString *) &arg2_defvalue ;
18557 wxString const &arg3_defvalue = wxPyEmptyString ;
18558 wxString *arg3 = (wxString *) &arg3_defvalue ;
18559 wxString const &arg4_defvalue = wxPyEmptyString ;
18560 wxString *arg4 = (wxString *) &arg4_defvalue ;
18561 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18562 wxFileConfig *result;
18563 bool temp1 = false ;
18564 bool temp2 = false ;
18565 bool temp3 = false ;
18566 bool temp4 = false ;
18567 PyObject * obj0 = 0 ;
18568 PyObject * obj1 = 0 ;
18569 PyObject * obj2 = 0 ;
18570 PyObject * obj3 = 0 ;
18571 PyObject * obj4 = 0 ;
18572 char *kwnames[] = {
18573 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18574 };
18575
18576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18577 if (obj0) {
18578 {
18579 arg1 = wxString_in_helper(obj0);
18580 if (arg1 == NULL) SWIG_fail;
18581 temp1 = true;
18582 }
18583 }
18584 if (obj1) {
18585 {
18586 arg2 = wxString_in_helper(obj1);
18587 if (arg2 == NULL) SWIG_fail;
18588 temp2 = true;
18589 }
18590 }
18591 if (obj2) {
18592 {
18593 arg3 = wxString_in_helper(obj2);
18594 if (arg3 == NULL) SWIG_fail;
18595 temp3 = true;
18596 }
18597 }
18598 if (obj3) {
18599 {
18600 arg4 = wxString_in_helper(obj3);
18601 if (arg4 == NULL) SWIG_fail;
18602 temp4 = true;
18603 }
18604 }
18605 if (obj4) {
18606 {
18607 arg5 = (long)(SWIG_As_long(obj4));
18608 if (SWIG_arg_fail(5)) SWIG_fail;
18609 }
18610 }
18611 {
18612 PyThreadState* __tstate = wxPyBeginAllowThreads();
18613 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18614
18615 wxPyEndAllowThreads(__tstate);
18616 if (PyErr_Occurred()) SWIG_fail;
18617 }
18618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18619 {
18620 if (temp1)
18621 delete arg1;
18622 }
18623 {
18624 if (temp2)
18625 delete arg2;
18626 }
18627 {
18628 if (temp3)
18629 delete arg3;
18630 }
18631 {
18632 if (temp4)
18633 delete arg4;
18634 }
18635 return resultobj;
18636 fail:
18637 {
18638 if (temp1)
18639 delete arg1;
18640 }
18641 {
18642 if (temp2)
18643 delete arg2;
18644 }
18645 {
18646 if (temp3)
18647 delete arg3;
18648 }
18649 {
18650 if (temp4)
18651 delete arg4;
18652 }
18653 return NULL;
18654 }
18655
18656
18657 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18658 PyObject *resultobj;
18659 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18660 PyObject * obj0 = 0 ;
18661 char *kwnames[] = {
18662 (char *) "self", NULL
18663 };
18664
18665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18667 if (SWIG_arg_fail(1)) SWIG_fail;
18668 {
18669 PyThreadState* __tstate = wxPyBeginAllowThreads();
18670 delete arg1;
18671
18672 wxPyEndAllowThreads(__tstate);
18673 if (PyErr_Occurred()) SWIG_fail;
18674 }
18675 Py_INCREF(Py_None); resultobj = Py_None;
18676 return resultobj;
18677 fail:
18678 return NULL;
18679 }
18680
18681
18682 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18683 PyObject *obj;
18684 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18685 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18686 Py_INCREF(obj);
18687 return Py_BuildValue((char *)"");
18688 }
18689 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18690 PyObject *resultobj;
18691 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18692 wxString *arg2 = 0 ;
18693 wxConfigPathChanger *result;
18694 bool temp2 = false ;
18695 PyObject * obj0 = 0 ;
18696 PyObject * obj1 = 0 ;
18697 char *kwnames[] = {
18698 (char *) "config",(char *) "entry", NULL
18699 };
18700
18701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18703 if (SWIG_arg_fail(1)) SWIG_fail;
18704 {
18705 arg2 = wxString_in_helper(obj1);
18706 if (arg2 == NULL) SWIG_fail;
18707 temp2 = true;
18708 }
18709 {
18710 PyThreadState* __tstate = wxPyBeginAllowThreads();
18711 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18712
18713 wxPyEndAllowThreads(__tstate);
18714 if (PyErr_Occurred()) SWIG_fail;
18715 }
18716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18717 {
18718 if (temp2)
18719 delete arg2;
18720 }
18721 return resultobj;
18722 fail:
18723 {
18724 if (temp2)
18725 delete arg2;
18726 }
18727 return NULL;
18728 }
18729
18730
18731 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18732 PyObject *resultobj;
18733 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18734 PyObject * obj0 = 0 ;
18735 char *kwnames[] = {
18736 (char *) "self", NULL
18737 };
18738
18739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18741 if (SWIG_arg_fail(1)) SWIG_fail;
18742 {
18743 PyThreadState* __tstate = wxPyBeginAllowThreads();
18744 delete arg1;
18745
18746 wxPyEndAllowThreads(__tstate);
18747 if (PyErr_Occurred()) SWIG_fail;
18748 }
18749 Py_INCREF(Py_None); resultobj = Py_None;
18750 return resultobj;
18751 fail:
18752 return NULL;
18753 }
18754
18755
18756 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18757 PyObject *resultobj;
18758 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18759 wxString *result;
18760 PyObject * obj0 = 0 ;
18761 char *kwnames[] = {
18762 (char *) "self", NULL
18763 };
18764
18765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18767 if (SWIG_arg_fail(1)) SWIG_fail;
18768 {
18769 PyThreadState* __tstate = wxPyBeginAllowThreads();
18770 {
18771 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18772 result = (wxString *) &_result_ref;
18773 }
18774
18775 wxPyEndAllowThreads(__tstate);
18776 if (PyErr_Occurred()) SWIG_fail;
18777 }
18778 {
18779 #if wxUSE_UNICODE
18780 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18781 #else
18782 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18783 #endif
18784 }
18785 return resultobj;
18786 fail:
18787 return NULL;
18788 }
18789
18790
18791 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18792 PyObject *obj;
18793 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18794 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18795 Py_INCREF(obj);
18796 return Py_BuildValue((char *)"");
18797 }
18798 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18799 PyObject *resultobj;
18800 wxString *arg1 = 0 ;
18801 wxString result;
18802 bool temp1 = false ;
18803 PyObject * obj0 = 0 ;
18804 char *kwnames[] = {
18805 (char *) "sz", NULL
18806 };
18807
18808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18809 {
18810 arg1 = wxString_in_helper(obj0);
18811 if (arg1 == NULL) SWIG_fail;
18812 temp1 = true;
18813 }
18814 {
18815 PyThreadState* __tstate = wxPyBeginAllowThreads();
18816 result = wxExpandEnvVars((wxString const &)*arg1);
18817
18818 wxPyEndAllowThreads(__tstate);
18819 if (PyErr_Occurred()) SWIG_fail;
18820 }
18821 {
18822 #if wxUSE_UNICODE
18823 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18824 #else
18825 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18826 #endif
18827 }
18828 {
18829 if (temp1)
18830 delete arg1;
18831 }
18832 return resultobj;
18833 fail:
18834 {
18835 if (temp1)
18836 delete arg1;
18837 }
18838 return NULL;
18839 }
18840
18841
18842 static int _wrap_DateFormatStr_set(PyObject *) {
18843 PyErr_SetString(PyExc_TypeError,"Variable DateFormatStr is read-only.");
18844 return 1;
18845 }
18846
18847
18848 static PyObject *_wrap_DateFormatStr_get(void) {
18849 PyObject *pyobj;
18850
18851 {
18852 #if wxUSE_UNICODE
18853 pyobj = PyUnicode_FromWideChar((&wxPyDateFormatStr)->c_str(), (&wxPyDateFormatStr)->Len());
18854 #else
18855 pyobj = PyString_FromStringAndSize((&wxPyDateFormatStr)->c_str(), (&wxPyDateFormatStr)->Len());
18856 #endif
18857 }
18858 return pyobj;
18859 }
18860
18861
18862 static int _wrap_TimeSpanFormatStr_set(PyObject *) {
18863 PyErr_SetString(PyExc_TypeError,"Variable TimeSpanFormatStr is read-only.");
18864 return 1;
18865 }
18866
18867
18868 static PyObject *_wrap_TimeSpanFormatStr_get(void) {
18869 PyObject *pyobj;
18870
18871 {
18872 #if wxUSE_UNICODE
18873 pyobj = PyUnicode_FromWideChar((&wxPyTimeSpanFormatStr)->c_str(), (&wxPyTimeSpanFormatStr)->Len());
18874 #else
18875 pyobj = PyString_FromStringAndSize((&wxPyTimeSpanFormatStr)->c_str(), (&wxPyTimeSpanFormatStr)->Len());
18876 #endif
18877 }
18878 return pyobj;
18879 }
18880
18881
18882 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18883 PyObject *resultobj;
18884 wxDateTime::Country arg1 ;
18885 PyObject * obj0 = 0 ;
18886 char *kwnames[] = {
18887 (char *) "country", NULL
18888 };
18889
18890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18891 {
18892 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18893 if (SWIG_arg_fail(1)) SWIG_fail;
18894 }
18895 {
18896 PyThreadState* __tstate = wxPyBeginAllowThreads();
18897 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18898
18899 wxPyEndAllowThreads(__tstate);
18900 if (PyErr_Occurred()) SWIG_fail;
18901 }
18902 Py_INCREF(Py_None); resultobj = Py_None;
18903 return resultobj;
18904 fail:
18905 return NULL;
18906 }
18907
18908
18909 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18910 PyObject *resultobj;
18911 wxDateTime::Country result;
18912 char *kwnames[] = {
18913 NULL
18914 };
18915
18916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18917 {
18918 PyThreadState* __tstate = wxPyBeginAllowThreads();
18919 result = (wxDateTime::Country)wxDateTime::GetCountry();
18920
18921 wxPyEndAllowThreads(__tstate);
18922 if (PyErr_Occurred()) SWIG_fail;
18923 }
18924 resultobj = SWIG_From_int((result));
18925 return resultobj;
18926 fail:
18927 return NULL;
18928 }
18929
18930
18931 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18932 PyObject *resultobj;
18933 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18934 bool result;
18935 PyObject * obj0 = 0 ;
18936 char *kwnames[] = {
18937 (char *) "country", NULL
18938 };
18939
18940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18941 if (obj0) {
18942 {
18943 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18944 if (SWIG_arg_fail(1)) SWIG_fail;
18945 }
18946 }
18947 {
18948 PyThreadState* __tstate = wxPyBeginAllowThreads();
18949 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18950
18951 wxPyEndAllowThreads(__tstate);
18952 if (PyErr_Occurred()) SWIG_fail;
18953 }
18954 {
18955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18956 }
18957 return resultobj;
18958 fail:
18959 return NULL;
18960 }
18961
18962
18963 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18964 PyObject *resultobj;
18965 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18966 int result;
18967 PyObject * obj0 = 0 ;
18968 char *kwnames[] = {
18969 (char *) "cal", NULL
18970 };
18971
18972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18973 if (obj0) {
18974 {
18975 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18976 if (SWIG_arg_fail(1)) SWIG_fail;
18977 }
18978 }
18979 {
18980 PyThreadState* __tstate = wxPyBeginAllowThreads();
18981 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18982
18983 wxPyEndAllowThreads(__tstate);
18984 if (PyErr_Occurred()) SWIG_fail;
18985 }
18986 {
18987 resultobj = SWIG_From_int((int)(result));
18988 }
18989 return resultobj;
18990 fail:
18991 return NULL;
18992 }
18993
18994
18995 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
18996 PyObject *resultobj;
18997 int arg1 ;
18998 int result;
18999 PyObject * obj0 = 0 ;
19000 char *kwnames[] = {
19001 (char *) "year", NULL
19002 };
19003
19004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19005 {
19006 arg1 = (int)(SWIG_As_int(obj0));
19007 if (SWIG_arg_fail(1)) SWIG_fail;
19008 }
19009 {
19010 PyThreadState* __tstate = wxPyBeginAllowThreads();
19011 result = (int)wxDateTime::ConvertYearToBC(arg1);
19012
19013 wxPyEndAllowThreads(__tstate);
19014 if (PyErr_Occurred()) SWIG_fail;
19015 }
19016 {
19017 resultobj = SWIG_From_int((int)(result));
19018 }
19019 return resultobj;
19020 fail:
19021 return NULL;
19022 }
19023
19024
19025 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19026 PyObject *resultobj;
19027 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19028 wxDateTime::Month result;
19029 PyObject * obj0 = 0 ;
19030 char *kwnames[] = {
19031 (char *) "cal", NULL
19032 };
19033
19034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19035 if (obj0) {
19036 {
19037 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19038 if (SWIG_arg_fail(1)) SWIG_fail;
19039 }
19040 }
19041 {
19042 PyThreadState* __tstate = wxPyBeginAllowThreads();
19043 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19044
19045 wxPyEndAllowThreads(__tstate);
19046 if (PyErr_Occurred()) SWIG_fail;
19047 }
19048 resultobj = SWIG_From_int((result));
19049 return resultobj;
19050 fail:
19051 return NULL;
19052 }
19053
19054
19055 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19056 PyObject *resultobj;
19057 int arg1 = (int) wxDateTime::Inv_Year ;
19058 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19059 bool result;
19060 PyObject * obj0 = 0 ;
19061 PyObject * obj1 = 0 ;
19062 char *kwnames[] = {
19063 (char *) "year",(char *) "cal", NULL
19064 };
19065
19066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19067 if (obj0) {
19068 {
19069 arg1 = (int)(SWIG_As_int(obj0));
19070 if (SWIG_arg_fail(1)) SWIG_fail;
19071 }
19072 }
19073 if (obj1) {
19074 {
19075 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19076 if (SWIG_arg_fail(2)) SWIG_fail;
19077 }
19078 }
19079 {
19080 PyThreadState* __tstate = wxPyBeginAllowThreads();
19081 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19082
19083 wxPyEndAllowThreads(__tstate);
19084 if (PyErr_Occurred()) SWIG_fail;
19085 }
19086 {
19087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19088 }
19089 return resultobj;
19090 fail:
19091 return NULL;
19092 }
19093
19094
19095 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19096 PyObject *resultobj;
19097 int arg1 = (int) wxDateTime::Inv_Year ;
19098 int result;
19099 PyObject * obj0 = 0 ;
19100 char *kwnames[] = {
19101 (char *) "year", NULL
19102 };
19103
19104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19105 if (obj0) {
19106 {
19107 arg1 = (int)(SWIG_As_int(obj0));
19108 if (SWIG_arg_fail(1)) SWIG_fail;
19109 }
19110 }
19111 {
19112 PyThreadState* __tstate = wxPyBeginAllowThreads();
19113 result = (int)wxDateTime::GetCentury(arg1);
19114
19115 wxPyEndAllowThreads(__tstate);
19116 if (PyErr_Occurred()) SWIG_fail;
19117 }
19118 {
19119 resultobj = SWIG_From_int((int)(result));
19120 }
19121 return resultobj;
19122 fail:
19123 return NULL;
19124 }
19125
19126
19127 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19128 PyObject *resultobj;
19129 int arg1 ;
19130 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19131 int result;
19132 PyObject * obj0 = 0 ;
19133 PyObject * obj1 = 0 ;
19134 char *kwnames[] = {
19135 (char *) "year",(char *) "cal", NULL
19136 };
19137
19138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19139 {
19140 arg1 = (int)(SWIG_As_int(obj0));
19141 if (SWIG_arg_fail(1)) SWIG_fail;
19142 }
19143 if (obj1) {
19144 {
19145 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19146 if (SWIG_arg_fail(2)) SWIG_fail;
19147 }
19148 }
19149 {
19150 PyThreadState* __tstate = wxPyBeginAllowThreads();
19151 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19152
19153 wxPyEndAllowThreads(__tstate);
19154 if (PyErr_Occurred()) SWIG_fail;
19155 }
19156 {
19157 resultobj = SWIG_From_int((int)(result));
19158 }
19159 return resultobj;
19160 fail:
19161 return NULL;
19162 }
19163
19164
19165 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19166 PyObject *resultobj;
19167 wxDateTime::Month arg1 ;
19168 int arg2 = (int) wxDateTime::Inv_Year ;
19169 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19170 int result;
19171 PyObject * obj0 = 0 ;
19172 PyObject * obj1 = 0 ;
19173 PyObject * obj2 = 0 ;
19174 char *kwnames[] = {
19175 (char *) "month",(char *) "year",(char *) "cal", NULL
19176 };
19177
19178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19179 {
19180 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19181 if (SWIG_arg_fail(1)) SWIG_fail;
19182 }
19183 if (obj1) {
19184 {
19185 arg2 = (int)(SWIG_As_int(obj1));
19186 if (SWIG_arg_fail(2)) SWIG_fail;
19187 }
19188 }
19189 if (obj2) {
19190 {
19191 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19192 if (SWIG_arg_fail(3)) SWIG_fail;
19193 }
19194 }
19195 {
19196 PyThreadState* __tstate = wxPyBeginAllowThreads();
19197 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19198
19199 wxPyEndAllowThreads(__tstate);
19200 if (PyErr_Occurred()) SWIG_fail;
19201 }
19202 {
19203 resultobj = SWIG_From_int((int)(result));
19204 }
19205 return resultobj;
19206 fail:
19207 return NULL;
19208 }
19209
19210
19211 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19212 PyObject *resultobj;
19213 wxDateTime::Month arg1 ;
19214 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19215 wxString result;
19216 PyObject * obj0 = 0 ;
19217 PyObject * obj1 = 0 ;
19218 char *kwnames[] = {
19219 (char *) "month",(char *) "flags", NULL
19220 };
19221
19222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19223 {
19224 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19225 if (SWIG_arg_fail(1)) SWIG_fail;
19226 }
19227 if (obj1) {
19228 {
19229 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19230 if (SWIG_arg_fail(2)) SWIG_fail;
19231 }
19232 }
19233 {
19234 PyThreadState* __tstate = wxPyBeginAllowThreads();
19235 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19236
19237 wxPyEndAllowThreads(__tstate);
19238 if (PyErr_Occurred()) SWIG_fail;
19239 }
19240 {
19241 #if wxUSE_UNICODE
19242 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19243 #else
19244 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19245 #endif
19246 }
19247 return resultobj;
19248 fail:
19249 return NULL;
19250 }
19251
19252
19253 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19254 PyObject *resultobj;
19255 wxDateTime::WeekDay arg1 ;
19256 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19257 wxString result;
19258 PyObject * obj0 = 0 ;
19259 PyObject * obj1 = 0 ;
19260 char *kwnames[] = {
19261 (char *) "weekday",(char *) "flags", NULL
19262 };
19263
19264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19265 {
19266 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19267 if (SWIG_arg_fail(1)) SWIG_fail;
19268 }
19269 if (obj1) {
19270 {
19271 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19272 if (SWIG_arg_fail(2)) SWIG_fail;
19273 }
19274 }
19275 {
19276 PyThreadState* __tstate = wxPyBeginAllowThreads();
19277 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19278
19279 wxPyEndAllowThreads(__tstate);
19280 if (PyErr_Occurred()) SWIG_fail;
19281 }
19282 {
19283 #if wxUSE_UNICODE
19284 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19285 #else
19286 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19287 #endif
19288 }
19289 return resultobj;
19290 fail:
19291 return NULL;
19292 }
19293
19294
19295 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19296 PyObject *resultobj;
19297 wxString *arg1 = (wxString *) 0 ;
19298 wxString *arg2 = (wxString *) 0 ;
19299 bool temp1 = false ;
19300 bool temp2 = false ;
19301 PyObject * obj0 = 0 ;
19302 PyObject * obj1 = 0 ;
19303 char *kwnames[] = {
19304 (char *) "OUTPUT",(char *) "OUTPUT", NULL
19305 };
19306
19307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetAmPmStrings",kwnames,&obj0,&obj1)) goto fail;
19308 {
19309 arg1 = wxString_in_helper(obj0);
19310 if (arg1 == NULL) SWIG_fail;
19311 temp1 = true;
19312 }
19313 {
19314 arg2 = wxString_in_helper(obj1);
19315 if (arg2 == NULL) SWIG_fail;
19316 temp2 = true;
19317 }
19318 {
19319 PyThreadState* __tstate = wxPyBeginAllowThreads();
19320 wxDateTime::GetAmPmStrings(arg1,arg2);
19321
19322 wxPyEndAllowThreads(__tstate);
19323 if (PyErr_Occurred()) SWIG_fail;
19324 }
19325 Py_INCREF(Py_None); resultobj = Py_None;
19326 {
19327 if (temp1)
19328 delete arg1;
19329 }
19330 {
19331 if (temp2)
19332 delete arg2;
19333 }
19334 return resultobj;
19335 fail:
19336 {
19337 if (temp1)
19338 delete arg1;
19339 }
19340 {
19341 if (temp2)
19342 delete arg2;
19343 }
19344 return NULL;
19345 }
19346
19347
19348 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19349 PyObject *resultobj;
19350 int arg1 = (int) wxDateTime::Inv_Year ;
19351 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19352 bool result;
19353 PyObject * obj0 = 0 ;
19354 PyObject * obj1 = 0 ;
19355 char *kwnames[] = {
19356 (char *) "year",(char *) "country", NULL
19357 };
19358
19359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19360 if (obj0) {
19361 {
19362 arg1 = (int)(SWIG_As_int(obj0));
19363 if (SWIG_arg_fail(1)) SWIG_fail;
19364 }
19365 }
19366 if (obj1) {
19367 {
19368 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19369 if (SWIG_arg_fail(2)) SWIG_fail;
19370 }
19371 }
19372 {
19373 PyThreadState* __tstate = wxPyBeginAllowThreads();
19374 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19375
19376 wxPyEndAllowThreads(__tstate);
19377 if (PyErr_Occurred()) SWIG_fail;
19378 }
19379 {
19380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19381 }
19382 return resultobj;
19383 fail:
19384 return NULL;
19385 }
19386
19387
19388 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19389 PyObject *resultobj;
19390 int arg1 = (int) wxDateTime::Inv_Year ;
19391 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19392 wxDateTime result;
19393 PyObject * obj0 = 0 ;
19394 PyObject * obj1 = 0 ;
19395 char *kwnames[] = {
19396 (char *) "year",(char *) "country", NULL
19397 };
19398
19399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19400 if (obj0) {
19401 {
19402 arg1 = (int)(SWIG_As_int(obj0));
19403 if (SWIG_arg_fail(1)) SWIG_fail;
19404 }
19405 }
19406 if (obj1) {
19407 {
19408 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19409 if (SWIG_arg_fail(2)) SWIG_fail;
19410 }
19411 }
19412 {
19413 PyThreadState* __tstate = wxPyBeginAllowThreads();
19414 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19415
19416 wxPyEndAllowThreads(__tstate);
19417 if (PyErr_Occurred()) SWIG_fail;
19418 }
19419 {
19420 wxDateTime * resultptr;
19421 resultptr = new wxDateTime((wxDateTime &)(result));
19422 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19423 }
19424 return resultobj;
19425 fail:
19426 return NULL;
19427 }
19428
19429
19430 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19431 PyObject *resultobj;
19432 int arg1 = (int) wxDateTime::Inv_Year ;
19433 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19434 wxDateTime result;
19435 PyObject * obj0 = 0 ;
19436 PyObject * obj1 = 0 ;
19437 char *kwnames[] = {
19438 (char *) "year",(char *) "country", NULL
19439 };
19440
19441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19442 if (obj0) {
19443 {
19444 arg1 = (int)(SWIG_As_int(obj0));
19445 if (SWIG_arg_fail(1)) SWIG_fail;
19446 }
19447 }
19448 if (obj1) {
19449 {
19450 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19451 if (SWIG_arg_fail(2)) SWIG_fail;
19452 }
19453 }
19454 {
19455 PyThreadState* __tstate = wxPyBeginAllowThreads();
19456 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19457
19458 wxPyEndAllowThreads(__tstate);
19459 if (PyErr_Occurred()) SWIG_fail;
19460 }
19461 {
19462 wxDateTime * resultptr;
19463 resultptr = new wxDateTime((wxDateTime &)(result));
19464 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19465 }
19466 return resultobj;
19467 fail:
19468 return NULL;
19469 }
19470
19471
19472 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19473 PyObject *resultobj;
19474 wxDateTime result;
19475 char *kwnames[] = {
19476 NULL
19477 };
19478
19479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19480 {
19481 PyThreadState* __tstate = wxPyBeginAllowThreads();
19482 result = wxDateTime::Now();
19483
19484 wxPyEndAllowThreads(__tstate);
19485 if (PyErr_Occurred()) SWIG_fail;
19486 }
19487 {
19488 wxDateTime * resultptr;
19489 resultptr = new wxDateTime((wxDateTime &)(result));
19490 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19491 }
19492 return resultobj;
19493 fail:
19494 return NULL;
19495 }
19496
19497
19498 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19499 PyObject *resultobj;
19500 wxDateTime result;
19501 char *kwnames[] = {
19502 NULL
19503 };
19504
19505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19506 {
19507 PyThreadState* __tstate = wxPyBeginAllowThreads();
19508 result = wxDateTime::UNow();
19509
19510 wxPyEndAllowThreads(__tstate);
19511 if (PyErr_Occurred()) SWIG_fail;
19512 }
19513 {
19514 wxDateTime * resultptr;
19515 resultptr = new wxDateTime((wxDateTime &)(result));
19516 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19517 }
19518 return resultobj;
19519 fail:
19520 return NULL;
19521 }
19522
19523
19524 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19525 PyObject *resultobj;
19526 wxDateTime result;
19527 char *kwnames[] = {
19528 NULL
19529 };
19530
19531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19532 {
19533 PyThreadState* __tstate = wxPyBeginAllowThreads();
19534 result = wxDateTime::Today();
19535
19536 wxPyEndAllowThreads(__tstate);
19537 if (PyErr_Occurred()) SWIG_fail;
19538 }
19539 {
19540 wxDateTime * resultptr;
19541 resultptr = new wxDateTime((wxDateTime &)(result));
19542 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19543 }
19544 return resultobj;
19545 fail:
19546 return NULL;
19547 }
19548
19549
19550 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19551 PyObject *resultobj;
19552 wxDateTime *result;
19553 char *kwnames[] = {
19554 NULL
19555 };
19556
19557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19558 {
19559 PyThreadState* __tstate = wxPyBeginAllowThreads();
19560 result = (wxDateTime *)new wxDateTime();
19561
19562 wxPyEndAllowThreads(__tstate);
19563 if (PyErr_Occurred()) SWIG_fail;
19564 }
19565 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19566 return resultobj;
19567 fail:
19568 return NULL;
19569 }
19570
19571
19572 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19573 PyObject *resultobj;
19574 time_t arg1 ;
19575 wxDateTime *result;
19576 PyObject * obj0 = 0 ;
19577 char *kwnames[] = {
19578 (char *) "timet", NULL
19579 };
19580
19581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19582 {
19583 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19584 if (SWIG_arg_fail(1)) SWIG_fail;
19585 }
19586 {
19587 PyThreadState* __tstate = wxPyBeginAllowThreads();
19588 result = (wxDateTime *)new wxDateTime(arg1);
19589
19590 wxPyEndAllowThreads(__tstate);
19591 if (PyErr_Occurred()) SWIG_fail;
19592 }
19593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19594 return resultobj;
19595 fail:
19596 return NULL;
19597 }
19598
19599
19600 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19601 PyObject *resultobj;
19602 double arg1 ;
19603 wxDateTime *result;
19604 PyObject * obj0 = 0 ;
19605 char *kwnames[] = {
19606 (char *) "jdn", NULL
19607 };
19608
19609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19610 {
19611 arg1 = (double)(SWIG_As_double(obj0));
19612 if (SWIG_arg_fail(1)) SWIG_fail;
19613 }
19614 {
19615 PyThreadState* __tstate = wxPyBeginAllowThreads();
19616 result = (wxDateTime *)new wxDateTime(arg1);
19617
19618 wxPyEndAllowThreads(__tstate);
19619 if (PyErr_Occurred()) SWIG_fail;
19620 }
19621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19622 return resultobj;
19623 fail:
19624 return NULL;
19625 }
19626
19627
19628 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19629 PyObject *resultobj;
19630 int arg1 ;
19631 int arg2 = (int) 0 ;
19632 int arg3 = (int) 0 ;
19633 int arg4 = (int) 0 ;
19634 wxDateTime *result;
19635 PyObject * obj0 = 0 ;
19636 PyObject * obj1 = 0 ;
19637 PyObject * obj2 = 0 ;
19638 PyObject * obj3 = 0 ;
19639 char *kwnames[] = {
19640 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19641 };
19642
19643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19644 {
19645 arg1 = (int)(SWIG_As_int(obj0));
19646 if (SWIG_arg_fail(1)) SWIG_fail;
19647 }
19648 if (obj1) {
19649 {
19650 arg2 = (int)(SWIG_As_int(obj1));
19651 if (SWIG_arg_fail(2)) SWIG_fail;
19652 }
19653 }
19654 if (obj2) {
19655 {
19656 arg3 = (int)(SWIG_As_int(obj2));
19657 if (SWIG_arg_fail(3)) SWIG_fail;
19658 }
19659 }
19660 if (obj3) {
19661 {
19662 arg4 = (int)(SWIG_As_int(obj3));
19663 if (SWIG_arg_fail(4)) SWIG_fail;
19664 }
19665 }
19666 {
19667 PyThreadState* __tstate = wxPyBeginAllowThreads();
19668 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19669
19670 wxPyEndAllowThreads(__tstate);
19671 if (PyErr_Occurred()) SWIG_fail;
19672 }
19673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19674 return resultobj;
19675 fail:
19676 return NULL;
19677 }
19678
19679
19680 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19681 PyObject *resultobj;
19682 int arg1 ;
19683 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19684 int arg3 = (int) wxDateTime::Inv_Year ;
19685 int arg4 = (int) 0 ;
19686 int arg5 = (int) 0 ;
19687 int arg6 = (int) 0 ;
19688 int arg7 = (int) 0 ;
19689 wxDateTime *result;
19690 PyObject * obj0 = 0 ;
19691 PyObject * obj1 = 0 ;
19692 PyObject * obj2 = 0 ;
19693 PyObject * obj3 = 0 ;
19694 PyObject * obj4 = 0 ;
19695 PyObject * obj5 = 0 ;
19696 PyObject * obj6 = 0 ;
19697 char *kwnames[] = {
19698 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19699 };
19700
19701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19702 {
19703 arg1 = (int)(SWIG_As_int(obj0));
19704 if (SWIG_arg_fail(1)) SWIG_fail;
19705 }
19706 if (obj1) {
19707 {
19708 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19709 if (SWIG_arg_fail(2)) SWIG_fail;
19710 }
19711 }
19712 if (obj2) {
19713 {
19714 arg3 = (int)(SWIG_As_int(obj2));
19715 if (SWIG_arg_fail(3)) SWIG_fail;
19716 }
19717 }
19718 if (obj3) {
19719 {
19720 arg4 = (int)(SWIG_As_int(obj3));
19721 if (SWIG_arg_fail(4)) SWIG_fail;
19722 }
19723 }
19724 if (obj4) {
19725 {
19726 arg5 = (int)(SWIG_As_int(obj4));
19727 if (SWIG_arg_fail(5)) SWIG_fail;
19728 }
19729 }
19730 if (obj5) {
19731 {
19732 arg6 = (int)(SWIG_As_int(obj5));
19733 if (SWIG_arg_fail(6)) SWIG_fail;
19734 }
19735 }
19736 if (obj6) {
19737 {
19738 arg7 = (int)(SWIG_As_int(obj6));
19739 if (SWIG_arg_fail(7)) SWIG_fail;
19740 }
19741 }
19742 {
19743 PyThreadState* __tstate = wxPyBeginAllowThreads();
19744 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19745
19746 wxPyEndAllowThreads(__tstate);
19747 if (PyErr_Occurred()) SWIG_fail;
19748 }
19749 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19757 PyObject *resultobj;
19758 wxDateTime *arg1 = (wxDateTime *) 0 ;
19759 PyObject * obj0 = 0 ;
19760 char *kwnames[] = {
19761 (char *) "self", NULL
19762 };
19763
19764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
19769 delete arg1;
19770
19771 wxPyEndAllowThreads(__tstate);
19772 if (PyErr_Occurred()) SWIG_fail;
19773 }
19774 Py_INCREF(Py_None); resultobj = Py_None;
19775 return resultobj;
19776 fail:
19777 return NULL;
19778 }
19779
19780
19781 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19782 PyObject *resultobj;
19783 wxDateTime *arg1 = (wxDateTime *) 0 ;
19784 wxDateTime *result;
19785 PyObject * obj0 = 0 ;
19786 char *kwnames[] = {
19787 (char *) "self", NULL
19788 };
19789
19790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19792 if (SWIG_arg_fail(1)) SWIG_fail;
19793 {
19794 PyThreadState* __tstate = wxPyBeginAllowThreads();
19795 {
19796 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19797 result = (wxDateTime *) &_result_ref;
19798 }
19799
19800 wxPyEndAllowThreads(__tstate);
19801 if (PyErr_Occurred()) SWIG_fail;
19802 }
19803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19804 return resultobj;
19805 fail:
19806 return NULL;
19807 }
19808
19809
19810 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19811 PyObject *resultobj;
19812 wxDateTime *arg1 = (wxDateTime *) 0 ;
19813 time_t arg2 ;
19814 wxDateTime *result;
19815 PyObject * obj0 = 0 ;
19816 PyObject * obj1 = 0 ;
19817 char *kwnames[] = {
19818 (char *) "self",(char *) "timet", NULL
19819 };
19820
19821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19823 if (SWIG_arg_fail(1)) SWIG_fail;
19824 {
19825 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19826 if (SWIG_arg_fail(2)) SWIG_fail;
19827 }
19828 {
19829 PyThreadState* __tstate = wxPyBeginAllowThreads();
19830 {
19831 wxDateTime &_result_ref = (arg1)->Set(arg2);
19832 result = (wxDateTime *) &_result_ref;
19833 }
19834
19835 wxPyEndAllowThreads(__tstate);
19836 if (PyErr_Occurred()) SWIG_fail;
19837 }
19838 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19839 return resultobj;
19840 fail:
19841 return NULL;
19842 }
19843
19844
19845 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19846 PyObject *resultobj;
19847 wxDateTime *arg1 = (wxDateTime *) 0 ;
19848 double arg2 ;
19849 wxDateTime *result;
19850 PyObject * obj0 = 0 ;
19851 PyObject * obj1 = 0 ;
19852 char *kwnames[] = {
19853 (char *) "self",(char *) "jdn", NULL
19854 };
19855
19856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19858 if (SWIG_arg_fail(1)) SWIG_fail;
19859 {
19860 arg2 = (double)(SWIG_As_double(obj1));
19861 if (SWIG_arg_fail(2)) SWIG_fail;
19862 }
19863 {
19864 PyThreadState* __tstate = wxPyBeginAllowThreads();
19865 {
19866 wxDateTime &_result_ref = (arg1)->Set(arg2);
19867 result = (wxDateTime *) &_result_ref;
19868 }
19869
19870 wxPyEndAllowThreads(__tstate);
19871 if (PyErr_Occurred()) SWIG_fail;
19872 }
19873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19874 return resultobj;
19875 fail:
19876 return NULL;
19877 }
19878
19879
19880 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19881 PyObject *resultobj;
19882 wxDateTime *arg1 = (wxDateTime *) 0 ;
19883 int arg2 ;
19884 int arg3 = (int) 0 ;
19885 int arg4 = (int) 0 ;
19886 int arg5 = (int) 0 ;
19887 wxDateTime *result;
19888 PyObject * obj0 = 0 ;
19889 PyObject * obj1 = 0 ;
19890 PyObject * obj2 = 0 ;
19891 PyObject * obj3 = 0 ;
19892 PyObject * obj4 = 0 ;
19893 char *kwnames[] = {
19894 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19895 };
19896
19897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19899 if (SWIG_arg_fail(1)) SWIG_fail;
19900 {
19901 arg2 = (int)(SWIG_As_int(obj1));
19902 if (SWIG_arg_fail(2)) SWIG_fail;
19903 }
19904 if (obj2) {
19905 {
19906 arg3 = (int)(SWIG_As_int(obj2));
19907 if (SWIG_arg_fail(3)) SWIG_fail;
19908 }
19909 }
19910 if (obj3) {
19911 {
19912 arg4 = (int)(SWIG_As_int(obj3));
19913 if (SWIG_arg_fail(4)) SWIG_fail;
19914 }
19915 }
19916 if (obj4) {
19917 {
19918 arg5 = (int)(SWIG_As_int(obj4));
19919 if (SWIG_arg_fail(5)) SWIG_fail;
19920 }
19921 }
19922 {
19923 PyThreadState* __tstate = wxPyBeginAllowThreads();
19924 {
19925 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19926 result = (wxDateTime *) &_result_ref;
19927 }
19928
19929 wxPyEndAllowThreads(__tstate);
19930 if (PyErr_Occurred()) SWIG_fail;
19931 }
19932 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19933 return resultobj;
19934 fail:
19935 return NULL;
19936 }
19937
19938
19939 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19940 PyObject *resultobj;
19941 wxDateTime *arg1 = (wxDateTime *) 0 ;
19942 int arg2 ;
19943 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19944 int arg4 = (int) wxDateTime::Inv_Year ;
19945 int arg5 = (int) 0 ;
19946 int arg6 = (int) 0 ;
19947 int arg7 = (int) 0 ;
19948 int arg8 = (int) 0 ;
19949 wxDateTime *result;
19950 PyObject * obj0 = 0 ;
19951 PyObject * obj1 = 0 ;
19952 PyObject * obj2 = 0 ;
19953 PyObject * obj3 = 0 ;
19954 PyObject * obj4 = 0 ;
19955 PyObject * obj5 = 0 ;
19956 PyObject * obj6 = 0 ;
19957 PyObject * obj7 = 0 ;
19958 char *kwnames[] = {
19959 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19960 };
19961
19962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19964 if (SWIG_arg_fail(1)) SWIG_fail;
19965 {
19966 arg2 = (int)(SWIG_As_int(obj1));
19967 if (SWIG_arg_fail(2)) SWIG_fail;
19968 }
19969 if (obj2) {
19970 {
19971 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19972 if (SWIG_arg_fail(3)) SWIG_fail;
19973 }
19974 }
19975 if (obj3) {
19976 {
19977 arg4 = (int)(SWIG_As_int(obj3));
19978 if (SWIG_arg_fail(4)) SWIG_fail;
19979 }
19980 }
19981 if (obj4) {
19982 {
19983 arg5 = (int)(SWIG_As_int(obj4));
19984 if (SWIG_arg_fail(5)) SWIG_fail;
19985 }
19986 }
19987 if (obj5) {
19988 {
19989 arg6 = (int)(SWIG_As_int(obj5));
19990 if (SWIG_arg_fail(6)) SWIG_fail;
19991 }
19992 }
19993 if (obj6) {
19994 {
19995 arg7 = (int)(SWIG_As_int(obj6));
19996 if (SWIG_arg_fail(7)) SWIG_fail;
19997 }
19998 }
19999 if (obj7) {
20000 {
20001 arg8 = (int)(SWIG_As_int(obj7));
20002 if (SWIG_arg_fail(8)) SWIG_fail;
20003 }
20004 }
20005 {
20006 PyThreadState* __tstate = wxPyBeginAllowThreads();
20007 {
20008 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20009 result = (wxDateTime *) &_result_ref;
20010 }
20011
20012 wxPyEndAllowThreads(__tstate);
20013 if (PyErr_Occurred()) SWIG_fail;
20014 }
20015 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20016 return resultobj;
20017 fail:
20018 return NULL;
20019 }
20020
20021
20022 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20023 PyObject *resultobj;
20024 wxDateTime *arg1 = (wxDateTime *) 0 ;
20025 wxDateTime *result;
20026 PyObject * obj0 = 0 ;
20027 char *kwnames[] = {
20028 (char *) "self", NULL
20029 };
20030
20031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20033 if (SWIG_arg_fail(1)) SWIG_fail;
20034 {
20035 PyThreadState* __tstate = wxPyBeginAllowThreads();
20036 {
20037 wxDateTime &_result_ref = (arg1)->ResetTime();
20038 result = (wxDateTime *) &_result_ref;
20039 }
20040
20041 wxPyEndAllowThreads(__tstate);
20042 if (PyErr_Occurred()) SWIG_fail;
20043 }
20044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20045 return resultobj;
20046 fail:
20047 return NULL;
20048 }
20049
20050
20051 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20052 PyObject *resultobj;
20053 wxDateTime *arg1 = (wxDateTime *) 0 ;
20054 int arg2 ;
20055 wxDateTime *result;
20056 PyObject * obj0 = 0 ;
20057 PyObject * obj1 = 0 ;
20058 char *kwnames[] = {
20059 (char *) "self",(char *) "year", NULL
20060 };
20061
20062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20064 if (SWIG_arg_fail(1)) SWIG_fail;
20065 {
20066 arg2 = (int)(SWIG_As_int(obj1));
20067 if (SWIG_arg_fail(2)) SWIG_fail;
20068 }
20069 {
20070 PyThreadState* __tstate = wxPyBeginAllowThreads();
20071 {
20072 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20073 result = (wxDateTime *) &_result_ref;
20074 }
20075
20076 wxPyEndAllowThreads(__tstate);
20077 if (PyErr_Occurred()) SWIG_fail;
20078 }
20079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20080 return resultobj;
20081 fail:
20082 return NULL;
20083 }
20084
20085
20086 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20087 PyObject *resultobj;
20088 wxDateTime *arg1 = (wxDateTime *) 0 ;
20089 wxDateTime::Month arg2 ;
20090 wxDateTime *result;
20091 PyObject * obj0 = 0 ;
20092 PyObject * obj1 = 0 ;
20093 char *kwnames[] = {
20094 (char *) "self",(char *) "month", NULL
20095 };
20096
20097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20099 if (SWIG_arg_fail(1)) SWIG_fail;
20100 {
20101 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20102 if (SWIG_arg_fail(2)) SWIG_fail;
20103 }
20104 {
20105 PyThreadState* __tstate = wxPyBeginAllowThreads();
20106 {
20107 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20108 result = (wxDateTime *) &_result_ref;
20109 }
20110
20111 wxPyEndAllowThreads(__tstate);
20112 if (PyErr_Occurred()) SWIG_fail;
20113 }
20114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20115 return resultobj;
20116 fail:
20117 return NULL;
20118 }
20119
20120
20121 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20122 PyObject *resultobj;
20123 wxDateTime *arg1 = (wxDateTime *) 0 ;
20124 int arg2 ;
20125 wxDateTime *result;
20126 PyObject * obj0 = 0 ;
20127 PyObject * obj1 = 0 ;
20128 char *kwnames[] = {
20129 (char *) "self",(char *) "day", NULL
20130 };
20131
20132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20134 if (SWIG_arg_fail(1)) SWIG_fail;
20135 {
20136 arg2 = (int)(SWIG_As_int(obj1));
20137 if (SWIG_arg_fail(2)) SWIG_fail;
20138 }
20139 {
20140 PyThreadState* __tstate = wxPyBeginAllowThreads();
20141 {
20142 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20143 result = (wxDateTime *) &_result_ref;
20144 }
20145
20146 wxPyEndAllowThreads(__tstate);
20147 if (PyErr_Occurred()) SWIG_fail;
20148 }
20149 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20150 return resultobj;
20151 fail:
20152 return NULL;
20153 }
20154
20155
20156 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20157 PyObject *resultobj;
20158 wxDateTime *arg1 = (wxDateTime *) 0 ;
20159 int arg2 ;
20160 wxDateTime *result;
20161 PyObject * obj0 = 0 ;
20162 PyObject * obj1 = 0 ;
20163 char *kwnames[] = {
20164 (char *) "self",(char *) "hour", NULL
20165 };
20166
20167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20169 if (SWIG_arg_fail(1)) SWIG_fail;
20170 {
20171 arg2 = (int)(SWIG_As_int(obj1));
20172 if (SWIG_arg_fail(2)) SWIG_fail;
20173 }
20174 {
20175 PyThreadState* __tstate = wxPyBeginAllowThreads();
20176 {
20177 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20178 result = (wxDateTime *) &_result_ref;
20179 }
20180
20181 wxPyEndAllowThreads(__tstate);
20182 if (PyErr_Occurred()) SWIG_fail;
20183 }
20184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20185 return resultobj;
20186 fail:
20187 return NULL;
20188 }
20189
20190
20191 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20192 PyObject *resultobj;
20193 wxDateTime *arg1 = (wxDateTime *) 0 ;
20194 int arg2 ;
20195 wxDateTime *result;
20196 PyObject * obj0 = 0 ;
20197 PyObject * obj1 = 0 ;
20198 char *kwnames[] = {
20199 (char *) "self",(char *) "minute", NULL
20200 };
20201
20202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20204 if (SWIG_arg_fail(1)) SWIG_fail;
20205 {
20206 arg2 = (int)(SWIG_As_int(obj1));
20207 if (SWIG_arg_fail(2)) SWIG_fail;
20208 }
20209 {
20210 PyThreadState* __tstate = wxPyBeginAllowThreads();
20211 {
20212 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20213 result = (wxDateTime *) &_result_ref;
20214 }
20215
20216 wxPyEndAllowThreads(__tstate);
20217 if (PyErr_Occurred()) SWIG_fail;
20218 }
20219 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20220 return resultobj;
20221 fail:
20222 return NULL;
20223 }
20224
20225
20226 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20227 PyObject *resultobj;
20228 wxDateTime *arg1 = (wxDateTime *) 0 ;
20229 int arg2 ;
20230 wxDateTime *result;
20231 PyObject * obj0 = 0 ;
20232 PyObject * obj1 = 0 ;
20233 char *kwnames[] = {
20234 (char *) "self",(char *) "second", NULL
20235 };
20236
20237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20239 if (SWIG_arg_fail(1)) SWIG_fail;
20240 {
20241 arg2 = (int)(SWIG_As_int(obj1));
20242 if (SWIG_arg_fail(2)) SWIG_fail;
20243 }
20244 {
20245 PyThreadState* __tstate = wxPyBeginAllowThreads();
20246 {
20247 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20248 result = (wxDateTime *) &_result_ref;
20249 }
20250
20251 wxPyEndAllowThreads(__tstate);
20252 if (PyErr_Occurred()) SWIG_fail;
20253 }
20254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20255 return resultobj;
20256 fail:
20257 return NULL;
20258 }
20259
20260
20261 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20262 PyObject *resultobj;
20263 wxDateTime *arg1 = (wxDateTime *) 0 ;
20264 int arg2 ;
20265 wxDateTime *result;
20266 PyObject * obj0 = 0 ;
20267 PyObject * obj1 = 0 ;
20268 char *kwnames[] = {
20269 (char *) "self",(char *) "millisecond", NULL
20270 };
20271
20272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20274 if (SWIG_arg_fail(1)) SWIG_fail;
20275 {
20276 arg2 = (int)(SWIG_As_int(obj1));
20277 if (SWIG_arg_fail(2)) SWIG_fail;
20278 }
20279 {
20280 PyThreadState* __tstate = wxPyBeginAllowThreads();
20281 {
20282 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20283 result = (wxDateTime *) &_result_ref;
20284 }
20285
20286 wxPyEndAllowThreads(__tstate);
20287 if (PyErr_Occurred()) SWIG_fail;
20288 }
20289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20290 return resultobj;
20291 fail:
20292 return NULL;
20293 }
20294
20295
20296 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20297 PyObject *resultobj;
20298 wxDateTime *arg1 = (wxDateTime *) 0 ;
20299 wxDateTime::WeekDay arg2 ;
20300 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20301 wxDateTime *result;
20302 PyObject * obj0 = 0 ;
20303 PyObject * obj1 = 0 ;
20304 PyObject * obj2 = 0 ;
20305 char *kwnames[] = {
20306 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20307 };
20308
20309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20311 if (SWIG_arg_fail(1)) SWIG_fail;
20312 {
20313 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20314 if (SWIG_arg_fail(2)) SWIG_fail;
20315 }
20316 if (obj2) {
20317 {
20318 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20319 if (SWIG_arg_fail(3)) SWIG_fail;
20320 }
20321 }
20322 {
20323 PyThreadState* __tstate = wxPyBeginAllowThreads();
20324 {
20325 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20326 result = (wxDateTime *) &_result_ref;
20327 }
20328
20329 wxPyEndAllowThreads(__tstate);
20330 if (PyErr_Occurred()) SWIG_fail;
20331 }
20332 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20333 return resultobj;
20334 fail:
20335 return NULL;
20336 }
20337
20338
20339 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20340 PyObject *resultobj;
20341 wxDateTime *arg1 = (wxDateTime *) 0 ;
20342 wxDateTime::WeekDay arg2 ;
20343 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20344 wxDateTime result;
20345 PyObject * obj0 = 0 ;
20346 PyObject * obj1 = 0 ;
20347 PyObject * obj2 = 0 ;
20348 char *kwnames[] = {
20349 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20350 };
20351
20352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20354 if (SWIG_arg_fail(1)) SWIG_fail;
20355 {
20356 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20357 if (SWIG_arg_fail(2)) SWIG_fail;
20358 }
20359 if (obj2) {
20360 {
20361 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20362 if (SWIG_arg_fail(3)) SWIG_fail;
20363 }
20364 }
20365 {
20366 PyThreadState* __tstate = wxPyBeginAllowThreads();
20367 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20368
20369 wxPyEndAllowThreads(__tstate);
20370 if (PyErr_Occurred()) SWIG_fail;
20371 }
20372 {
20373 wxDateTime * resultptr;
20374 resultptr = new wxDateTime((wxDateTime &)(result));
20375 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20376 }
20377 return resultobj;
20378 fail:
20379 return NULL;
20380 }
20381
20382
20383 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20384 PyObject *resultobj;
20385 wxDateTime *arg1 = (wxDateTime *) 0 ;
20386 wxDateTime::WeekDay arg2 ;
20387 wxDateTime *result;
20388 PyObject * obj0 = 0 ;
20389 PyObject * obj1 = 0 ;
20390 char *kwnames[] = {
20391 (char *) "self",(char *) "weekday", NULL
20392 };
20393
20394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20396 if (SWIG_arg_fail(1)) SWIG_fail;
20397 {
20398 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20399 if (SWIG_arg_fail(2)) SWIG_fail;
20400 }
20401 {
20402 PyThreadState* __tstate = wxPyBeginAllowThreads();
20403 {
20404 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20405 result = (wxDateTime *) &_result_ref;
20406 }
20407
20408 wxPyEndAllowThreads(__tstate);
20409 if (PyErr_Occurred()) SWIG_fail;
20410 }
20411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20412 return resultobj;
20413 fail:
20414 return NULL;
20415 }
20416
20417
20418 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20419 PyObject *resultobj;
20420 wxDateTime *arg1 = (wxDateTime *) 0 ;
20421 wxDateTime::WeekDay arg2 ;
20422 wxDateTime result;
20423 PyObject * obj0 = 0 ;
20424 PyObject * obj1 = 0 ;
20425 char *kwnames[] = {
20426 (char *) "self",(char *) "weekday", NULL
20427 };
20428
20429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20431 if (SWIG_arg_fail(1)) SWIG_fail;
20432 {
20433 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20434 if (SWIG_arg_fail(2)) SWIG_fail;
20435 }
20436 {
20437 PyThreadState* __tstate = wxPyBeginAllowThreads();
20438 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20439
20440 wxPyEndAllowThreads(__tstate);
20441 if (PyErr_Occurred()) SWIG_fail;
20442 }
20443 {
20444 wxDateTime * resultptr;
20445 resultptr = new wxDateTime((wxDateTime &)(result));
20446 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20447 }
20448 return resultobj;
20449 fail:
20450 return NULL;
20451 }
20452
20453
20454 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20455 PyObject *resultobj;
20456 wxDateTime *arg1 = (wxDateTime *) 0 ;
20457 wxDateTime::WeekDay arg2 ;
20458 wxDateTime *result;
20459 PyObject * obj0 = 0 ;
20460 PyObject * obj1 = 0 ;
20461 char *kwnames[] = {
20462 (char *) "self",(char *) "weekday", NULL
20463 };
20464
20465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) 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 {
20473 PyThreadState* __tstate = wxPyBeginAllowThreads();
20474 {
20475 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20476 result = (wxDateTime *) &_result_ref;
20477 }
20478
20479 wxPyEndAllowThreads(__tstate);
20480 if (PyErr_Occurred()) SWIG_fail;
20481 }
20482 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20483 return resultobj;
20484 fail:
20485 return NULL;
20486 }
20487
20488
20489 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20490 PyObject *resultobj;
20491 wxDateTime *arg1 = (wxDateTime *) 0 ;
20492 wxDateTime::WeekDay arg2 ;
20493 wxDateTime result;
20494 PyObject * obj0 = 0 ;
20495 PyObject * obj1 = 0 ;
20496 char *kwnames[] = {
20497 (char *) "self",(char *) "weekday", NULL
20498 };
20499
20500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20502 if (SWIG_arg_fail(1)) SWIG_fail;
20503 {
20504 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20505 if (SWIG_arg_fail(2)) SWIG_fail;
20506 }
20507 {
20508 PyThreadState* __tstate = wxPyBeginAllowThreads();
20509 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20510
20511 wxPyEndAllowThreads(__tstate);
20512 if (PyErr_Occurred()) SWIG_fail;
20513 }
20514 {
20515 wxDateTime * resultptr;
20516 resultptr = new wxDateTime((wxDateTime &)(result));
20517 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20518 }
20519 return resultobj;
20520 fail:
20521 return NULL;
20522 }
20523
20524
20525 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20526 PyObject *resultobj;
20527 wxDateTime *arg1 = (wxDateTime *) 0 ;
20528 wxDateTime::WeekDay arg2 ;
20529 int arg3 = (int) 1 ;
20530 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20531 int arg5 = (int) wxDateTime::Inv_Year ;
20532 bool result;
20533 PyObject * obj0 = 0 ;
20534 PyObject * obj1 = 0 ;
20535 PyObject * obj2 = 0 ;
20536 PyObject * obj3 = 0 ;
20537 PyObject * obj4 = 0 ;
20538 char *kwnames[] = {
20539 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20540 };
20541
20542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20544 if (SWIG_arg_fail(1)) SWIG_fail;
20545 {
20546 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20547 if (SWIG_arg_fail(2)) SWIG_fail;
20548 }
20549 if (obj2) {
20550 {
20551 arg3 = (int)(SWIG_As_int(obj2));
20552 if (SWIG_arg_fail(3)) SWIG_fail;
20553 }
20554 }
20555 if (obj3) {
20556 {
20557 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20558 if (SWIG_arg_fail(4)) SWIG_fail;
20559 }
20560 }
20561 if (obj4) {
20562 {
20563 arg5 = (int)(SWIG_As_int(obj4));
20564 if (SWIG_arg_fail(5)) SWIG_fail;
20565 }
20566 }
20567 {
20568 PyThreadState* __tstate = wxPyBeginAllowThreads();
20569 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20570
20571 wxPyEndAllowThreads(__tstate);
20572 if (PyErr_Occurred()) SWIG_fail;
20573 }
20574 {
20575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20576 }
20577 return resultobj;
20578 fail:
20579 return NULL;
20580 }
20581
20582
20583 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20584 PyObject *resultobj;
20585 wxDateTime *arg1 = (wxDateTime *) 0 ;
20586 wxDateTime::WeekDay arg2 ;
20587 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20588 int arg4 = (int) wxDateTime::Inv_Year ;
20589 bool result;
20590 PyObject * obj0 = 0 ;
20591 PyObject * obj1 = 0 ;
20592 PyObject * obj2 = 0 ;
20593 PyObject * obj3 = 0 ;
20594 char *kwnames[] = {
20595 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20596 };
20597
20598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20600 if (SWIG_arg_fail(1)) SWIG_fail;
20601 {
20602 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20603 if (SWIG_arg_fail(2)) SWIG_fail;
20604 }
20605 if (obj2) {
20606 {
20607 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20608 if (SWIG_arg_fail(3)) SWIG_fail;
20609 }
20610 }
20611 if (obj3) {
20612 {
20613 arg4 = (int)(SWIG_As_int(obj3));
20614 if (SWIG_arg_fail(4)) SWIG_fail;
20615 }
20616 }
20617 {
20618 PyThreadState* __tstate = wxPyBeginAllowThreads();
20619 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20620
20621 wxPyEndAllowThreads(__tstate);
20622 if (PyErr_Occurred()) SWIG_fail;
20623 }
20624 {
20625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20626 }
20627 return resultobj;
20628 fail:
20629 return NULL;
20630 }
20631
20632
20633 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20634 PyObject *resultobj;
20635 wxDateTime *arg1 = (wxDateTime *) 0 ;
20636 wxDateTime::WeekDay arg2 ;
20637 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20638 int arg4 = (int) wxDateTime::Inv_Year ;
20639 wxDateTime result;
20640 PyObject * obj0 = 0 ;
20641 PyObject * obj1 = 0 ;
20642 PyObject * obj2 = 0 ;
20643 PyObject * obj3 = 0 ;
20644 char *kwnames[] = {
20645 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20646 };
20647
20648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20650 if (SWIG_arg_fail(1)) SWIG_fail;
20651 {
20652 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20653 if (SWIG_arg_fail(2)) SWIG_fail;
20654 }
20655 if (obj2) {
20656 {
20657 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20658 if (SWIG_arg_fail(3)) SWIG_fail;
20659 }
20660 }
20661 if (obj3) {
20662 {
20663 arg4 = (int)(SWIG_As_int(obj3));
20664 if (SWIG_arg_fail(4)) SWIG_fail;
20665 }
20666 }
20667 {
20668 PyThreadState* __tstate = wxPyBeginAllowThreads();
20669 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20670
20671 wxPyEndAllowThreads(__tstate);
20672 if (PyErr_Occurred()) SWIG_fail;
20673 }
20674 {
20675 wxDateTime * resultptr;
20676 resultptr = new wxDateTime((wxDateTime &)(result));
20677 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20678 }
20679 return resultobj;
20680 fail:
20681 return NULL;
20682 }
20683
20684
20685 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20686 PyObject *resultobj;
20687 wxDateTime *arg1 = (wxDateTime *) 0 ;
20688 int arg2 ;
20689 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20690 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20691 bool result;
20692 PyObject * obj0 = 0 ;
20693 PyObject * obj1 = 0 ;
20694 PyObject * obj2 = 0 ;
20695 PyObject * obj3 = 0 ;
20696 char *kwnames[] = {
20697 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20698 };
20699
20700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20702 if (SWIG_arg_fail(1)) SWIG_fail;
20703 {
20704 arg2 = (int)(SWIG_As_int(obj1));
20705 if (SWIG_arg_fail(2)) SWIG_fail;
20706 }
20707 if (obj2) {
20708 {
20709 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20710 if (SWIG_arg_fail(3)) SWIG_fail;
20711 }
20712 }
20713 if (obj3) {
20714 {
20715 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20716 if (SWIG_arg_fail(4)) SWIG_fail;
20717 }
20718 }
20719 {
20720 PyThreadState* __tstate = wxPyBeginAllowThreads();
20721 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20722
20723 wxPyEndAllowThreads(__tstate);
20724 if (PyErr_Occurred()) SWIG_fail;
20725 }
20726 {
20727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20728 }
20729 return resultobj;
20730 fail:
20731 return NULL;
20732 }
20733
20734
20735 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20736 PyObject *resultobj;
20737 wxDateTime *arg1 = (wxDateTime *) 0 ;
20738 int arg2 ;
20739 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20740 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20741 wxDateTime result;
20742 PyObject * obj0 = 0 ;
20743 PyObject * obj1 = 0 ;
20744 PyObject * obj2 = 0 ;
20745 PyObject * obj3 = 0 ;
20746 char *kwnames[] = {
20747 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20748 };
20749
20750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20752 if (SWIG_arg_fail(1)) SWIG_fail;
20753 {
20754 arg2 = (int)(SWIG_As_int(obj1));
20755 if (SWIG_arg_fail(2)) SWIG_fail;
20756 }
20757 if (obj2) {
20758 {
20759 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20760 if (SWIG_arg_fail(3)) SWIG_fail;
20761 }
20762 }
20763 if (obj3) {
20764 {
20765 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20766 if (SWIG_arg_fail(4)) SWIG_fail;
20767 }
20768 }
20769 {
20770 PyThreadState* __tstate = wxPyBeginAllowThreads();
20771 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20772
20773 wxPyEndAllowThreads(__tstate);
20774 if (PyErr_Occurred()) SWIG_fail;
20775 }
20776 {
20777 wxDateTime * resultptr;
20778 resultptr = new wxDateTime((wxDateTime &)(result));
20779 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20780 }
20781 return resultobj;
20782 fail:
20783 return NULL;
20784 }
20785
20786
20787 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20788 PyObject *resultobj;
20789 int arg1 ;
20790 int arg2 ;
20791 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20792 wxDateTime result;
20793 PyObject * obj0 = 0 ;
20794 PyObject * obj1 = 0 ;
20795 PyObject * obj2 = 0 ;
20796 char *kwnames[] = {
20797 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20798 };
20799
20800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20801 {
20802 arg1 = (int)(SWIG_As_int(obj0));
20803 if (SWIG_arg_fail(1)) SWIG_fail;
20804 }
20805 {
20806 arg2 = (int)(SWIG_As_int(obj1));
20807 if (SWIG_arg_fail(2)) SWIG_fail;
20808 }
20809 if (obj2) {
20810 {
20811 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20812 if (SWIG_arg_fail(3)) SWIG_fail;
20813 }
20814 }
20815 {
20816 PyThreadState* __tstate = wxPyBeginAllowThreads();
20817 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20818
20819 wxPyEndAllowThreads(__tstate);
20820 if (PyErr_Occurred()) SWIG_fail;
20821 }
20822 {
20823 wxDateTime * resultptr;
20824 resultptr = new wxDateTime((wxDateTime &)(result));
20825 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20826 }
20827 return resultobj;
20828 fail:
20829 return NULL;
20830 }
20831
20832
20833 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20834 PyObject *resultobj;
20835 wxDateTime *arg1 = (wxDateTime *) 0 ;
20836 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20837 int arg3 = (int) wxDateTime::Inv_Year ;
20838 wxDateTime *result;
20839 PyObject * obj0 = 0 ;
20840 PyObject * obj1 = 0 ;
20841 PyObject * obj2 = 0 ;
20842 char *kwnames[] = {
20843 (char *) "self",(char *) "month",(char *) "year", NULL
20844 };
20845
20846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20848 if (SWIG_arg_fail(1)) SWIG_fail;
20849 if (obj1) {
20850 {
20851 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20852 if (SWIG_arg_fail(2)) SWIG_fail;
20853 }
20854 }
20855 if (obj2) {
20856 {
20857 arg3 = (int)(SWIG_As_int(obj2));
20858 if (SWIG_arg_fail(3)) SWIG_fail;
20859 }
20860 }
20861 {
20862 PyThreadState* __tstate = wxPyBeginAllowThreads();
20863 {
20864 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20865 result = (wxDateTime *) &_result_ref;
20866 }
20867
20868 wxPyEndAllowThreads(__tstate);
20869 if (PyErr_Occurred()) SWIG_fail;
20870 }
20871 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20872 return resultobj;
20873 fail:
20874 return NULL;
20875 }
20876
20877
20878 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20879 PyObject *resultobj;
20880 wxDateTime *arg1 = (wxDateTime *) 0 ;
20881 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20882 int arg3 = (int) wxDateTime::Inv_Year ;
20883 wxDateTime result;
20884 PyObject * obj0 = 0 ;
20885 PyObject * obj1 = 0 ;
20886 PyObject * obj2 = 0 ;
20887 char *kwnames[] = {
20888 (char *) "self",(char *) "month",(char *) "year", NULL
20889 };
20890
20891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20893 if (SWIG_arg_fail(1)) SWIG_fail;
20894 if (obj1) {
20895 {
20896 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20897 if (SWIG_arg_fail(2)) SWIG_fail;
20898 }
20899 }
20900 if (obj2) {
20901 {
20902 arg3 = (int)(SWIG_As_int(obj2));
20903 if (SWIG_arg_fail(3)) SWIG_fail;
20904 }
20905 }
20906 {
20907 PyThreadState* __tstate = wxPyBeginAllowThreads();
20908 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20909
20910 wxPyEndAllowThreads(__tstate);
20911 if (PyErr_Occurred()) SWIG_fail;
20912 }
20913 {
20914 wxDateTime * resultptr;
20915 resultptr = new wxDateTime((wxDateTime &)(result));
20916 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20917 }
20918 return resultobj;
20919 fail:
20920 return NULL;
20921 }
20922
20923
20924 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20925 PyObject *resultobj;
20926 wxDateTime *arg1 = (wxDateTime *) 0 ;
20927 int arg2 ;
20928 wxDateTime *result;
20929 PyObject * obj0 = 0 ;
20930 PyObject * obj1 = 0 ;
20931 char *kwnames[] = {
20932 (char *) "self",(char *) "yday", NULL
20933 };
20934
20935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20937 if (SWIG_arg_fail(1)) SWIG_fail;
20938 {
20939 arg2 = (int)(SWIG_As_int(obj1));
20940 if (SWIG_arg_fail(2)) SWIG_fail;
20941 }
20942 {
20943 PyThreadState* __tstate = wxPyBeginAllowThreads();
20944 {
20945 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20946 result = (wxDateTime *) &_result_ref;
20947 }
20948
20949 wxPyEndAllowThreads(__tstate);
20950 if (PyErr_Occurred()) SWIG_fail;
20951 }
20952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20953 return resultobj;
20954 fail:
20955 return NULL;
20956 }
20957
20958
20959 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20960 PyObject *resultobj;
20961 wxDateTime *arg1 = (wxDateTime *) 0 ;
20962 int arg2 ;
20963 wxDateTime result;
20964 PyObject * obj0 = 0 ;
20965 PyObject * obj1 = 0 ;
20966 char *kwnames[] = {
20967 (char *) "self",(char *) "yday", NULL
20968 };
20969
20970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20972 if (SWIG_arg_fail(1)) SWIG_fail;
20973 {
20974 arg2 = (int)(SWIG_As_int(obj1));
20975 if (SWIG_arg_fail(2)) SWIG_fail;
20976 }
20977 {
20978 PyThreadState* __tstate = wxPyBeginAllowThreads();
20979 result = (arg1)->GetYearDay(arg2);
20980
20981 wxPyEndAllowThreads(__tstate);
20982 if (PyErr_Occurred()) SWIG_fail;
20983 }
20984 {
20985 wxDateTime * resultptr;
20986 resultptr = new wxDateTime((wxDateTime &)(result));
20987 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20988 }
20989 return resultobj;
20990 fail:
20991 return NULL;
20992 }
20993
20994
20995 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20996 PyObject *resultobj;
20997 wxDateTime *arg1 = (wxDateTime *) 0 ;
20998 double result;
20999 PyObject * obj0 = 0 ;
21000 char *kwnames[] = {
21001 (char *) "self", NULL
21002 };
21003
21004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21006 if (SWIG_arg_fail(1)) SWIG_fail;
21007 {
21008 PyThreadState* __tstate = wxPyBeginAllowThreads();
21009 result = (double)(arg1)->GetJulianDayNumber();
21010
21011 wxPyEndAllowThreads(__tstate);
21012 if (PyErr_Occurred()) SWIG_fail;
21013 }
21014 {
21015 resultobj = SWIG_From_double((double)(result));
21016 }
21017 return resultobj;
21018 fail:
21019 return NULL;
21020 }
21021
21022
21023 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21024 PyObject *resultobj;
21025 wxDateTime *arg1 = (wxDateTime *) 0 ;
21026 double result;
21027 PyObject * obj0 = 0 ;
21028 char *kwnames[] = {
21029 (char *) "self", NULL
21030 };
21031
21032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21034 if (SWIG_arg_fail(1)) SWIG_fail;
21035 {
21036 PyThreadState* __tstate = wxPyBeginAllowThreads();
21037 result = (double)(arg1)->GetJDN();
21038
21039 wxPyEndAllowThreads(__tstate);
21040 if (PyErr_Occurred()) SWIG_fail;
21041 }
21042 {
21043 resultobj = SWIG_From_double((double)(result));
21044 }
21045 return resultobj;
21046 fail:
21047 return NULL;
21048 }
21049
21050
21051 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21052 PyObject *resultobj;
21053 wxDateTime *arg1 = (wxDateTime *) 0 ;
21054 double result;
21055 PyObject * obj0 = 0 ;
21056 char *kwnames[] = {
21057 (char *) "self", NULL
21058 };
21059
21060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21062 if (SWIG_arg_fail(1)) SWIG_fail;
21063 {
21064 PyThreadState* __tstate = wxPyBeginAllowThreads();
21065 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21066
21067 wxPyEndAllowThreads(__tstate);
21068 if (PyErr_Occurred()) SWIG_fail;
21069 }
21070 {
21071 resultobj = SWIG_From_double((double)(result));
21072 }
21073 return resultobj;
21074 fail:
21075 return NULL;
21076 }
21077
21078
21079 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21080 PyObject *resultobj;
21081 wxDateTime *arg1 = (wxDateTime *) 0 ;
21082 double result;
21083 PyObject * obj0 = 0 ;
21084 char *kwnames[] = {
21085 (char *) "self", NULL
21086 };
21087
21088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21090 if (SWIG_arg_fail(1)) SWIG_fail;
21091 {
21092 PyThreadState* __tstate = wxPyBeginAllowThreads();
21093 result = (double)(arg1)->GetMJD();
21094
21095 wxPyEndAllowThreads(__tstate);
21096 if (PyErr_Occurred()) SWIG_fail;
21097 }
21098 {
21099 resultobj = SWIG_From_double((double)(result));
21100 }
21101 return resultobj;
21102 fail:
21103 return NULL;
21104 }
21105
21106
21107 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21108 PyObject *resultobj;
21109 wxDateTime *arg1 = (wxDateTime *) 0 ;
21110 double result;
21111 PyObject * obj0 = 0 ;
21112 char *kwnames[] = {
21113 (char *) "self", NULL
21114 };
21115
21116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21118 if (SWIG_arg_fail(1)) SWIG_fail;
21119 {
21120 PyThreadState* __tstate = wxPyBeginAllowThreads();
21121 result = (double)(arg1)->GetRataDie();
21122
21123 wxPyEndAllowThreads(__tstate);
21124 if (PyErr_Occurred()) SWIG_fail;
21125 }
21126 {
21127 resultobj = SWIG_From_double((double)(result));
21128 }
21129 return resultobj;
21130 fail:
21131 return NULL;
21132 }
21133
21134
21135 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21136 PyObject *resultobj;
21137 wxDateTime *arg1 = (wxDateTime *) 0 ;
21138 wxDateTime::TimeZone *arg2 = 0 ;
21139 bool arg3 = (bool) false ;
21140 wxDateTime result;
21141 bool temp2 = false ;
21142 PyObject * obj0 = 0 ;
21143 PyObject * obj1 = 0 ;
21144 PyObject * obj2 = 0 ;
21145 char *kwnames[] = {
21146 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21147 };
21148
21149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21151 if (SWIG_arg_fail(1)) SWIG_fail;
21152 {
21153 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21154 temp2 = true;
21155 }
21156 if (obj2) {
21157 {
21158 arg3 = (bool)(SWIG_As_bool(obj2));
21159 if (SWIG_arg_fail(3)) SWIG_fail;
21160 }
21161 }
21162 {
21163 PyThreadState* __tstate = wxPyBeginAllowThreads();
21164 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21165
21166 wxPyEndAllowThreads(__tstate);
21167 if (PyErr_Occurred()) SWIG_fail;
21168 }
21169 {
21170 wxDateTime * resultptr;
21171 resultptr = new wxDateTime((wxDateTime &)(result));
21172 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21173 }
21174 {
21175 if (temp2) delete arg2;
21176 }
21177 return resultobj;
21178 fail:
21179 {
21180 if (temp2) delete arg2;
21181 }
21182 return NULL;
21183 }
21184
21185
21186 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21187 PyObject *resultobj;
21188 wxDateTime *arg1 = (wxDateTime *) 0 ;
21189 wxDateTime::TimeZone *arg2 = 0 ;
21190 bool arg3 = (bool) false ;
21191 wxDateTime *result;
21192 bool temp2 = false ;
21193 PyObject * obj0 = 0 ;
21194 PyObject * obj1 = 0 ;
21195 PyObject * obj2 = 0 ;
21196 char *kwnames[] = {
21197 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21198 };
21199
21200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21202 if (SWIG_arg_fail(1)) SWIG_fail;
21203 {
21204 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21205 temp2 = true;
21206 }
21207 if (obj2) {
21208 {
21209 arg3 = (bool)(SWIG_As_bool(obj2));
21210 if (SWIG_arg_fail(3)) SWIG_fail;
21211 }
21212 }
21213 {
21214 PyThreadState* __tstate = wxPyBeginAllowThreads();
21215 {
21216 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21217 result = (wxDateTime *) &_result_ref;
21218 }
21219
21220 wxPyEndAllowThreads(__tstate);
21221 if (PyErr_Occurred()) SWIG_fail;
21222 }
21223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21224 {
21225 if (temp2) delete arg2;
21226 }
21227 return resultobj;
21228 fail:
21229 {
21230 if (temp2) delete arg2;
21231 }
21232 return NULL;
21233 }
21234
21235
21236 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21237 PyObject *resultobj;
21238 wxDateTime *arg1 = (wxDateTime *) 0 ;
21239 bool arg2 = (bool) false ;
21240 wxDateTime result;
21241 PyObject * obj0 = 0 ;
21242 PyObject * obj1 = 0 ;
21243 char *kwnames[] = {
21244 (char *) "self",(char *) "noDST", NULL
21245 };
21246
21247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21249 if (SWIG_arg_fail(1)) SWIG_fail;
21250 if (obj1) {
21251 {
21252 arg2 = (bool)(SWIG_As_bool(obj1));
21253 if (SWIG_arg_fail(2)) SWIG_fail;
21254 }
21255 }
21256 {
21257 PyThreadState* __tstate = wxPyBeginAllowThreads();
21258 result = (arg1)->ToGMT(arg2);
21259
21260 wxPyEndAllowThreads(__tstate);
21261 if (PyErr_Occurred()) SWIG_fail;
21262 }
21263 {
21264 wxDateTime * resultptr;
21265 resultptr = new wxDateTime((wxDateTime &)(result));
21266 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21267 }
21268 return resultobj;
21269 fail:
21270 return NULL;
21271 }
21272
21273
21274 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21275 PyObject *resultobj;
21276 wxDateTime *arg1 = (wxDateTime *) 0 ;
21277 bool arg2 = (bool) false ;
21278 wxDateTime *result;
21279 PyObject * obj0 = 0 ;
21280 PyObject * obj1 = 0 ;
21281 char *kwnames[] = {
21282 (char *) "self",(char *) "noDST", NULL
21283 };
21284
21285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21287 if (SWIG_arg_fail(1)) SWIG_fail;
21288 if (obj1) {
21289 {
21290 arg2 = (bool)(SWIG_As_bool(obj1));
21291 if (SWIG_arg_fail(2)) SWIG_fail;
21292 }
21293 }
21294 {
21295 PyThreadState* __tstate = wxPyBeginAllowThreads();
21296 {
21297 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21298 result = (wxDateTime *) &_result_ref;
21299 }
21300
21301 wxPyEndAllowThreads(__tstate);
21302 if (PyErr_Occurred()) SWIG_fail;
21303 }
21304 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21305 return resultobj;
21306 fail:
21307 return NULL;
21308 }
21309
21310
21311 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21312 PyObject *resultobj;
21313 wxDateTime *arg1 = (wxDateTime *) 0 ;
21314 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21315 int result;
21316 PyObject * obj0 = 0 ;
21317 PyObject * obj1 = 0 ;
21318 char *kwnames[] = {
21319 (char *) "self",(char *) "country", NULL
21320 };
21321
21322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21324 if (SWIG_arg_fail(1)) SWIG_fail;
21325 if (obj1) {
21326 {
21327 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21328 if (SWIG_arg_fail(2)) SWIG_fail;
21329 }
21330 }
21331 {
21332 PyThreadState* __tstate = wxPyBeginAllowThreads();
21333 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21334
21335 wxPyEndAllowThreads(__tstate);
21336 if (PyErr_Occurred()) SWIG_fail;
21337 }
21338 {
21339 resultobj = SWIG_From_int((int)(result));
21340 }
21341 return resultobj;
21342 fail:
21343 return NULL;
21344 }
21345
21346
21347 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21348 PyObject *resultobj;
21349 wxDateTime *arg1 = (wxDateTime *) 0 ;
21350 bool result;
21351 PyObject * obj0 = 0 ;
21352 char *kwnames[] = {
21353 (char *) "self", NULL
21354 };
21355
21356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21358 if (SWIG_arg_fail(1)) SWIG_fail;
21359 {
21360 PyThreadState* __tstate = wxPyBeginAllowThreads();
21361 result = (bool)((wxDateTime const *)arg1)->IsValid();
21362
21363 wxPyEndAllowThreads(__tstate);
21364 if (PyErr_Occurred()) SWIG_fail;
21365 }
21366 {
21367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21368 }
21369 return resultobj;
21370 fail:
21371 return NULL;
21372 }
21373
21374
21375 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21376 PyObject *resultobj;
21377 wxDateTime *arg1 = (wxDateTime *) 0 ;
21378 time_t result;
21379 PyObject * obj0 = 0 ;
21380 char *kwnames[] = {
21381 (char *) "self", NULL
21382 };
21383
21384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21386 if (SWIG_arg_fail(1)) SWIG_fail;
21387 {
21388 PyThreadState* __tstate = wxPyBeginAllowThreads();
21389 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21390
21391 wxPyEndAllowThreads(__tstate);
21392 if (PyErr_Occurred()) SWIG_fail;
21393 }
21394 {
21395 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21396 }
21397 return resultobj;
21398 fail:
21399 return NULL;
21400 }
21401
21402
21403 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21404 PyObject *resultobj;
21405 wxDateTime *arg1 = (wxDateTime *) 0 ;
21406 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21407 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21408 int result;
21409 bool temp2 = false ;
21410 PyObject * obj0 = 0 ;
21411 PyObject * obj1 = 0 ;
21412 char *kwnames[] = {
21413 (char *) "self",(char *) "tz", NULL
21414 };
21415
21416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21418 if (SWIG_arg_fail(1)) SWIG_fail;
21419 if (obj1) {
21420 {
21421 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21422 temp2 = true;
21423 }
21424 }
21425 {
21426 PyThreadState* __tstate = wxPyBeginAllowThreads();
21427 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21428
21429 wxPyEndAllowThreads(__tstate);
21430 if (PyErr_Occurred()) SWIG_fail;
21431 }
21432 {
21433 resultobj = SWIG_From_int((int)(result));
21434 }
21435 {
21436 if (temp2) delete arg2;
21437 }
21438 return resultobj;
21439 fail:
21440 {
21441 if (temp2) delete arg2;
21442 }
21443 return NULL;
21444 }
21445
21446
21447 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21448 PyObject *resultobj;
21449 wxDateTime *arg1 = (wxDateTime *) 0 ;
21450 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21451 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21452 wxDateTime::Month result;
21453 bool temp2 = false ;
21454 PyObject * obj0 = 0 ;
21455 PyObject * obj1 = 0 ;
21456 char *kwnames[] = {
21457 (char *) "self",(char *) "tz", NULL
21458 };
21459
21460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21462 if (SWIG_arg_fail(1)) SWIG_fail;
21463 if (obj1) {
21464 {
21465 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21466 temp2 = true;
21467 }
21468 }
21469 {
21470 PyThreadState* __tstate = wxPyBeginAllowThreads();
21471 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21472
21473 wxPyEndAllowThreads(__tstate);
21474 if (PyErr_Occurred()) SWIG_fail;
21475 }
21476 resultobj = SWIG_From_int((result));
21477 {
21478 if (temp2) delete arg2;
21479 }
21480 return resultobj;
21481 fail:
21482 {
21483 if (temp2) delete arg2;
21484 }
21485 return NULL;
21486 }
21487
21488
21489 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21490 PyObject *resultobj;
21491 wxDateTime *arg1 = (wxDateTime *) 0 ;
21492 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21493 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21494 int result;
21495 bool temp2 = false ;
21496 PyObject * obj0 = 0 ;
21497 PyObject * obj1 = 0 ;
21498 char *kwnames[] = {
21499 (char *) "self",(char *) "tz", NULL
21500 };
21501
21502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21504 if (SWIG_arg_fail(1)) SWIG_fail;
21505 if (obj1) {
21506 {
21507 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21508 temp2 = true;
21509 }
21510 }
21511 {
21512 PyThreadState* __tstate = wxPyBeginAllowThreads();
21513 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21514
21515 wxPyEndAllowThreads(__tstate);
21516 if (PyErr_Occurred()) SWIG_fail;
21517 }
21518 {
21519 resultobj = SWIG_From_int((int)(result));
21520 }
21521 {
21522 if (temp2) delete arg2;
21523 }
21524 return resultobj;
21525 fail:
21526 {
21527 if (temp2) delete arg2;
21528 }
21529 return NULL;
21530 }
21531
21532
21533 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21534 PyObject *resultobj;
21535 wxDateTime *arg1 = (wxDateTime *) 0 ;
21536 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21537 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21538 wxDateTime::WeekDay result;
21539 bool temp2 = false ;
21540 PyObject * obj0 = 0 ;
21541 PyObject * obj1 = 0 ;
21542 char *kwnames[] = {
21543 (char *) "self",(char *) "tz", NULL
21544 };
21545
21546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21548 if (SWIG_arg_fail(1)) SWIG_fail;
21549 if (obj1) {
21550 {
21551 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21552 temp2 = true;
21553 }
21554 }
21555 {
21556 PyThreadState* __tstate = wxPyBeginAllowThreads();
21557 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21558
21559 wxPyEndAllowThreads(__tstate);
21560 if (PyErr_Occurred()) SWIG_fail;
21561 }
21562 resultobj = SWIG_From_int((result));
21563 {
21564 if (temp2) delete arg2;
21565 }
21566 return resultobj;
21567 fail:
21568 {
21569 if (temp2) delete arg2;
21570 }
21571 return NULL;
21572 }
21573
21574
21575 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21576 PyObject *resultobj;
21577 wxDateTime *arg1 = (wxDateTime *) 0 ;
21578 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21579 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21580 int result;
21581 bool temp2 = false ;
21582 PyObject * obj0 = 0 ;
21583 PyObject * obj1 = 0 ;
21584 char *kwnames[] = {
21585 (char *) "self",(char *) "tz", NULL
21586 };
21587
21588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21590 if (SWIG_arg_fail(1)) SWIG_fail;
21591 if (obj1) {
21592 {
21593 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21594 temp2 = true;
21595 }
21596 }
21597 {
21598 PyThreadState* __tstate = wxPyBeginAllowThreads();
21599 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21600
21601 wxPyEndAllowThreads(__tstate);
21602 if (PyErr_Occurred()) SWIG_fail;
21603 }
21604 {
21605 resultobj = SWIG_From_int((int)(result));
21606 }
21607 {
21608 if (temp2) delete arg2;
21609 }
21610 return resultobj;
21611 fail:
21612 {
21613 if (temp2) delete arg2;
21614 }
21615 return NULL;
21616 }
21617
21618
21619 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21620 PyObject *resultobj;
21621 wxDateTime *arg1 = (wxDateTime *) 0 ;
21622 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21623 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21624 int result;
21625 bool temp2 = false ;
21626 PyObject * obj0 = 0 ;
21627 PyObject * obj1 = 0 ;
21628 char *kwnames[] = {
21629 (char *) "self",(char *) "tz", NULL
21630 };
21631
21632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21634 if (SWIG_arg_fail(1)) SWIG_fail;
21635 if (obj1) {
21636 {
21637 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21638 temp2 = true;
21639 }
21640 }
21641 {
21642 PyThreadState* __tstate = wxPyBeginAllowThreads();
21643 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21644
21645 wxPyEndAllowThreads(__tstate);
21646 if (PyErr_Occurred()) SWIG_fail;
21647 }
21648 {
21649 resultobj = SWIG_From_int((int)(result));
21650 }
21651 {
21652 if (temp2) delete arg2;
21653 }
21654 return resultobj;
21655 fail:
21656 {
21657 if (temp2) delete arg2;
21658 }
21659 return NULL;
21660 }
21661
21662
21663 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21664 PyObject *resultobj;
21665 wxDateTime *arg1 = (wxDateTime *) 0 ;
21666 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21667 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21668 int result;
21669 bool temp2 = false ;
21670 PyObject * obj0 = 0 ;
21671 PyObject * obj1 = 0 ;
21672 char *kwnames[] = {
21673 (char *) "self",(char *) "tz", NULL
21674 };
21675
21676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21678 if (SWIG_arg_fail(1)) SWIG_fail;
21679 if (obj1) {
21680 {
21681 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21682 temp2 = true;
21683 }
21684 }
21685 {
21686 PyThreadState* __tstate = wxPyBeginAllowThreads();
21687 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21688
21689 wxPyEndAllowThreads(__tstate);
21690 if (PyErr_Occurred()) SWIG_fail;
21691 }
21692 {
21693 resultobj = SWIG_From_int((int)(result));
21694 }
21695 {
21696 if (temp2) delete arg2;
21697 }
21698 return resultobj;
21699 fail:
21700 {
21701 if (temp2) delete arg2;
21702 }
21703 return NULL;
21704 }
21705
21706
21707 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21708 PyObject *resultobj;
21709 wxDateTime *arg1 = (wxDateTime *) 0 ;
21710 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21711 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21712 int result;
21713 bool temp2 = false ;
21714 PyObject * obj0 = 0 ;
21715 PyObject * obj1 = 0 ;
21716 char *kwnames[] = {
21717 (char *) "self",(char *) "tz", NULL
21718 };
21719
21720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21722 if (SWIG_arg_fail(1)) SWIG_fail;
21723 if (obj1) {
21724 {
21725 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21726 temp2 = true;
21727 }
21728 }
21729 {
21730 PyThreadState* __tstate = wxPyBeginAllowThreads();
21731 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21732
21733 wxPyEndAllowThreads(__tstate);
21734 if (PyErr_Occurred()) SWIG_fail;
21735 }
21736 {
21737 resultobj = SWIG_From_int((int)(result));
21738 }
21739 {
21740 if (temp2) delete arg2;
21741 }
21742 return resultobj;
21743 fail:
21744 {
21745 if (temp2) delete arg2;
21746 }
21747 return NULL;
21748 }
21749
21750
21751 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21752 PyObject *resultobj;
21753 wxDateTime *arg1 = (wxDateTime *) 0 ;
21754 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21755 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21756 int result;
21757 bool temp2 = false ;
21758 PyObject * obj0 = 0 ;
21759 PyObject * obj1 = 0 ;
21760 char *kwnames[] = {
21761 (char *) "self",(char *) "tz", NULL
21762 };
21763
21764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21766 if (SWIG_arg_fail(1)) SWIG_fail;
21767 if (obj1) {
21768 {
21769 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21770 temp2 = true;
21771 }
21772 }
21773 {
21774 PyThreadState* __tstate = wxPyBeginAllowThreads();
21775 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21776
21777 wxPyEndAllowThreads(__tstate);
21778 if (PyErr_Occurred()) SWIG_fail;
21779 }
21780 {
21781 resultobj = SWIG_From_int((int)(result));
21782 }
21783 {
21784 if (temp2) delete arg2;
21785 }
21786 return resultobj;
21787 fail:
21788 {
21789 if (temp2) delete arg2;
21790 }
21791 return NULL;
21792 }
21793
21794
21795 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21796 PyObject *resultobj;
21797 wxDateTime *arg1 = (wxDateTime *) 0 ;
21798 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21799 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21800 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21801 int result;
21802 bool temp3 = false ;
21803 PyObject * obj0 = 0 ;
21804 PyObject * obj1 = 0 ;
21805 PyObject * obj2 = 0 ;
21806 char *kwnames[] = {
21807 (char *) "self",(char *) "flags",(char *) "tz", NULL
21808 };
21809
21810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21812 if (SWIG_arg_fail(1)) SWIG_fail;
21813 if (obj1) {
21814 {
21815 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21816 if (SWIG_arg_fail(2)) SWIG_fail;
21817 }
21818 }
21819 if (obj2) {
21820 {
21821 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21822 temp3 = true;
21823 }
21824 }
21825 {
21826 PyThreadState* __tstate = wxPyBeginAllowThreads();
21827 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21828
21829 wxPyEndAllowThreads(__tstate);
21830 if (PyErr_Occurred()) SWIG_fail;
21831 }
21832 {
21833 resultobj = SWIG_From_int((int)(result));
21834 }
21835 {
21836 if (temp3) delete arg3;
21837 }
21838 return resultobj;
21839 fail:
21840 {
21841 if (temp3) delete arg3;
21842 }
21843 return NULL;
21844 }
21845
21846
21847 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21848 PyObject *resultobj;
21849 wxDateTime *arg1 = (wxDateTime *) 0 ;
21850 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21851 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21852 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21853 int result;
21854 bool temp3 = false ;
21855 PyObject * obj0 = 0 ;
21856 PyObject * obj1 = 0 ;
21857 PyObject * obj2 = 0 ;
21858 char *kwnames[] = {
21859 (char *) "self",(char *) "flags",(char *) "tz", NULL
21860 };
21861
21862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21864 if (SWIG_arg_fail(1)) SWIG_fail;
21865 if (obj1) {
21866 {
21867 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21868 if (SWIG_arg_fail(2)) SWIG_fail;
21869 }
21870 }
21871 if (obj2) {
21872 {
21873 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21874 temp3 = true;
21875 }
21876 }
21877 {
21878 PyThreadState* __tstate = wxPyBeginAllowThreads();
21879 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21880
21881 wxPyEndAllowThreads(__tstate);
21882 if (PyErr_Occurred()) SWIG_fail;
21883 }
21884 {
21885 resultobj = SWIG_From_int((int)(result));
21886 }
21887 {
21888 if (temp3) delete arg3;
21889 }
21890 return resultobj;
21891 fail:
21892 {
21893 if (temp3) delete arg3;
21894 }
21895 return NULL;
21896 }
21897
21898
21899 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21900 PyObject *resultobj;
21901 wxDateTime *arg1 = (wxDateTime *) 0 ;
21902 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21903 bool result;
21904 PyObject * obj0 = 0 ;
21905 PyObject * obj1 = 0 ;
21906 char *kwnames[] = {
21907 (char *) "self",(char *) "country", NULL
21908 };
21909
21910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21912 if (SWIG_arg_fail(1)) SWIG_fail;
21913 if (obj1) {
21914 {
21915 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21916 if (SWIG_arg_fail(2)) SWIG_fail;
21917 }
21918 }
21919 {
21920 PyThreadState* __tstate = wxPyBeginAllowThreads();
21921 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21922
21923 wxPyEndAllowThreads(__tstate);
21924 if (PyErr_Occurred()) SWIG_fail;
21925 }
21926 {
21927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21928 }
21929 return resultobj;
21930 fail:
21931 return NULL;
21932 }
21933
21934
21935 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21936 PyObject *resultobj;
21937 wxDateTime *arg1 = (wxDateTime *) 0 ;
21938 wxDateTime *arg2 = 0 ;
21939 bool result;
21940 PyObject * obj0 = 0 ;
21941 PyObject * obj1 = 0 ;
21942 char *kwnames[] = {
21943 (char *) "self",(char *) "datetime", NULL
21944 };
21945
21946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21948 if (SWIG_arg_fail(1)) SWIG_fail;
21949 {
21950 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21951 if (SWIG_arg_fail(2)) SWIG_fail;
21952 if (arg2 == NULL) {
21953 SWIG_null_ref("wxDateTime");
21954 }
21955 if (SWIG_arg_fail(2)) SWIG_fail;
21956 }
21957 {
21958 PyThreadState* __tstate = wxPyBeginAllowThreads();
21959 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21960
21961 wxPyEndAllowThreads(__tstate);
21962 if (PyErr_Occurred()) SWIG_fail;
21963 }
21964 {
21965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21966 }
21967 return resultobj;
21968 fail:
21969 return NULL;
21970 }
21971
21972
21973 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21974 PyObject *resultobj;
21975 wxDateTime *arg1 = (wxDateTime *) 0 ;
21976 wxDateTime *arg2 = 0 ;
21977 bool result;
21978 PyObject * obj0 = 0 ;
21979 PyObject * obj1 = 0 ;
21980 char *kwnames[] = {
21981 (char *) "self",(char *) "datetime", NULL
21982 };
21983
21984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21986 if (SWIG_arg_fail(1)) SWIG_fail;
21987 {
21988 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21989 if (SWIG_arg_fail(2)) SWIG_fail;
21990 if (arg2 == NULL) {
21991 SWIG_null_ref("wxDateTime");
21992 }
21993 if (SWIG_arg_fail(2)) SWIG_fail;
21994 }
21995 {
21996 PyThreadState* __tstate = wxPyBeginAllowThreads();
21997 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
21998
21999 wxPyEndAllowThreads(__tstate);
22000 if (PyErr_Occurred()) SWIG_fail;
22001 }
22002 {
22003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22004 }
22005 return resultobj;
22006 fail:
22007 return NULL;
22008 }
22009
22010
22011 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22012 PyObject *resultobj;
22013 wxDateTime *arg1 = (wxDateTime *) 0 ;
22014 wxDateTime *arg2 = 0 ;
22015 bool result;
22016 PyObject * obj0 = 0 ;
22017 PyObject * obj1 = 0 ;
22018 char *kwnames[] = {
22019 (char *) "self",(char *) "datetime", NULL
22020 };
22021
22022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22024 if (SWIG_arg_fail(1)) SWIG_fail;
22025 {
22026 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22027 if (SWIG_arg_fail(2)) SWIG_fail;
22028 if (arg2 == NULL) {
22029 SWIG_null_ref("wxDateTime");
22030 }
22031 if (SWIG_arg_fail(2)) SWIG_fail;
22032 }
22033 {
22034 PyThreadState* __tstate = wxPyBeginAllowThreads();
22035 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22036
22037 wxPyEndAllowThreads(__tstate);
22038 if (PyErr_Occurred()) SWIG_fail;
22039 }
22040 {
22041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22042 }
22043 return resultobj;
22044 fail:
22045 return NULL;
22046 }
22047
22048
22049 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22050 PyObject *resultobj;
22051 wxDateTime *arg1 = (wxDateTime *) 0 ;
22052 wxDateTime *arg2 = 0 ;
22053 wxDateTime *arg3 = 0 ;
22054 bool result;
22055 PyObject * obj0 = 0 ;
22056 PyObject * obj1 = 0 ;
22057 PyObject * obj2 = 0 ;
22058 char *kwnames[] = {
22059 (char *) "self",(char *) "t1",(char *) "t2", NULL
22060 };
22061
22062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22064 if (SWIG_arg_fail(1)) SWIG_fail;
22065 {
22066 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22067 if (SWIG_arg_fail(2)) SWIG_fail;
22068 if (arg2 == NULL) {
22069 SWIG_null_ref("wxDateTime");
22070 }
22071 if (SWIG_arg_fail(2)) SWIG_fail;
22072 }
22073 {
22074 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22075 if (SWIG_arg_fail(3)) SWIG_fail;
22076 if (arg3 == NULL) {
22077 SWIG_null_ref("wxDateTime");
22078 }
22079 if (SWIG_arg_fail(3)) SWIG_fail;
22080 }
22081 {
22082 PyThreadState* __tstate = wxPyBeginAllowThreads();
22083 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22084
22085 wxPyEndAllowThreads(__tstate);
22086 if (PyErr_Occurred()) SWIG_fail;
22087 }
22088 {
22089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22090 }
22091 return resultobj;
22092 fail:
22093 return NULL;
22094 }
22095
22096
22097 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22098 PyObject *resultobj;
22099 wxDateTime *arg1 = (wxDateTime *) 0 ;
22100 wxDateTime *arg2 = 0 ;
22101 wxDateTime *arg3 = 0 ;
22102 bool result;
22103 PyObject * obj0 = 0 ;
22104 PyObject * obj1 = 0 ;
22105 PyObject * obj2 = 0 ;
22106 char *kwnames[] = {
22107 (char *) "self",(char *) "t1",(char *) "t2", NULL
22108 };
22109
22110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22112 if (SWIG_arg_fail(1)) SWIG_fail;
22113 {
22114 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22115 if (SWIG_arg_fail(2)) SWIG_fail;
22116 if (arg2 == NULL) {
22117 SWIG_null_ref("wxDateTime");
22118 }
22119 if (SWIG_arg_fail(2)) SWIG_fail;
22120 }
22121 {
22122 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22123 if (SWIG_arg_fail(3)) SWIG_fail;
22124 if (arg3 == NULL) {
22125 SWIG_null_ref("wxDateTime");
22126 }
22127 if (SWIG_arg_fail(3)) SWIG_fail;
22128 }
22129 {
22130 PyThreadState* __tstate = wxPyBeginAllowThreads();
22131 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22132
22133 wxPyEndAllowThreads(__tstate);
22134 if (PyErr_Occurred()) SWIG_fail;
22135 }
22136 {
22137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22138 }
22139 return resultobj;
22140 fail:
22141 return NULL;
22142 }
22143
22144
22145 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22146 PyObject *resultobj;
22147 wxDateTime *arg1 = (wxDateTime *) 0 ;
22148 wxDateTime *arg2 = 0 ;
22149 bool result;
22150 PyObject * obj0 = 0 ;
22151 PyObject * obj1 = 0 ;
22152 char *kwnames[] = {
22153 (char *) "self",(char *) "dt", NULL
22154 };
22155
22156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22158 if (SWIG_arg_fail(1)) SWIG_fail;
22159 {
22160 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22161 if (SWIG_arg_fail(2)) SWIG_fail;
22162 if (arg2 == NULL) {
22163 SWIG_null_ref("wxDateTime");
22164 }
22165 if (SWIG_arg_fail(2)) SWIG_fail;
22166 }
22167 {
22168 PyThreadState* __tstate = wxPyBeginAllowThreads();
22169 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22170
22171 wxPyEndAllowThreads(__tstate);
22172 if (PyErr_Occurred()) SWIG_fail;
22173 }
22174 {
22175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22176 }
22177 return resultobj;
22178 fail:
22179 return NULL;
22180 }
22181
22182
22183 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22184 PyObject *resultobj;
22185 wxDateTime *arg1 = (wxDateTime *) 0 ;
22186 wxDateTime *arg2 = 0 ;
22187 bool result;
22188 PyObject * obj0 = 0 ;
22189 PyObject * obj1 = 0 ;
22190 char *kwnames[] = {
22191 (char *) "self",(char *) "dt", NULL
22192 };
22193
22194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22196 if (SWIG_arg_fail(1)) SWIG_fail;
22197 {
22198 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22199 if (SWIG_arg_fail(2)) SWIG_fail;
22200 if (arg2 == NULL) {
22201 SWIG_null_ref("wxDateTime");
22202 }
22203 if (SWIG_arg_fail(2)) SWIG_fail;
22204 }
22205 {
22206 PyThreadState* __tstate = wxPyBeginAllowThreads();
22207 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22208
22209 wxPyEndAllowThreads(__tstate);
22210 if (PyErr_Occurred()) SWIG_fail;
22211 }
22212 {
22213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22214 }
22215 return resultobj;
22216 fail:
22217 return NULL;
22218 }
22219
22220
22221 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22222 PyObject *resultobj;
22223 wxDateTime *arg1 = (wxDateTime *) 0 ;
22224 wxDateTime *arg2 = 0 ;
22225 wxTimeSpan *arg3 = 0 ;
22226 bool result;
22227 PyObject * obj0 = 0 ;
22228 PyObject * obj1 = 0 ;
22229 PyObject * obj2 = 0 ;
22230 char *kwnames[] = {
22231 (char *) "self",(char *) "dt",(char *) "ts", NULL
22232 };
22233
22234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22236 if (SWIG_arg_fail(1)) SWIG_fail;
22237 {
22238 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22239 if (SWIG_arg_fail(2)) SWIG_fail;
22240 if (arg2 == NULL) {
22241 SWIG_null_ref("wxDateTime");
22242 }
22243 if (SWIG_arg_fail(2)) SWIG_fail;
22244 }
22245 {
22246 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22247 if (SWIG_arg_fail(3)) SWIG_fail;
22248 if (arg3 == NULL) {
22249 SWIG_null_ref("wxTimeSpan");
22250 }
22251 if (SWIG_arg_fail(3)) SWIG_fail;
22252 }
22253 {
22254 PyThreadState* __tstate = wxPyBeginAllowThreads();
22255 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22256
22257 wxPyEndAllowThreads(__tstate);
22258 if (PyErr_Occurred()) SWIG_fail;
22259 }
22260 {
22261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22262 }
22263 return resultobj;
22264 fail:
22265 return NULL;
22266 }
22267
22268
22269 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22270 PyObject *resultobj;
22271 wxDateTime *arg1 = (wxDateTime *) 0 ;
22272 wxTimeSpan *arg2 = 0 ;
22273 wxDateTime *result;
22274 PyObject * obj0 = 0 ;
22275 PyObject * obj1 = 0 ;
22276 char *kwnames[] = {
22277 (char *) "self",(char *) "diff", NULL
22278 };
22279
22280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22282 if (SWIG_arg_fail(1)) SWIG_fail;
22283 {
22284 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22285 if (SWIG_arg_fail(2)) SWIG_fail;
22286 if (arg2 == NULL) {
22287 SWIG_null_ref("wxTimeSpan");
22288 }
22289 if (SWIG_arg_fail(2)) SWIG_fail;
22290 }
22291 {
22292 PyThreadState* __tstate = wxPyBeginAllowThreads();
22293 {
22294 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22295 result = (wxDateTime *) &_result_ref;
22296 }
22297
22298 wxPyEndAllowThreads(__tstate);
22299 if (PyErr_Occurred()) SWIG_fail;
22300 }
22301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22302 return resultobj;
22303 fail:
22304 return NULL;
22305 }
22306
22307
22308 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22309 PyObject *resultobj;
22310 wxDateTime *arg1 = (wxDateTime *) 0 ;
22311 wxDateSpan *arg2 = 0 ;
22312 wxDateTime *result;
22313 PyObject * obj0 = 0 ;
22314 PyObject * obj1 = 0 ;
22315 char *kwnames[] = {
22316 (char *) "self",(char *) "diff", NULL
22317 };
22318
22319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22321 if (SWIG_arg_fail(1)) SWIG_fail;
22322 {
22323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22324 if (SWIG_arg_fail(2)) SWIG_fail;
22325 if (arg2 == NULL) {
22326 SWIG_null_ref("wxDateSpan");
22327 }
22328 if (SWIG_arg_fail(2)) SWIG_fail;
22329 }
22330 {
22331 PyThreadState* __tstate = wxPyBeginAllowThreads();
22332 {
22333 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22334 result = (wxDateTime *) &_result_ref;
22335 }
22336
22337 wxPyEndAllowThreads(__tstate);
22338 if (PyErr_Occurred()) SWIG_fail;
22339 }
22340 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22341 return resultobj;
22342 fail:
22343 return NULL;
22344 }
22345
22346
22347 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22348 PyObject *resultobj;
22349 wxDateTime *arg1 = (wxDateTime *) 0 ;
22350 wxTimeSpan *arg2 = 0 ;
22351 wxDateTime *result;
22352 PyObject * obj0 = 0 ;
22353 PyObject * obj1 = 0 ;
22354 char *kwnames[] = {
22355 (char *) "self",(char *) "diff", NULL
22356 };
22357
22358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22360 if (SWIG_arg_fail(1)) SWIG_fail;
22361 {
22362 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22363 if (SWIG_arg_fail(2)) SWIG_fail;
22364 if (arg2 == NULL) {
22365 SWIG_null_ref("wxTimeSpan");
22366 }
22367 if (SWIG_arg_fail(2)) SWIG_fail;
22368 }
22369 {
22370 PyThreadState* __tstate = wxPyBeginAllowThreads();
22371 {
22372 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22373 result = (wxDateTime *) &_result_ref;
22374 }
22375
22376 wxPyEndAllowThreads(__tstate);
22377 if (PyErr_Occurred()) SWIG_fail;
22378 }
22379 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22380 return resultobj;
22381 fail:
22382 return NULL;
22383 }
22384
22385
22386 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22387 PyObject *resultobj;
22388 wxDateTime *arg1 = (wxDateTime *) 0 ;
22389 wxDateSpan *arg2 = 0 ;
22390 wxDateTime *result;
22391 PyObject * obj0 = 0 ;
22392 PyObject * obj1 = 0 ;
22393 char *kwnames[] = {
22394 (char *) "self",(char *) "diff", NULL
22395 };
22396
22397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22399 if (SWIG_arg_fail(1)) SWIG_fail;
22400 {
22401 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22402 if (SWIG_arg_fail(2)) SWIG_fail;
22403 if (arg2 == NULL) {
22404 SWIG_null_ref("wxDateSpan");
22405 }
22406 if (SWIG_arg_fail(2)) SWIG_fail;
22407 }
22408 {
22409 PyThreadState* __tstate = wxPyBeginAllowThreads();
22410 {
22411 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22412 result = (wxDateTime *) &_result_ref;
22413 }
22414
22415 wxPyEndAllowThreads(__tstate);
22416 if (PyErr_Occurred()) SWIG_fail;
22417 }
22418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22419 return resultobj;
22420 fail:
22421 return NULL;
22422 }
22423
22424
22425 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22426 PyObject *resultobj;
22427 wxDateTime *arg1 = (wxDateTime *) 0 ;
22428 wxDateTime *arg2 = 0 ;
22429 wxTimeSpan result;
22430 PyObject * obj0 = 0 ;
22431 PyObject * obj1 = 0 ;
22432 char *kwnames[] = {
22433 (char *) "self",(char *) "dt", NULL
22434 };
22435
22436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22438 if (SWIG_arg_fail(1)) SWIG_fail;
22439 {
22440 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22441 if (SWIG_arg_fail(2)) SWIG_fail;
22442 if (arg2 == NULL) {
22443 SWIG_null_ref("wxDateTime");
22444 }
22445 if (SWIG_arg_fail(2)) SWIG_fail;
22446 }
22447 {
22448 PyThreadState* __tstate = wxPyBeginAllowThreads();
22449 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22450
22451 wxPyEndAllowThreads(__tstate);
22452 if (PyErr_Occurred()) SWIG_fail;
22453 }
22454 {
22455 wxTimeSpan * resultptr;
22456 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22457 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22458 }
22459 return resultobj;
22460 fail:
22461 return NULL;
22462 }
22463
22464
22465 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22466 PyObject *resultobj;
22467 wxDateTime *arg1 = (wxDateTime *) 0 ;
22468 wxTimeSpan *arg2 = 0 ;
22469 wxDateTime *result;
22470 PyObject * obj0 = 0 ;
22471 PyObject * obj1 = 0 ;
22472
22473 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22475 if (SWIG_arg_fail(1)) SWIG_fail;
22476 {
22477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22478 if (SWIG_arg_fail(2)) SWIG_fail;
22479 if (arg2 == NULL) {
22480 SWIG_null_ref("wxTimeSpan");
22481 }
22482 if (SWIG_arg_fail(2)) SWIG_fail;
22483 }
22484 {
22485 PyThreadState* __tstate = wxPyBeginAllowThreads();
22486 {
22487 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22488 result = (wxDateTime *) &_result_ref;
22489 }
22490
22491 wxPyEndAllowThreads(__tstate);
22492 if (PyErr_Occurred()) SWIG_fail;
22493 }
22494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22495 return resultobj;
22496 fail:
22497 return NULL;
22498 }
22499
22500
22501 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22502 PyObject *resultobj;
22503 wxDateTime *arg1 = (wxDateTime *) 0 ;
22504 wxDateSpan *arg2 = 0 ;
22505 wxDateTime *result;
22506 PyObject * obj0 = 0 ;
22507 PyObject * obj1 = 0 ;
22508
22509 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22511 if (SWIG_arg_fail(1)) SWIG_fail;
22512 {
22513 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22514 if (SWIG_arg_fail(2)) SWIG_fail;
22515 if (arg2 == NULL) {
22516 SWIG_null_ref("wxDateSpan");
22517 }
22518 if (SWIG_arg_fail(2)) SWIG_fail;
22519 }
22520 {
22521 PyThreadState* __tstate = wxPyBeginAllowThreads();
22522 {
22523 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22524 result = (wxDateTime *) &_result_ref;
22525 }
22526
22527 wxPyEndAllowThreads(__tstate);
22528 if (PyErr_Occurred()) SWIG_fail;
22529 }
22530 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22531 return resultobj;
22532 fail:
22533 return NULL;
22534 }
22535
22536
22537 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22538 int argc;
22539 PyObject *argv[3];
22540 int ii;
22541
22542 argc = PyObject_Length(args);
22543 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22544 argv[ii] = PyTuple_GetItem(args,ii);
22545 }
22546 if (argc == 2) {
22547 int _v;
22548 {
22549 void *ptr;
22550 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22551 _v = 0;
22552 PyErr_Clear();
22553 } else {
22554 _v = 1;
22555 }
22556 }
22557 if (_v) {
22558 {
22559 void *ptr = 0;
22560 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22561 _v = 0;
22562 PyErr_Clear();
22563 } else {
22564 _v = (ptr != 0);
22565 }
22566 }
22567 if (_v) {
22568 return _wrap_DateTime___iadd____SWIG_0(self,args);
22569 }
22570 }
22571 }
22572 if (argc == 2) {
22573 int _v;
22574 {
22575 void *ptr;
22576 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22577 _v = 0;
22578 PyErr_Clear();
22579 } else {
22580 _v = 1;
22581 }
22582 }
22583 if (_v) {
22584 {
22585 void *ptr = 0;
22586 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22587 _v = 0;
22588 PyErr_Clear();
22589 } else {
22590 _v = (ptr != 0);
22591 }
22592 }
22593 if (_v) {
22594 return _wrap_DateTime___iadd____SWIG_1(self,args);
22595 }
22596 }
22597 }
22598
22599 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22600 return NULL;
22601 }
22602
22603
22604 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22605 PyObject *resultobj;
22606 wxDateTime *arg1 = (wxDateTime *) 0 ;
22607 wxTimeSpan *arg2 = 0 ;
22608 wxDateTime *result;
22609 PyObject * obj0 = 0 ;
22610 PyObject * obj1 = 0 ;
22611
22612 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22614 if (SWIG_arg_fail(1)) SWIG_fail;
22615 {
22616 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22617 if (SWIG_arg_fail(2)) SWIG_fail;
22618 if (arg2 == NULL) {
22619 SWIG_null_ref("wxTimeSpan");
22620 }
22621 if (SWIG_arg_fail(2)) SWIG_fail;
22622 }
22623 {
22624 PyThreadState* __tstate = wxPyBeginAllowThreads();
22625 {
22626 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22627 result = (wxDateTime *) &_result_ref;
22628 }
22629
22630 wxPyEndAllowThreads(__tstate);
22631 if (PyErr_Occurred()) SWIG_fail;
22632 }
22633 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22634 return resultobj;
22635 fail:
22636 return NULL;
22637 }
22638
22639
22640 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22641 PyObject *resultobj;
22642 wxDateTime *arg1 = (wxDateTime *) 0 ;
22643 wxDateSpan *arg2 = 0 ;
22644 wxDateTime *result;
22645 PyObject * obj0 = 0 ;
22646 PyObject * obj1 = 0 ;
22647
22648 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22650 if (SWIG_arg_fail(1)) SWIG_fail;
22651 {
22652 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22653 if (SWIG_arg_fail(2)) SWIG_fail;
22654 if (arg2 == NULL) {
22655 SWIG_null_ref("wxDateSpan");
22656 }
22657 if (SWIG_arg_fail(2)) SWIG_fail;
22658 }
22659 {
22660 PyThreadState* __tstate = wxPyBeginAllowThreads();
22661 {
22662 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22663 result = (wxDateTime *) &_result_ref;
22664 }
22665
22666 wxPyEndAllowThreads(__tstate);
22667 if (PyErr_Occurred()) SWIG_fail;
22668 }
22669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22670 return resultobj;
22671 fail:
22672 return NULL;
22673 }
22674
22675
22676 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22677 int argc;
22678 PyObject *argv[3];
22679 int ii;
22680
22681 argc = PyObject_Length(args);
22682 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22683 argv[ii] = PyTuple_GetItem(args,ii);
22684 }
22685 if (argc == 2) {
22686 int _v;
22687 {
22688 void *ptr;
22689 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22690 _v = 0;
22691 PyErr_Clear();
22692 } else {
22693 _v = 1;
22694 }
22695 }
22696 if (_v) {
22697 {
22698 void *ptr = 0;
22699 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22700 _v = 0;
22701 PyErr_Clear();
22702 } else {
22703 _v = (ptr != 0);
22704 }
22705 }
22706 if (_v) {
22707 return _wrap_DateTime___isub____SWIG_0(self,args);
22708 }
22709 }
22710 }
22711 if (argc == 2) {
22712 int _v;
22713 {
22714 void *ptr;
22715 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22716 _v = 0;
22717 PyErr_Clear();
22718 } else {
22719 _v = 1;
22720 }
22721 }
22722 if (_v) {
22723 {
22724 void *ptr = 0;
22725 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22726 _v = 0;
22727 PyErr_Clear();
22728 } else {
22729 _v = (ptr != 0);
22730 }
22731 }
22732 if (_v) {
22733 return _wrap_DateTime___isub____SWIG_1(self,args);
22734 }
22735 }
22736 }
22737
22738 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22739 return NULL;
22740 }
22741
22742
22743 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22744 PyObject *resultobj;
22745 wxDateTime *arg1 = (wxDateTime *) 0 ;
22746 wxTimeSpan *arg2 = 0 ;
22747 wxDateTime result;
22748 PyObject * obj0 = 0 ;
22749 PyObject * obj1 = 0 ;
22750
22751 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22753 if (SWIG_arg_fail(1)) SWIG_fail;
22754 {
22755 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22756 if (SWIG_arg_fail(2)) SWIG_fail;
22757 if (arg2 == NULL) {
22758 SWIG_null_ref("wxTimeSpan");
22759 }
22760 if (SWIG_arg_fail(2)) SWIG_fail;
22761 }
22762 {
22763 PyThreadState* __tstate = wxPyBeginAllowThreads();
22764 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22765
22766 wxPyEndAllowThreads(__tstate);
22767 if (PyErr_Occurred()) SWIG_fail;
22768 }
22769 {
22770 wxDateTime * resultptr;
22771 resultptr = new wxDateTime((wxDateTime &)(result));
22772 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22773 }
22774 return resultobj;
22775 fail:
22776 return NULL;
22777 }
22778
22779
22780 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22781 PyObject *resultobj;
22782 wxDateTime *arg1 = (wxDateTime *) 0 ;
22783 wxDateSpan *arg2 = 0 ;
22784 wxDateTime result;
22785 PyObject * obj0 = 0 ;
22786 PyObject * obj1 = 0 ;
22787
22788 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22790 if (SWIG_arg_fail(1)) SWIG_fail;
22791 {
22792 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22793 if (SWIG_arg_fail(2)) SWIG_fail;
22794 if (arg2 == NULL) {
22795 SWIG_null_ref("wxDateSpan");
22796 }
22797 if (SWIG_arg_fail(2)) SWIG_fail;
22798 }
22799 {
22800 PyThreadState* __tstate = wxPyBeginAllowThreads();
22801 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22802
22803 wxPyEndAllowThreads(__tstate);
22804 if (PyErr_Occurred()) SWIG_fail;
22805 }
22806 {
22807 wxDateTime * resultptr;
22808 resultptr = new wxDateTime((wxDateTime &)(result));
22809 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22810 }
22811 return resultobj;
22812 fail:
22813 return NULL;
22814 }
22815
22816
22817 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22818 int argc;
22819 PyObject *argv[3];
22820 int ii;
22821
22822 argc = PyObject_Length(args);
22823 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22824 argv[ii] = PyTuple_GetItem(args,ii);
22825 }
22826 if (argc == 2) {
22827 int _v;
22828 {
22829 void *ptr;
22830 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22831 _v = 0;
22832 PyErr_Clear();
22833 } else {
22834 _v = 1;
22835 }
22836 }
22837 if (_v) {
22838 {
22839 void *ptr = 0;
22840 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22841 _v = 0;
22842 PyErr_Clear();
22843 } else {
22844 _v = (ptr != 0);
22845 }
22846 }
22847 if (_v) {
22848 return _wrap_DateTime___add____SWIG_0(self,args);
22849 }
22850 }
22851 }
22852 if (argc == 2) {
22853 int _v;
22854 {
22855 void *ptr;
22856 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22857 _v = 0;
22858 PyErr_Clear();
22859 } else {
22860 _v = 1;
22861 }
22862 }
22863 if (_v) {
22864 {
22865 void *ptr = 0;
22866 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22867 _v = 0;
22868 PyErr_Clear();
22869 } else {
22870 _v = (ptr != 0);
22871 }
22872 }
22873 if (_v) {
22874 return _wrap_DateTime___add____SWIG_1(self,args);
22875 }
22876 }
22877 }
22878
22879 Py_INCREF(Py_NotImplemented);
22880 return Py_NotImplemented;
22881 }
22882
22883
22884 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22885 PyObject *resultobj;
22886 wxDateTime *arg1 = (wxDateTime *) 0 ;
22887 wxDateTime *arg2 = 0 ;
22888 wxTimeSpan result;
22889 PyObject * obj0 = 0 ;
22890 PyObject * obj1 = 0 ;
22891
22892 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22894 if (SWIG_arg_fail(1)) SWIG_fail;
22895 {
22896 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22897 if (SWIG_arg_fail(2)) SWIG_fail;
22898 if (arg2 == NULL) {
22899 SWIG_null_ref("wxDateTime");
22900 }
22901 if (SWIG_arg_fail(2)) SWIG_fail;
22902 }
22903 {
22904 PyThreadState* __tstate = wxPyBeginAllowThreads();
22905 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22906
22907 wxPyEndAllowThreads(__tstate);
22908 if (PyErr_Occurred()) SWIG_fail;
22909 }
22910 {
22911 wxTimeSpan * resultptr;
22912 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22913 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22914 }
22915 return resultobj;
22916 fail:
22917 return NULL;
22918 }
22919
22920
22921 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22922 PyObject *resultobj;
22923 wxDateTime *arg1 = (wxDateTime *) 0 ;
22924 wxTimeSpan *arg2 = 0 ;
22925 wxDateTime result;
22926 PyObject * obj0 = 0 ;
22927 PyObject * obj1 = 0 ;
22928
22929 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22931 if (SWIG_arg_fail(1)) SWIG_fail;
22932 {
22933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22934 if (SWIG_arg_fail(2)) SWIG_fail;
22935 if (arg2 == NULL) {
22936 SWIG_null_ref("wxTimeSpan");
22937 }
22938 if (SWIG_arg_fail(2)) SWIG_fail;
22939 }
22940 {
22941 PyThreadState* __tstate = wxPyBeginAllowThreads();
22942 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22943
22944 wxPyEndAllowThreads(__tstate);
22945 if (PyErr_Occurred()) SWIG_fail;
22946 }
22947 {
22948 wxDateTime * resultptr;
22949 resultptr = new wxDateTime((wxDateTime &)(result));
22950 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22951 }
22952 return resultobj;
22953 fail:
22954 return NULL;
22955 }
22956
22957
22958 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22959 PyObject *resultobj;
22960 wxDateTime *arg1 = (wxDateTime *) 0 ;
22961 wxDateSpan *arg2 = 0 ;
22962 wxDateTime result;
22963 PyObject * obj0 = 0 ;
22964 PyObject * obj1 = 0 ;
22965
22966 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22968 if (SWIG_arg_fail(1)) SWIG_fail;
22969 {
22970 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22971 if (SWIG_arg_fail(2)) SWIG_fail;
22972 if (arg2 == NULL) {
22973 SWIG_null_ref("wxDateSpan");
22974 }
22975 if (SWIG_arg_fail(2)) SWIG_fail;
22976 }
22977 {
22978 PyThreadState* __tstate = wxPyBeginAllowThreads();
22979 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22980
22981 wxPyEndAllowThreads(__tstate);
22982 if (PyErr_Occurred()) SWIG_fail;
22983 }
22984 {
22985 wxDateTime * resultptr;
22986 resultptr = new wxDateTime((wxDateTime &)(result));
22987 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22988 }
22989 return resultobj;
22990 fail:
22991 return NULL;
22992 }
22993
22994
22995 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
22996 int argc;
22997 PyObject *argv[3];
22998 int ii;
22999
23000 argc = PyObject_Length(args);
23001 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23002 argv[ii] = PyTuple_GetItem(args,ii);
23003 }
23004 if (argc == 2) {
23005 int _v;
23006 {
23007 void *ptr;
23008 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23009 _v = 0;
23010 PyErr_Clear();
23011 } else {
23012 _v = 1;
23013 }
23014 }
23015 if (_v) {
23016 {
23017 void *ptr = 0;
23018 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23019 _v = 0;
23020 PyErr_Clear();
23021 } else {
23022 _v = (ptr != 0);
23023 }
23024 }
23025 if (_v) {
23026 return _wrap_DateTime___sub____SWIG_0(self,args);
23027 }
23028 }
23029 }
23030 if (argc == 2) {
23031 int _v;
23032 {
23033 void *ptr;
23034 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23035 _v = 0;
23036 PyErr_Clear();
23037 } else {
23038 _v = 1;
23039 }
23040 }
23041 if (_v) {
23042 {
23043 void *ptr = 0;
23044 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23045 _v = 0;
23046 PyErr_Clear();
23047 } else {
23048 _v = (ptr != 0);
23049 }
23050 }
23051 if (_v) {
23052 return _wrap_DateTime___sub____SWIG_1(self,args);
23053 }
23054 }
23055 }
23056 if (argc == 2) {
23057 int _v;
23058 {
23059 void *ptr;
23060 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23061 _v = 0;
23062 PyErr_Clear();
23063 } else {
23064 _v = 1;
23065 }
23066 }
23067 if (_v) {
23068 {
23069 void *ptr = 0;
23070 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23071 _v = 0;
23072 PyErr_Clear();
23073 } else {
23074 _v = (ptr != 0);
23075 }
23076 }
23077 if (_v) {
23078 return _wrap_DateTime___sub____SWIG_2(self,args);
23079 }
23080 }
23081 }
23082
23083 Py_INCREF(Py_NotImplemented);
23084 return Py_NotImplemented;
23085 }
23086
23087
23088 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args) {
23089 PyObject *resultobj;
23090 wxDateTime *arg1 = (wxDateTime *) 0 ;
23091 wxDateTime *arg2 = (wxDateTime *) 0 ;
23092 bool result;
23093 PyObject * obj0 = 0 ;
23094 PyObject * obj1 = 0 ;
23095
23096 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___lt__",&obj0,&obj1)) goto fail;
23097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23098 if (SWIG_arg_fail(1)) SWIG_fail;
23099 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23100 if (SWIG_arg_fail(2)) SWIG_fail;
23101 {
23102 PyThreadState* __tstate = wxPyBeginAllowThreads();
23103 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23104
23105 wxPyEndAllowThreads(__tstate);
23106 if (PyErr_Occurred()) SWIG_fail;
23107 }
23108 {
23109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23110 }
23111 return resultobj;
23112 fail:
23113 return NULL;
23114 }
23115
23116
23117 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args) {
23118 PyObject *resultobj;
23119 wxDateTime *arg1 = (wxDateTime *) 0 ;
23120 wxDateTime *arg2 = (wxDateTime *) 0 ;
23121 bool result;
23122 PyObject * obj0 = 0 ;
23123 PyObject * obj1 = 0 ;
23124
23125 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___le__",&obj0,&obj1)) goto fail;
23126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23127 if (SWIG_arg_fail(1)) SWIG_fail;
23128 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23129 if (SWIG_arg_fail(2)) SWIG_fail;
23130 {
23131 PyThreadState* __tstate = wxPyBeginAllowThreads();
23132 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23133
23134 wxPyEndAllowThreads(__tstate);
23135 if (PyErr_Occurred()) SWIG_fail;
23136 }
23137 {
23138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23139 }
23140 return resultobj;
23141 fail:
23142 return NULL;
23143 }
23144
23145
23146 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args) {
23147 PyObject *resultobj;
23148 wxDateTime *arg1 = (wxDateTime *) 0 ;
23149 wxDateTime *arg2 = (wxDateTime *) 0 ;
23150 bool result;
23151 PyObject * obj0 = 0 ;
23152 PyObject * obj1 = 0 ;
23153
23154 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___gt__",&obj0,&obj1)) goto fail;
23155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23156 if (SWIG_arg_fail(1)) SWIG_fail;
23157 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23158 if (SWIG_arg_fail(2)) SWIG_fail;
23159 {
23160 PyThreadState* __tstate = wxPyBeginAllowThreads();
23161 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23162
23163 wxPyEndAllowThreads(__tstate);
23164 if (PyErr_Occurred()) SWIG_fail;
23165 }
23166 {
23167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23168 }
23169 return resultobj;
23170 fail:
23171 return NULL;
23172 }
23173
23174
23175 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args) {
23176 PyObject *resultobj;
23177 wxDateTime *arg1 = (wxDateTime *) 0 ;
23178 wxDateTime *arg2 = (wxDateTime *) 0 ;
23179 bool result;
23180 PyObject * obj0 = 0 ;
23181 PyObject * obj1 = 0 ;
23182
23183 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___ge__",&obj0,&obj1)) goto fail;
23184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23185 if (SWIG_arg_fail(1)) SWIG_fail;
23186 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23187 if (SWIG_arg_fail(2)) SWIG_fail;
23188 {
23189 PyThreadState* __tstate = wxPyBeginAllowThreads();
23190 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23191
23192 wxPyEndAllowThreads(__tstate);
23193 if (PyErr_Occurred()) SWIG_fail;
23194 }
23195 {
23196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23197 }
23198 return resultobj;
23199 fail:
23200 return NULL;
23201 }
23202
23203
23204 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args) {
23205 PyObject *resultobj;
23206 wxDateTime *arg1 = (wxDateTime *) 0 ;
23207 wxDateTime *arg2 = (wxDateTime *) 0 ;
23208 bool result;
23209 PyObject * obj0 = 0 ;
23210 PyObject * obj1 = 0 ;
23211
23212 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___eq__",&obj0,&obj1)) goto fail;
23213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23214 if (SWIG_arg_fail(1)) SWIG_fail;
23215 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23216 if (SWIG_arg_fail(2)) SWIG_fail;
23217 {
23218 PyThreadState* __tstate = wxPyBeginAllowThreads();
23219 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23220
23221 wxPyEndAllowThreads(__tstate);
23222 if (PyErr_Occurred()) SWIG_fail;
23223 }
23224 {
23225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23226 }
23227 return resultobj;
23228 fail:
23229 return NULL;
23230 }
23231
23232
23233 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args) {
23234 PyObject *resultobj;
23235 wxDateTime *arg1 = (wxDateTime *) 0 ;
23236 wxDateTime *arg2 = (wxDateTime *) 0 ;
23237 bool result;
23238 PyObject * obj0 = 0 ;
23239 PyObject * obj1 = 0 ;
23240
23241 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___ne__",&obj0,&obj1)) goto fail;
23242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23243 if (SWIG_arg_fail(1)) SWIG_fail;
23244 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23245 if (SWIG_arg_fail(2)) SWIG_fail;
23246 {
23247 PyThreadState* __tstate = wxPyBeginAllowThreads();
23248 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23249
23250 wxPyEndAllowThreads(__tstate);
23251 if (PyErr_Occurred()) SWIG_fail;
23252 }
23253 {
23254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23255 }
23256 return resultobj;
23257 fail:
23258 return NULL;
23259 }
23260
23261
23262 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23263 PyObject *resultobj;
23264 wxDateTime *arg1 = (wxDateTime *) 0 ;
23265 wxString *arg2 = 0 ;
23266 int result;
23267 bool temp2 = false ;
23268 PyObject * obj0 = 0 ;
23269 PyObject * obj1 = 0 ;
23270 char *kwnames[] = {
23271 (char *) "self",(char *) "date", NULL
23272 };
23273
23274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23276 if (SWIG_arg_fail(1)) SWIG_fail;
23277 {
23278 arg2 = wxString_in_helper(obj1);
23279 if (arg2 == NULL) SWIG_fail;
23280 temp2 = true;
23281 }
23282 {
23283 PyThreadState* __tstate = wxPyBeginAllowThreads();
23284 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23285
23286 wxPyEndAllowThreads(__tstate);
23287 if (PyErr_Occurred()) SWIG_fail;
23288 }
23289 {
23290 resultobj = SWIG_From_int((int)(result));
23291 }
23292 {
23293 if (temp2)
23294 delete arg2;
23295 }
23296 return resultobj;
23297 fail:
23298 {
23299 if (temp2)
23300 delete arg2;
23301 }
23302 return NULL;
23303 }
23304
23305
23306 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23307 PyObject *resultobj;
23308 wxDateTime *arg1 = (wxDateTime *) 0 ;
23309 wxString *arg2 = 0 ;
23310 wxString const &arg3_defvalue = wxPyDateFormatStr ;
23311 wxString *arg3 = (wxString *) &arg3_defvalue ;
23312 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23313 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23314 int result;
23315 bool temp2 = false ;
23316 bool temp3 = false ;
23317 PyObject * obj0 = 0 ;
23318 PyObject * obj1 = 0 ;
23319 PyObject * obj2 = 0 ;
23320 PyObject * obj3 = 0 ;
23321 char *kwnames[] = {
23322 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23323 };
23324
23325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23327 if (SWIG_arg_fail(1)) SWIG_fail;
23328 {
23329 arg2 = wxString_in_helper(obj1);
23330 if (arg2 == NULL) SWIG_fail;
23331 temp2 = true;
23332 }
23333 if (obj2) {
23334 {
23335 arg3 = wxString_in_helper(obj2);
23336 if (arg3 == NULL) SWIG_fail;
23337 temp3 = true;
23338 }
23339 }
23340 if (obj3) {
23341 {
23342 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23343 if (SWIG_arg_fail(4)) SWIG_fail;
23344 if (arg4 == NULL) {
23345 SWIG_null_ref("wxDateTime");
23346 }
23347 if (SWIG_arg_fail(4)) SWIG_fail;
23348 }
23349 }
23350 {
23351 PyThreadState* __tstate = wxPyBeginAllowThreads();
23352 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23353
23354 wxPyEndAllowThreads(__tstate);
23355 if (PyErr_Occurred()) SWIG_fail;
23356 }
23357 {
23358 resultobj = SWIG_From_int((int)(result));
23359 }
23360 {
23361 if (temp2)
23362 delete arg2;
23363 }
23364 {
23365 if (temp3)
23366 delete arg3;
23367 }
23368 return resultobj;
23369 fail:
23370 {
23371 if (temp2)
23372 delete arg2;
23373 }
23374 {
23375 if (temp3)
23376 delete arg3;
23377 }
23378 return NULL;
23379 }
23380
23381
23382 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23383 PyObject *resultobj;
23384 wxDateTime *arg1 = (wxDateTime *) 0 ;
23385 wxString *arg2 = 0 ;
23386 int result;
23387 bool temp2 = false ;
23388 PyObject * obj0 = 0 ;
23389 PyObject * obj1 = 0 ;
23390 char *kwnames[] = {
23391 (char *) "self",(char *) "datetime", NULL
23392 };
23393
23394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23396 if (SWIG_arg_fail(1)) SWIG_fail;
23397 {
23398 arg2 = wxString_in_helper(obj1);
23399 if (arg2 == NULL) SWIG_fail;
23400 temp2 = true;
23401 }
23402 {
23403 PyThreadState* __tstate = wxPyBeginAllowThreads();
23404 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23405
23406 wxPyEndAllowThreads(__tstate);
23407 if (PyErr_Occurred()) SWIG_fail;
23408 }
23409 {
23410 resultobj = SWIG_From_int((int)(result));
23411 }
23412 {
23413 if (temp2)
23414 delete arg2;
23415 }
23416 return resultobj;
23417 fail:
23418 {
23419 if (temp2)
23420 delete arg2;
23421 }
23422 return NULL;
23423 }
23424
23425
23426 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23427 PyObject *resultobj;
23428 wxDateTime *arg1 = (wxDateTime *) 0 ;
23429 wxString *arg2 = 0 ;
23430 int result;
23431 bool temp2 = false ;
23432 PyObject * obj0 = 0 ;
23433 PyObject * obj1 = 0 ;
23434 char *kwnames[] = {
23435 (char *) "self",(char *) "date", NULL
23436 };
23437
23438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23440 if (SWIG_arg_fail(1)) SWIG_fail;
23441 {
23442 arg2 = wxString_in_helper(obj1);
23443 if (arg2 == NULL) SWIG_fail;
23444 temp2 = true;
23445 }
23446 {
23447 PyThreadState* __tstate = wxPyBeginAllowThreads();
23448 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23449
23450 wxPyEndAllowThreads(__tstate);
23451 if (PyErr_Occurred()) SWIG_fail;
23452 }
23453 {
23454 resultobj = SWIG_From_int((int)(result));
23455 }
23456 {
23457 if (temp2)
23458 delete arg2;
23459 }
23460 return resultobj;
23461 fail:
23462 {
23463 if (temp2)
23464 delete arg2;
23465 }
23466 return NULL;
23467 }
23468
23469
23470 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23471 PyObject *resultobj;
23472 wxDateTime *arg1 = (wxDateTime *) 0 ;
23473 wxString *arg2 = 0 ;
23474 int result;
23475 bool temp2 = false ;
23476 PyObject * obj0 = 0 ;
23477 PyObject * obj1 = 0 ;
23478 char *kwnames[] = {
23479 (char *) "self",(char *) "time", NULL
23480 };
23481
23482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23484 if (SWIG_arg_fail(1)) SWIG_fail;
23485 {
23486 arg2 = wxString_in_helper(obj1);
23487 if (arg2 == NULL) SWIG_fail;
23488 temp2 = true;
23489 }
23490 {
23491 PyThreadState* __tstate = wxPyBeginAllowThreads();
23492 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23493
23494 wxPyEndAllowThreads(__tstate);
23495 if (PyErr_Occurred()) SWIG_fail;
23496 }
23497 {
23498 resultobj = SWIG_From_int((int)(result));
23499 }
23500 {
23501 if (temp2)
23502 delete arg2;
23503 }
23504 return resultobj;
23505 fail:
23506 {
23507 if (temp2)
23508 delete arg2;
23509 }
23510 return NULL;
23511 }
23512
23513
23514 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23515 PyObject *resultobj;
23516 wxDateTime *arg1 = (wxDateTime *) 0 ;
23517 wxString const &arg2_defvalue = wxPyDateFormatStr ;
23518 wxString *arg2 = (wxString *) &arg2_defvalue ;
23519 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23520 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23521 wxString result;
23522 bool temp2 = false ;
23523 bool temp3 = false ;
23524 PyObject * obj0 = 0 ;
23525 PyObject * obj1 = 0 ;
23526 PyObject * obj2 = 0 ;
23527 char *kwnames[] = {
23528 (char *) "self",(char *) "format",(char *) "tz", NULL
23529 };
23530
23531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23533 if (SWIG_arg_fail(1)) SWIG_fail;
23534 if (obj1) {
23535 {
23536 arg2 = wxString_in_helper(obj1);
23537 if (arg2 == NULL) SWIG_fail;
23538 temp2 = true;
23539 }
23540 }
23541 if (obj2) {
23542 {
23543 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23544 temp3 = true;
23545 }
23546 }
23547 {
23548 PyThreadState* __tstate = wxPyBeginAllowThreads();
23549 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23550
23551 wxPyEndAllowThreads(__tstate);
23552 if (PyErr_Occurred()) SWIG_fail;
23553 }
23554 {
23555 #if wxUSE_UNICODE
23556 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23557 #else
23558 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23559 #endif
23560 }
23561 {
23562 if (temp2)
23563 delete arg2;
23564 }
23565 {
23566 if (temp3) delete arg3;
23567 }
23568 return resultobj;
23569 fail:
23570 {
23571 if (temp2)
23572 delete arg2;
23573 }
23574 {
23575 if (temp3) delete arg3;
23576 }
23577 return NULL;
23578 }
23579
23580
23581 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23582 PyObject *resultobj;
23583 wxDateTime *arg1 = (wxDateTime *) 0 ;
23584 wxString result;
23585 PyObject * obj0 = 0 ;
23586 char *kwnames[] = {
23587 (char *) "self", NULL
23588 };
23589
23590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23592 if (SWIG_arg_fail(1)) SWIG_fail;
23593 {
23594 PyThreadState* __tstate = wxPyBeginAllowThreads();
23595 result = ((wxDateTime const *)arg1)->FormatDate();
23596
23597 wxPyEndAllowThreads(__tstate);
23598 if (PyErr_Occurred()) SWIG_fail;
23599 }
23600 {
23601 #if wxUSE_UNICODE
23602 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23603 #else
23604 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23605 #endif
23606 }
23607 return resultobj;
23608 fail:
23609 return NULL;
23610 }
23611
23612
23613 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23614 PyObject *resultobj;
23615 wxDateTime *arg1 = (wxDateTime *) 0 ;
23616 wxString result;
23617 PyObject * obj0 = 0 ;
23618 char *kwnames[] = {
23619 (char *) "self", NULL
23620 };
23621
23622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23624 if (SWIG_arg_fail(1)) SWIG_fail;
23625 {
23626 PyThreadState* __tstate = wxPyBeginAllowThreads();
23627 result = ((wxDateTime const *)arg1)->FormatTime();
23628
23629 wxPyEndAllowThreads(__tstate);
23630 if (PyErr_Occurred()) SWIG_fail;
23631 }
23632 {
23633 #if wxUSE_UNICODE
23634 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23635 #else
23636 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23637 #endif
23638 }
23639 return resultobj;
23640 fail:
23641 return NULL;
23642 }
23643
23644
23645 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23646 PyObject *resultobj;
23647 wxDateTime *arg1 = (wxDateTime *) 0 ;
23648 wxString result;
23649 PyObject * obj0 = 0 ;
23650 char *kwnames[] = {
23651 (char *) "self", NULL
23652 };
23653
23654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23656 if (SWIG_arg_fail(1)) SWIG_fail;
23657 {
23658 PyThreadState* __tstate = wxPyBeginAllowThreads();
23659 result = ((wxDateTime const *)arg1)->FormatISODate();
23660
23661 wxPyEndAllowThreads(__tstate);
23662 if (PyErr_Occurred()) SWIG_fail;
23663 }
23664 {
23665 #if wxUSE_UNICODE
23666 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23667 #else
23668 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23669 #endif
23670 }
23671 return resultobj;
23672 fail:
23673 return NULL;
23674 }
23675
23676
23677 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23678 PyObject *resultobj;
23679 wxDateTime *arg1 = (wxDateTime *) 0 ;
23680 wxString result;
23681 PyObject * obj0 = 0 ;
23682 char *kwnames[] = {
23683 (char *) "self", NULL
23684 };
23685
23686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23688 if (SWIG_arg_fail(1)) SWIG_fail;
23689 {
23690 PyThreadState* __tstate = wxPyBeginAllowThreads();
23691 result = ((wxDateTime const *)arg1)->FormatISOTime();
23692
23693 wxPyEndAllowThreads(__tstate);
23694 if (PyErr_Occurred()) SWIG_fail;
23695 }
23696 {
23697 #if wxUSE_UNICODE
23698 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23699 #else
23700 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23701 #endif
23702 }
23703 return resultobj;
23704 fail:
23705 return NULL;
23706 }
23707
23708
23709 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23710 PyObject *obj;
23711 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23712 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23713 Py_INCREF(obj);
23714 return Py_BuildValue((char *)"");
23715 }
23716 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23717 PyObject *resultobj;
23718 long arg1 ;
23719 wxTimeSpan result;
23720 PyObject * obj0 = 0 ;
23721 char *kwnames[] = {
23722 (char *) "sec", NULL
23723 };
23724
23725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23726 {
23727 arg1 = (long)(SWIG_As_long(obj0));
23728 if (SWIG_arg_fail(1)) SWIG_fail;
23729 }
23730 {
23731 PyThreadState* __tstate = wxPyBeginAllowThreads();
23732 result = wxTimeSpan::Seconds(arg1);
23733
23734 wxPyEndAllowThreads(__tstate);
23735 if (PyErr_Occurred()) SWIG_fail;
23736 }
23737 {
23738 wxTimeSpan * resultptr;
23739 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23740 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23741 }
23742 return resultobj;
23743 fail:
23744 return NULL;
23745 }
23746
23747
23748 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23749 PyObject *resultobj;
23750 wxTimeSpan result;
23751 char *kwnames[] = {
23752 NULL
23753 };
23754
23755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23756 {
23757 PyThreadState* __tstate = wxPyBeginAllowThreads();
23758 result = wxTimeSpan::Second();
23759
23760 wxPyEndAllowThreads(__tstate);
23761 if (PyErr_Occurred()) SWIG_fail;
23762 }
23763 {
23764 wxTimeSpan * resultptr;
23765 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23766 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23767 }
23768 return resultobj;
23769 fail:
23770 return NULL;
23771 }
23772
23773
23774 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23775 PyObject *resultobj;
23776 long arg1 ;
23777 wxTimeSpan result;
23778 PyObject * obj0 = 0 ;
23779 char *kwnames[] = {
23780 (char *) "min", NULL
23781 };
23782
23783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23784 {
23785 arg1 = (long)(SWIG_As_long(obj0));
23786 if (SWIG_arg_fail(1)) SWIG_fail;
23787 }
23788 {
23789 PyThreadState* __tstate = wxPyBeginAllowThreads();
23790 result = wxTimeSpan::Minutes(arg1);
23791
23792 wxPyEndAllowThreads(__tstate);
23793 if (PyErr_Occurred()) SWIG_fail;
23794 }
23795 {
23796 wxTimeSpan * resultptr;
23797 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23798 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23799 }
23800 return resultobj;
23801 fail:
23802 return NULL;
23803 }
23804
23805
23806 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23807 PyObject *resultobj;
23808 wxTimeSpan result;
23809 char *kwnames[] = {
23810 NULL
23811 };
23812
23813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23814 {
23815 PyThreadState* __tstate = wxPyBeginAllowThreads();
23816 result = wxTimeSpan::Minute();
23817
23818 wxPyEndAllowThreads(__tstate);
23819 if (PyErr_Occurred()) SWIG_fail;
23820 }
23821 {
23822 wxTimeSpan * resultptr;
23823 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23824 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23825 }
23826 return resultobj;
23827 fail:
23828 return NULL;
23829 }
23830
23831
23832 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23833 PyObject *resultobj;
23834 long arg1 ;
23835 wxTimeSpan result;
23836 PyObject * obj0 = 0 ;
23837 char *kwnames[] = {
23838 (char *) "hours", NULL
23839 };
23840
23841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23842 {
23843 arg1 = (long)(SWIG_As_long(obj0));
23844 if (SWIG_arg_fail(1)) SWIG_fail;
23845 }
23846 {
23847 PyThreadState* __tstate = wxPyBeginAllowThreads();
23848 result = wxTimeSpan::Hours(arg1);
23849
23850 wxPyEndAllowThreads(__tstate);
23851 if (PyErr_Occurred()) SWIG_fail;
23852 }
23853 {
23854 wxTimeSpan * resultptr;
23855 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23856 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23857 }
23858 return resultobj;
23859 fail:
23860 return NULL;
23861 }
23862
23863
23864 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23865 PyObject *resultobj;
23866 wxTimeSpan result;
23867 char *kwnames[] = {
23868 NULL
23869 };
23870
23871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23872 {
23873 PyThreadState* __tstate = wxPyBeginAllowThreads();
23874 result = wxTimeSpan::Hour();
23875
23876 wxPyEndAllowThreads(__tstate);
23877 if (PyErr_Occurred()) SWIG_fail;
23878 }
23879 {
23880 wxTimeSpan * resultptr;
23881 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23882 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23883 }
23884 return resultobj;
23885 fail:
23886 return NULL;
23887 }
23888
23889
23890 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23891 PyObject *resultobj;
23892 long arg1 ;
23893 wxTimeSpan result;
23894 PyObject * obj0 = 0 ;
23895 char *kwnames[] = {
23896 (char *) "days", NULL
23897 };
23898
23899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23900 {
23901 arg1 = (long)(SWIG_As_long(obj0));
23902 if (SWIG_arg_fail(1)) SWIG_fail;
23903 }
23904 {
23905 PyThreadState* __tstate = wxPyBeginAllowThreads();
23906 result = wxTimeSpan::Days(arg1);
23907
23908 wxPyEndAllowThreads(__tstate);
23909 if (PyErr_Occurred()) SWIG_fail;
23910 }
23911 {
23912 wxTimeSpan * resultptr;
23913 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23914 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23915 }
23916 return resultobj;
23917 fail:
23918 return NULL;
23919 }
23920
23921
23922 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23923 PyObject *resultobj;
23924 wxTimeSpan result;
23925 char *kwnames[] = {
23926 NULL
23927 };
23928
23929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23930 {
23931 PyThreadState* __tstate = wxPyBeginAllowThreads();
23932 result = wxTimeSpan::Day();
23933
23934 wxPyEndAllowThreads(__tstate);
23935 if (PyErr_Occurred()) SWIG_fail;
23936 }
23937 {
23938 wxTimeSpan * resultptr;
23939 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23940 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23941 }
23942 return resultobj;
23943 fail:
23944 return NULL;
23945 }
23946
23947
23948 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23949 PyObject *resultobj;
23950 long arg1 ;
23951 wxTimeSpan result;
23952 PyObject * obj0 = 0 ;
23953 char *kwnames[] = {
23954 (char *) "days", NULL
23955 };
23956
23957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23958 {
23959 arg1 = (long)(SWIG_As_long(obj0));
23960 if (SWIG_arg_fail(1)) SWIG_fail;
23961 }
23962 {
23963 PyThreadState* __tstate = wxPyBeginAllowThreads();
23964 result = wxTimeSpan::Weeks(arg1);
23965
23966 wxPyEndAllowThreads(__tstate);
23967 if (PyErr_Occurred()) SWIG_fail;
23968 }
23969 {
23970 wxTimeSpan * resultptr;
23971 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23972 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23973 }
23974 return resultobj;
23975 fail:
23976 return NULL;
23977 }
23978
23979
23980 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
23981 PyObject *resultobj;
23982 wxTimeSpan result;
23983 char *kwnames[] = {
23984 NULL
23985 };
23986
23987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
23988 {
23989 PyThreadState* __tstate = wxPyBeginAllowThreads();
23990 result = wxTimeSpan::Week();
23991
23992 wxPyEndAllowThreads(__tstate);
23993 if (PyErr_Occurred()) SWIG_fail;
23994 }
23995 {
23996 wxTimeSpan * resultptr;
23997 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23998 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23999 }
24000 return resultobj;
24001 fail:
24002 return NULL;
24003 }
24004
24005
24006 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24007 PyObject *resultobj;
24008 long arg1 = (long) 0 ;
24009 long arg2 = (long) 0 ;
24010 long arg3 = (long) 0 ;
24011 long arg4 = (long) 0 ;
24012 wxTimeSpan *result;
24013 PyObject * obj0 = 0 ;
24014 PyObject * obj1 = 0 ;
24015 PyObject * obj2 = 0 ;
24016 PyObject * obj3 = 0 ;
24017 char *kwnames[] = {
24018 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24019 };
24020
24021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24022 if (obj0) {
24023 {
24024 arg1 = (long)(SWIG_As_long(obj0));
24025 if (SWIG_arg_fail(1)) SWIG_fail;
24026 }
24027 }
24028 if (obj1) {
24029 {
24030 arg2 = (long)(SWIG_As_long(obj1));
24031 if (SWIG_arg_fail(2)) SWIG_fail;
24032 }
24033 }
24034 if (obj2) {
24035 {
24036 arg3 = (long)(SWIG_As_long(obj2));
24037 if (SWIG_arg_fail(3)) SWIG_fail;
24038 }
24039 }
24040 if (obj3) {
24041 {
24042 arg4 = (long)(SWIG_As_long(obj3));
24043 if (SWIG_arg_fail(4)) SWIG_fail;
24044 }
24045 }
24046 {
24047 PyThreadState* __tstate = wxPyBeginAllowThreads();
24048 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24049
24050 wxPyEndAllowThreads(__tstate);
24051 if (PyErr_Occurred()) SWIG_fail;
24052 }
24053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24054 return resultobj;
24055 fail:
24056 return NULL;
24057 }
24058
24059
24060 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24061 PyObject *resultobj;
24062 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24063 PyObject * obj0 = 0 ;
24064 char *kwnames[] = {
24065 (char *) "self", NULL
24066 };
24067
24068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24070 if (SWIG_arg_fail(1)) SWIG_fail;
24071 {
24072 PyThreadState* __tstate = wxPyBeginAllowThreads();
24073 delete arg1;
24074
24075 wxPyEndAllowThreads(__tstate);
24076 if (PyErr_Occurred()) SWIG_fail;
24077 }
24078 Py_INCREF(Py_None); resultobj = Py_None;
24079 return resultobj;
24080 fail:
24081 return NULL;
24082 }
24083
24084
24085 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24086 PyObject *resultobj;
24087 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24088 wxTimeSpan *arg2 = 0 ;
24089 wxTimeSpan *result;
24090 PyObject * obj0 = 0 ;
24091 PyObject * obj1 = 0 ;
24092 char *kwnames[] = {
24093 (char *) "self",(char *) "diff", NULL
24094 };
24095
24096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24098 if (SWIG_arg_fail(1)) SWIG_fail;
24099 {
24100 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24101 if (SWIG_arg_fail(2)) SWIG_fail;
24102 if (arg2 == NULL) {
24103 SWIG_null_ref("wxTimeSpan");
24104 }
24105 if (SWIG_arg_fail(2)) SWIG_fail;
24106 }
24107 {
24108 PyThreadState* __tstate = wxPyBeginAllowThreads();
24109 {
24110 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24111 result = (wxTimeSpan *) &_result_ref;
24112 }
24113
24114 wxPyEndAllowThreads(__tstate);
24115 if (PyErr_Occurred()) SWIG_fail;
24116 }
24117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24118 return resultobj;
24119 fail:
24120 return NULL;
24121 }
24122
24123
24124 static PyObject *_wrap_TimeSpan_Subtract(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_Subtract",kwnames,&obj0,&obj1)) goto fail;
24136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
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)->Subtract((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, 0);
24157 return resultobj;
24158 fail:
24159 return NULL;
24160 }
24161
24162
24163 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24164 PyObject *resultobj;
24165 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24166 int arg2 ;
24167 wxTimeSpan *result;
24168 PyObject * obj0 = 0 ;
24169 PyObject * obj1 = 0 ;
24170 char *kwnames[] = {
24171 (char *) "self",(char *) "n", NULL
24172 };
24173
24174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24176 if (SWIG_arg_fail(1)) SWIG_fail;
24177 {
24178 arg2 = (int)(SWIG_As_int(obj1));
24179 if (SWIG_arg_fail(2)) SWIG_fail;
24180 }
24181 {
24182 PyThreadState* __tstate = wxPyBeginAllowThreads();
24183 {
24184 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24185 result = (wxTimeSpan *) &_result_ref;
24186 }
24187
24188 wxPyEndAllowThreads(__tstate);
24189 if (PyErr_Occurred()) SWIG_fail;
24190 }
24191 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24192 return resultobj;
24193 fail:
24194 return NULL;
24195 }
24196
24197
24198 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24199 PyObject *resultobj;
24200 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24201 wxTimeSpan *result;
24202 PyObject * obj0 = 0 ;
24203 char *kwnames[] = {
24204 (char *) "self", NULL
24205 };
24206
24207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24209 if (SWIG_arg_fail(1)) SWIG_fail;
24210 {
24211 PyThreadState* __tstate = wxPyBeginAllowThreads();
24212 {
24213 wxTimeSpan &_result_ref = (arg1)->Neg();
24214 result = (wxTimeSpan *) &_result_ref;
24215 }
24216
24217 wxPyEndAllowThreads(__tstate);
24218 if (PyErr_Occurred()) SWIG_fail;
24219 }
24220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24221 return resultobj;
24222 fail:
24223 return NULL;
24224 }
24225
24226
24227 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24228 PyObject *resultobj;
24229 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24230 wxTimeSpan result;
24231 PyObject * obj0 = 0 ;
24232 char *kwnames[] = {
24233 (char *) "self", NULL
24234 };
24235
24236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24238 if (SWIG_arg_fail(1)) SWIG_fail;
24239 {
24240 PyThreadState* __tstate = wxPyBeginAllowThreads();
24241 result = ((wxTimeSpan const *)arg1)->Abs();
24242
24243 wxPyEndAllowThreads(__tstate);
24244 if (PyErr_Occurred()) SWIG_fail;
24245 }
24246 {
24247 wxTimeSpan * resultptr;
24248 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24249 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24250 }
24251 return resultobj;
24252 fail:
24253 return NULL;
24254 }
24255
24256
24257 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24258 PyObject *resultobj;
24259 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24260 wxTimeSpan *arg2 = 0 ;
24261 wxTimeSpan *result;
24262 PyObject * obj0 = 0 ;
24263 PyObject * obj1 = 0 ;
24264 char *kwnames[] = {
24265 (char *) "self",(char *) "diff", NULL
24266 };
24267
24268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24270 if (SWIG_arg_fail(1)) SWIG_fail;
24271 {
24272 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24273 if (SWIG_arg_fail(2)) SWIG_fail;
24274 if (arg2 == NULL) {
24275 SWIG_null_ref("wxTimeSpan");
24276 }
24277 if (SWIG_arg_fail(2)) SWIG_fail;
24278 }
24279 {
24280 PyThreadState* __tstate = wxPyBeginAllowThreads();
24281 {
24282 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24283 result = (wxTimeSpan *) &_result_ref;
24284 }
24285
24286 wxPyEndAllowThreads(__tstate);
24287 if (PyErr_Occurred()) SWIG_fail;
24288 }
24289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24290 return resultobj;
24291 fail:
24292 return NULL;
24293 }
24294
24295
24296 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24297 PyObject *resultobj;
24298 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24299 wxTimeSpan *arg2 = 0 ;
24300 wxTimeSpan *result;
24301 PyObject * obj0 = 0 ;
24302 PyObject * obj1 = 0 ;
24303 char *kwnames[] = {
24304 (char *) "self",(char *) "diff", NULL
24305 };
24306
24307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24309 if (SWIG_arg_fail(1)) SWIG_fail;
24310 {
24311 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24312 if (SWIG_arg_fail(2)) SWIG_fail;
24313 if (arg2 == NULL) {
24314 SWIG_null_ref("wxTimeSpan");
24315 }
24316 if (SWIG_arg_fail(2)) SWIG_fail;
24317 }
24318 {
24319 PyThreadState* __tstate = wxPyBeginAllowThreads();
24320 {
24321 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24322 result = (wxTimeSpan *) &_result_ref;
24323 }
24324
24325 wxPyEndAllowThreads(__tstate);
24326 if (PyErr_Occurred()) SWIG_fail;
24327 }
24328 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24336 PyObject *resultobj;
24337 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24338 int arg2 ;
24339 wxTimeSpan *result;
24340 PyObject * obj0 = 0 ;
24341 PyObject * obj1 = 0 ;
24342 char *kwnames[] = {
24343 (char *) "self",(char *) "n", NULL
24344 };
24345
24346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24348 if (SWIG_arg_fail(1)) SWIG_fail;
24349 {
24350 arg2 = (int)(SWIG_As_int(obj1));
24351 if (SWIG_arg_fail(2)) SWIG_fail;
24352 }
24353 {
24354 PyThreadState* __tstate = wxPyBeginAllowThreads();
24355 {
24356 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24357 result = (wxTimeSpan *) &_result_ref;
24358 }
24359
24360 wxPyEndAllowThreads(__tstate);
24361 if (PyErr_Occurred()) SWIG_fail;
24362 }
24363 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24364 return resultobj;
24365 fail:
24366 return NULL;
24367 }
24368
24369
24370 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24371 PyObject *resultobj;
24372 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24373 wxTimeSpan *result;
24374 PyObject * obj0 = 0 ;
24375 char *kwnames[] = {
24376 (char *) "self", NULL
24377 };
24378
24379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24381 if (SWIG_arg_fail(1)) SWIG_fail;
24382 {
24383 PyThreadState* __tstate = wxPyBeginAllowThreads();
24384 {
24385 wxTimeSpan &_result_ref = (arg1)->operator -();
24386 result = (wxTimeSpan *) &_result_ref;
24387 }
24388
24389 wxPyEndAllowThreads(__tstate);
24390 if (PyErr_Occurred()) SWIG_fail;
24391 }
24392 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24393 return resultobj;
24394 fail:
24395 return NULL;
24396 }
24397
24398
24399 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24400 PyObject *resultobj;
24401 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24402 wxTimeSpan *arg2 = 0 ;
24403 wxTimeSpan result;
24404 PyObject * obj0 = 0 ;
24405 PyObject * obj1 = 0 ;
24406 char *kwnames[] = {
24407 (char *) "self",(char *) "other", NULL
24408 };
24409
24410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24412 if (SWIG_arg_fail(1)) SWIG_fail;
24413 {
24414 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24415 if (SWIG_arg_fail(2)) SWIG_fail;
24416 if (arg2 == NULL) {
24417 SWIG_null_ref("wxTimeSpan");
24418 }
24419 if (SWIG_arg_fail(2)) SWIG_fail;
24420 }
24421 {
24422 PyThreadState* __tstate = wxPyBeginAllowThreads();
24423 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24424
24425 wxPyEndAllowThreads(__tstate);
24426 if (PyErr_Occurred()) SWIG_fail;
24427 }
24428 {
24429 wxTimeSpan * resultptr;
24430 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24431 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24432 }
24433 return resultobj;
24434 fail:
24435 return NULL;
24436 }
24437
24438
24439 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24440 PyObject *resultobj;
24441 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24442 wxTimeSpan *arg2 = 0 ;
24443 wxTimeSpan result;
24444 PyObject * obj0 = 0 ;
24445 PyObject * obj1 = 0 ;
24446 char *kwnames[] = {
24447 (char *) "self",(char *) "other", NULL
24448 };
24449
24450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24452 if (SWIG_arg_fail(1)) SWIG_fail;
24453 {
24454 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24455 if (SWIG_arg_fail(2)) SWIG_fail;
24456 if (arg2 == NULL) {
24457 SWIG_null_ref("wxTimeSpan");
24458 }
24459 if (SWIG_arg_fail(2)) SWIG_fail;
24460 }
24461 {
24462 PyThreadState* __tstate = wxPyBeginAllowThreads();
24463 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24464
24465 wxPyEndAllowThreads(__tstate);
24466 if (PyErr_Occurred()) SWIG_fail;
24467 }
24468 {
24469 wxTimeSpan * resultptr;
24470 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24471 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24472 }
24473 return resultobj;
24474 fail:
24475 return NULL;
24476 }
24477
24478
24479 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24480 PyObject *resultobj;
24481 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24482 int arg2 ;
24483 wxTimeSpan result;
24484 PyObject * obj0 = 0 ;
24485 PyObject * obj1 = 0 ;
24486 char *kwnames[] = {
24487 (char *) "self",(char *) "n", NULL
24488 };
24489
24490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24492 if (SWIG_arg_fail(1)) SWIG_fail;
24493 {
24494 arg2 = (int)(SWIG_As_int(obj1));
24495 if (SWIG_arg_fail(2)) SWIG_fail;
24496 }
24497 {
24498 PyThreadState* __tstate = wxPyBeginAllowThreads();
24499 result = wxTimeSpan___mul__(arg1,arg2);
24500
24501 wxPyEndAllowThreads(__tstate);
24502 if (PyErr_Occurred()) SWIG_fail;
24503 }
24504 {
24505 wxTimeSpan * resultptr;
24506 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24507 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24508 }
24509 return resultobj;
24510 fail:
24511 return NULL;
24512 }
24513
24514
24515 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24516 PyObject *resultobj;
24517 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24518 int arg2 ;
24519 wxTimeSpan result;
24520 PyObject * obj0 = 0 ;
24521 PyObject * obj1 = 0 ;
24522 char *kwnames[] = {
24523 (char *) "self",(char *) "n", NULL
24524 };
24525
24526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24528 if (SWIG_arg_fail(1)) SWIG_fail;
24529 {
24530 arg2 = (int)(SWIG_As_int(obj1));
24531 if (SWIG_arg_fail(2)) SWIG_fail;
24532 }
24533 {
24534 PyThreadState* __tstate = wxPyBeginAllowThreads();
24535 result = wxTimeSpan___rmul__(arg1,arg2);
24536
24537 wxPyEndAllowThreads(__tstate);
24538 if (PyErr_Occurred()) SWIG_fail;
24539 }
24540 {
24541 wxTimeSpan * resultptr;
24542 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24543 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24544 }
24545 return resultobj;
24546 fail:
24547 return NULL;
24548 }
24549
24550
24551 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24552 PyObject *resultobj;
24553 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24554 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24555 bool result;
24556 PyObject * obj0 = 0 ;
24557 PyObject * obj1 = 0 ;
24558 char *kwnames[] = {
24559 (char *) "self",(char *) "other", NULL
24560 };
24561
24562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24564 if (SWIG_arg_fail(1)) SWIG_fail;
24565 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24566 if (SWIG_arg_fail(2)) SWIG_fail;
24567 {
24568 PyThreadState* __tstate = wxPyBeginAllowThreads();
24569 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24570
24571 wxPyEndAllowThreads(__tstate);
24572 if (PyErr_Occurred()) SWIG_fail;
24573 }
24574 {
24575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24576 }
24577 return resultobj;
24578 fail:
24579 return NULL;
24580 }
24581
24582
24583 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24584 PyObject *resultobj;
24585 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24586 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24587 bool result;
24588 PyObject * obj0 = 0 ;
24589 PyObject * obj1 = 0 ;
24590 char *kwnames[] = {
24591 (char *) "self",(char *) "other", NULL
24592 };
24593
24594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24596 if (SWIG_arg_fail(1)) SWIG_fail;
24597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24598 if (SWIG_arg_fail(2)) SWIG_fail;
24599 {
24600 PyThreadState* __tstate = wxPyBeginAllowThreads();
24601 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24602
24603 wxPyEndAllowThreads(__tstate);
24604 if (PyErr_Occurred()) SWIG_fail;
24605 }
24606 {
24607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24608 }
24609 return resultobj;
24610 fail:
24611 return NULL;
24612 }
24613
24614
24615 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24616 PyObject *resultobj;
24617 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24618 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24619 bool result;
24620 PyObject * obj0 = 0 ;
24621 PyObject * obj1 = 0 ;
24622 char *kwnames[] = {
24623 (char *) "self",(char *) "other", NULL
24624 };
24625
24626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24628 if (SWIG_arg_fail(1)) SWIG_fail;
24629 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24630 if (SWIG_arg_fail(2)) SWIG_fail;
24631 {
24632 PyThreadState* __tstate = wxPyBeginAllowThreads();
24633 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24634
24635 wxPyEndAllowThreads(__tstate);
24636 if (PyErr_Occurred()) SWIG_fail;
24637 }
24638 {
24639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24640 }
24641 return resultobj;
24642 fail:
24643 return NULL;
24644 }
24645
24646
24647 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24648 PyObject *resultobj;
24649 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24650 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24651 bool result;
24652 PyObject * obj0 = 0 ;
24653 PyObject * obj1 = 0 ;
24654 char *kwnames[] = {
24655 (char *) "self",(char *) "other", NULL
24656 };
24657
24658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24660 if (SWIG_arg_fail(1)) SWIG_fail;
24661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24662 if (SWIG_arg_fail(2)) SWIG_fail;
24663 {
24664 PyThreadState* __tstate = wxPyBeginAllowThreads();
24665 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24666
24667 wxPyEndAllowThreads(__tstate);
24668 if (PyErr_Occurred()) SWIG_fail;
24669 }
24670 {
24671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24672 }
24673 return resultobj;
24674 fail:
24675 return NULL;
24676 }
24677
24678
24679 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24680 PyObject *resultobj;
24681 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24682 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24683 bool result;
24684 PyObject * obj0 = 0 ;
24685 PyObject * obj1 = 0 ;
24686 char *kwnames[] = {
24687 (char *) "self",(char *) "other", NULL
24688 };
24689
24690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24692 if (SWIG_arg_fail(1)) SWIG_fail;
24693 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24694 if (SWIG_arg_fail(2)) SWIG_fail;
24695 {
24696 PyThreadState* __tstate = wxPyBeginAllowThreads();
24697 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24698
24699 wxPyEndAllowThreads(__tstate);
24700 if (PyErr_Occurred()) SWIG_fail;
24701 }
24702 {
24703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24704 }
24705 return resultobj;
24706 fail:
24707 return NULL;
24708 }
24709
24710
24711 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24712 PyObject *resultobj;
24713 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24714 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24715 bool result;
24716 PyObject * obj0 = 0 ;
24717 PyObject * obj1 = 0 ;
24718 char *kwnames[] = {
24719 (char *) "self",(char *) "other", NULL
24720 };
24721
24722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24724 if (SWIG_arg_fail(1)) SWIG_fail;
24725 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24726 if (SWIG_arg_fail(2)) SWIG_fail;
24727 {
24728 PyThreadState* __tstate = wxPyBeginAllowThreads();
24729 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24730
24731 wxPyEndAllowThreads(__tstate);
24732 if (PyErr_Occurred()) SWIG_fail;
24733 }
24734 {
24735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24736 }
24737 return resultobj;
24738 fail:
24739 return NULL;
24740 }
24741
24742
24743 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24744 PyObject *resultobj;
24745 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24746 bool result;
24747 PyObject * obj0 = 0 ;
24748 char *kwnames[] = {
24749 (char *) "self", NULL
24750 };
24751
24752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24754 if (SWIG_arg_fail(1)) SWIG_fail;
24755 {
24756 PyThreadState* __tstate = wxPyBeginAllowThreads();
24757 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24758
24759 wxPyEndAllowThreads(__tstate);
24760 if (PyErr_Occurred()) SWIG_fail;
24761 }
24762 {
24763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24764 }
24765 return resultobj;
24766 fail:
24767 return NULL;
24768 }
24769
24770
24771 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24772 PyObject *resultobj;
24773 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24774 bool result;
24775 PyObject * obj0 = 0 ;
24776 char *kwnames[] = {
24777 (char *) "self", NULL
24778 };
24779
24780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24782 if (SWIG_arg_fail(1)) SWIG_fail;
24783 {
24784 PyThreadState* __tstate = wxPyBeginAllowThreads();
24785 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24786
24787 wxPyEndAllowThreads(__tstate);
24788 if (PyErr_Occurred()) SWIG_fail;
24789 }
24790 {
24791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24792 }
24793 return resultobj;
24794 fail:
24795 return NULL;
24796 }
24797
24798
24799 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24800 PyObject *resultobj;
24801 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24802 bool result;
24803 PyObject * obj0 = 0 ;
24804 char *kwnames[] = {
24805 (char *) "self", NULL
24806 };
24807
24808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24810 if (SWIG_arg_fail(1)) SWIG_fail;
24811 {
24812 PyThreadState* __tstate = wxPyBeginAllowThreads();
24813 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24814
24815 wxPyEndAllowThreads(__tstate);
24816 if (PyErr_Occurred()) SWIG_fail;
24817 }
24818 {
24819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24820 }
24821 return resultobj;
24822 fail:
24823 return NULL;
24824 }
24825
24826
24827 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24828 PyObject *resultobj;
24829 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24830 wxTimeSpan *arg2 = 0 ;
24831 bool result;
24832 PyObject * obj0 = 0 ;
24833 PyObject * obj1 = 0 ;
24834 char *kwnames[] = {
24835 (char *) "self",(char *) "ts", NULL
24836 };
24837
24838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24840 if (SWIG_arg_fail(1)) SWIG_fail;
24841 {
24842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24843 if (SWIG_arg_fail(2)) SWIG_fail;
24844 if (arg2 == NULL) {
24845 SWIG_null_ref("wxTimeSpan");
24846 }
24847 if (SWIG_arg_fail(2)) SWIG_fail;
24848 }
24849 {
24850 PyThreadState* __tstate = wxPyBeginAllowThreads();
24851 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24852
24853 wxPyEndAllowThreads(__tstate);
24854 if (PyErr_Occurred()) SWIG_fail;
24855 }
24856 {
24857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24858 }
24859 return resultobj;
24860 fail:
24861 return NULL;
24862 }
24863
24864
24865 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24866 PyObject *resultobj;
24867 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24868 wxTimeSpan *arg2 = 0 ;
24869 bool result;
24870 PyObject * obj0 = 0 ;
24871 PyObject * obj1 = 0 ;
24872 char *kwnames[] = {
24873 (char *) "self",(char *) "ts", NULL
24874 };
24875
24876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24878 if (SWIG_arg_fail(1)) SWIG_fail;
24879 {
24880 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24881 if (SWIG_arg_fail(2)) SWIG_fail;
24882 if (arg2 == NULL) {
24883 SWIG_null_ref("wxTimeSpan");
24884 }
24885 if (SWIG_arg_fail(2)) SWIG_fail;
24886 }
24887 {
24888 PyThreadState* __tstate = wxPyBeginAllowThreads();
24889 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24890
24891 wxPyEndAllowThreads(__tstate);
24892 if (PyErr_Occurred()) SWIG_fail;
24893 }
24894 {
24895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24896 }
24897 return resultobj;
24898 fail:
24899 return NULL;
24900 }
24901
24902
24903 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24904 PyObject *resultobj;
24905 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24906 wxTimeSpan *arg2 = 0 ;
24907 bool result;
24908 PyObject * obj0 = 0 ;
24909 PyObject * obj1 = 0 ;
24910 char *kwnames[] = {
24911 (char *) "self",(char *) "t", NULL
24912 };
24913
24914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24916 if (SWIG_arg_fail(1)) SWIG_fail;
24917 {
24918 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24919 if (SWIG_arg_fail(2)) SWIG_fail;
24920 if (arg2 == NULL) {
24921 SWIG_null_ref("wxTimeSpan");
24922 }
24923 if (SWIG_arg_fail(2)) SWIG_fail;
24924 }
24925 {
24926 PyThreadState* __tstate = wxPyBeginAllowThreads();
24927 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24928
24929 wxPyEndAllowThreads(__tstate);
24930 if (PyErr_Occurred()) SWIG_fail;
24931 }
24932 {
24933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24934 }
24935 return resultobj;
24936 fail:
24937 return NULL;
24938 }
24939
24940
24941 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24942 PyObject *resultobj;
24943 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24944 int result;
24945 PyObject * obj0 = 0 ;
24946 char *kwnames[] = {
24947 (char *) "self", NULL
24948 };
24949
24950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24952 if (SWIG_arg_fail(1)) SWIG_fail;
24953 {
24954 PyThreadState* __tstate = wxPyBeginAllowThreads();
24955 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24956
24957 wxPyEndAllowThreads(__tstate);
24958 if (PyErr_Occurred()) SWIG_fail;
24959 }
24960 {
24961 resultobj = SWIG_From_int((int)(result));
24962 }
24963 return resultobj;
24964 fail:
24965 return NULL;
24966 }
24967
24968
24969 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24970 PyObject *resultobj;
24971 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24972 int result;
24973 PyObject * obj0 = 0 ;
24974 char *kwnames[] = {
24975 (char *) "self", NULL
24976 };
24977
24978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
24979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24980 if (SWIG_arg_fail(1)) SWIG_fail;
24981 {
24982 PyThreadState* __tstate = wxPyBeginAllowThreads();
24983 result = (int)((wxTimeSpan const *)arg1)->GetDays();
24984
24985 wxPyEndAllowThreads(__tstate);
24986 if (PyErr_Occurred()) SWIG_fail;
24987 }
24988 {
24989 resultobj = SWIG_From_int((int)(result));
24990 }
24991 return resultobj;
24992 fail:
24993 return NULL;
24994 }
24995
24996
24997 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
24998 PyObject *resultobj;
24999 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25000 int result;
25001 PyObject * obj0 = 0 ;
25002 char *kwnames[] = {
25003 (char *) "self", NULL
25004 };
25005
25006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25008 if (SWIG_arg_fail(1)) SWIG_fail;
25009 {
25010 PyThreadState* __tstate = wxPyBeginAllowThreads();
25011 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25012
25013 wxPyEndAllowThreads(__tstate);
25014 if (PyErr_Occurred()) SWIG_fail;
25015 }
25016 {
25017 resultobj = SWIG_From_int((int)(result));
25018 }
25019 return resultobj;
25020 fail:
25021 return NULL;
25022 }
25023
25024
25025 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25026 PyObject *resultobj;
25027 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25028 int result;
25029 PyObject * obj0 = 0 ;
25030 char *kwnames[] = {
25031 (char *) "self", NULL
25032 };
25033
25034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25036 if (SWIG_arg_fail(1)) SWIG_fail;
25037 {
25038 PyThreadState* __tstate = wxPyBeginAllowThreads();
25039 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25040
25041 wxPyEndAllowThreads(__tstate);
25042 if (PyErr_Occurred()) SWIG_fail;
25043 }
25044 {
25045 resultobj = SWIG_From_int((int)(result));
25046 }
25047 return resultobj;
25048 fail:
25049 return NULL;
25050 }
25051
25052
25053 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25054 PyObject *resultobj;
25055 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25056 wxLongLong result;
25057 PyObject * obj0 = 0 ;
25058 char *kwnames[] = {
25059 (char *) "self", NULL
25060 };
25061
25062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25064 if (SWIG_arg_fail(1)) SWIG_fail;
25065 {
25066 PyThreadState* __tstate = wxPyBeginAllowThreads();
25067 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25068
25069 wxPyEndAllowThreads(__tstate);
25070 if (PyErr_Occurred()) SWIG_fail;
25071 }
25072 {
25073 PyObject *hi, *lo, *shifter, *shifted;
25074 hi = PyLong_FromLong( (&result)->GetHi() );
25075 lo = PyLong_FromLong( (&result)->GetLo() );
25076 shifter = PyLong_FromLong(32);
25077 shifted = PyNumber_Lshift(hi, shifter);
25078 resultobj = PyNumber_Or(shifted, lo);
25079 Py_DECREF(hi);
25080 Py_DECREF(lo);
25081 Py_DECREF(shifter);
25082 Py_DECREF(shifted);
25083 }
25084 return resultobj;
25085 fail:
25086 return NULL;
25087 }
25088
25089
25090 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25091 PyObject *resultobj;
25092 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25093 wxLongLong result;
25094 PyObject * obj0 = 0 ;
25095 char *kwnames[] = {
25096 (char *) "self", NULL
25097 };
25098
25099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25101 if (SWIG_arg_fail(1)) SWIG_fail;
25102 {
25103 PyThreadState* __tstate = wxPyBeginAllowThreads();
25104 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25105
25106 wxPyEndAllowThreads(__tstate);
25107 if (PyErr_Occurred()) SWIG_fail;
25108 }
25109 {
25110 PyObject *hi, *lo, *shifter, *shifted;
25111 hi = PyLong_FromLong( (&result)->GetHi() );
25112 lo = PyLong_FromLong( (&result)->GetLo() );
25113 shifter = PyLong_FromLong(32);
25114 shifted = PyNumber_Lshift(hi, shifter);
25115 resultobj = PyNumber_Or(shifted, lo);
25116 Py_DECREF(hi);
25117 Py_DECREF(lo);
25118 Py_DECREF(shifter);
25119 Py_DECREF(shifted);
25120 }
25121 return resultobj;
25122 fail:
25123 return NULL;
25124 }
25125
25126
25127 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25128 PyObject *resultobj;
25129 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25130 wxString const &arg2_defvalue = wxPyTimeSpanFormatStr ;
25131 wxString *arg2 = (wxString *) &arg2_defvalue ;
25132 wxString result;
25133 bool temp2 = false ;
25134 PyObject * obj0 = 0 ;
25135 PyObject * obj1 = 0 ;
25136 char *kwnames[] = {
25137 (char *) "self",(char *) "format", NULL
25138 };
25139
25140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25142 if (SWIG_arg_fail(1)) SWIG_fail;
25143 if (obj1) {
25144 {
25145 arg2 = wxString_in_helper(obj1);
25146 if (arg2 == NULL) SWIG_fail;
25147 temp2 = true;
25148 }
25149 }
25150 {
25151 PyThreadState* __tstate = wxPyBeginAllowThreads();
25152 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25153
25154 wxPyEndAllowThreads(__tstate);
25155 if (PyErr_Occurred()) SWIG_fail;
25156 }
25157 {
25158 #if wxUSE_UNICODE
25159 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25160 #else
25161 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25162 #endif
25163 }
25164 {
25165 if (temp2)
25166 delete arg2;
25167 }
25168 return resultobj;
25169 fail:
25170 {
25171 if (temp2)
25172 delete arg2;
25173 }
25174 return NULL;
25175 }
25176
25177
25178 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25179 PyObject *obj;
25180 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25181 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25182 Py_INCREF(obj);
25183 return Py_BuildValue((char *)"");
25184 }
25185 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25186 PyObject *resultobj;
25187 int arg1 = (int) 0 ;
25188 int arg2 = (int) 0 ;
25189 int arg3 = (int) 0 ;
25190 int arg4 = (int) 0 ;
25191 wxDateSpan *result;
25192 PyObject * obj0 = 0 ;
25193 PyObject * obj1 = 0 ;
25194 PyObject * obj2 = 0 ;
25195 PyObject * obj3 = 0 ;
25196 char *kwnames[] = {
25197 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25198 };
25199
25200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25201 if (obj0) {
25202 {
25203 arg1 = (int)(SWIG_As_int(obj0));
25204 if (SWIG_arg_fail(1)) SWIG_fail;
25205 }
25206 }
25207 if (obj1) {
25208 {
25209 arg2 = (int)(SWIG_As_int(obj1));
25210 if (SWIG_arg_fail(2)) SWIG_fail;
25211 }
25212 }
25213 if (obj2) {
25214 {
25215 arg3 = (int)(SWIG_As_int(obj2));
25216 if (SWIG_arg_fail(3)) SWIG_fail;
25217 }
25218 }
25219 if (obj3) {
25220 {
25221 arg4 = (int)(SWIG_As_int(obj3));
25222 if (SWIG_arg_fail(4)) SWIG_fail;
25223 }
25224 }
25225 {
25226 PyThreadState* __tstate = wxPyBeginAllowThreads();
25227 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25228
25229 wxPyEndAllowThreads(__tstate);
25230 if (PyErr_Occurred()) SWIG_fail;
25231 }
25232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25233 return resultobj;
25234 fail:
25235 return NULL;
25236 }
25237
25238
25239 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25240 PyObject *resultobj;
25241 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25242 PyObject * obj0 = 0 ;
25243 char *kwnames[] = {
25244 (char *) "self", NULL
25245 };
25246
25247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25249 if (SWIG_arg_fail(1)) SWIG_fail;
25250 {
25251 PyThreadState* __tstate = wxPyBeginAllowThreads();
25252 delete arg1;
25253
25254 wxPyEndAllowThreads(__tstate);
25255 if (PyErr_Occurred()) SWIG_fail;
25256 }
25257 Py_INCREF(Py_None); resultobj = Py_None;
25258 return resultobj;
25259 fail:
25260 return NULL;
25261 }
25262
25263
25264 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25265 PyObject *resultobj;
25266 int arg1 ;
25267 wxDateSpan result;
25268 PyObject * obj0 = 0 ;
25269 char *kwnames[] = {
25270 (char *) "days", NULL
25271 };
25272
25273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25274 {
25275 arg1 = (int)(SWIG_As_int(obj0));
25276 if (SWIG_arg_fail(1)) SWIG_fail;
25277 }
25278 {
25279 PyThreadState* __tstate = wxPyBeginAllowThreads();
25280 result = wxDateSpan::Days(arg1);
25281
25282 wxPyEndAllowThreads(__tstate);
25283 if (PyErr_Occurred()) SWIG_fail;
25284 }
25285 {
25286 wxDateSpan * resultptr;
25287 resultptr = new wxDateSpan((wxDateSpan &)(result));
25288 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25289 }
25290 return resultobj;
25291 fail:
25292 return NULL;
25293 }
25294
25295
25296 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25297 PyObject *resultobj;
25298 wxDateSpan result;
25299 char *kwnames[] = {
25300 NULL
25301 };
25302
25303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25304 {
25305 PyThreadState* __tstate = wxPyBeginAllowThreads();
25306 result = wxDateSpan::Day();
25307
25308 wxPyEndAllowThreads(__tstate);
25309 if (PyErr_Occurred()) SWIG_fail;
25310 }
25311 {
25312 wxDateSpan * resultptr;
25313 resultptr = new wxDateSpan((wxDateSpan &)(result));
25314 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25315 }
25316 return resultobj;
25317 fail:
25318 return NULL;
25319 }
25320
25321
25322 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25323 PyObject *resultobj;
25324 int arg1 ;
25325 wxDateSpan result;
25326 PyObject * obj0 = 0 ;
25327 char *kwnames[] = {
25328 (char *) "weeks", NULL
25329 };
25330
25331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25332 {
25333 arg1 = (int)(SWIG_As_int(obj0));
25334 if (SWIG_arg_fail(1)) SWIG_fail;
25335 }
25336 {
25337 PyThreadState* __tstate = wxPyBeginAllowThreads();
25338 result = wxDateSpan::Weeks(arg1);
25339
25340 wxPyEndAllowThreads(__tstate);
25341 if (PyErr_Occurred()) SWIG_fail;
25342 }
25343 {
25344 wxDateSpan * resultptr;
25345 resultptr = new wxDateSpan((wxDateSpan &)(result));
25346 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25347 }
25348 return resultobj;
25349 fail:
25350 return NULL;
25351 }
25352
25353
25354 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25355 PyObject *resultobj;
25356 wxDateSpan result;
25357 char *kwnames[] = {
25358 NULL
25359 };
25360
25361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25362 {
25363 PyThreadState* __tstate = wxPyBeginAllowThreads();
25364 result = wxDateSpan::Week();
25365
25366 wxPyEndAllowThreads(__tstate);
25367 if (PyErr_Occurred()) SWIG_fail;
25368 }
25369 {
25370 wxDateSpan * resultptr;
25371 resultptr = new wxDateSpan((wxDateSpan &)(result));
25372 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25373 }
25374 return resultobj;
25375 fail:
25376 return NULL;
25377 }
25378
25379
25380 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25381 PyObject *resultobj;
25382 int arg1 ;
25383 wxDateSpan result;
25384 PyObject * obj0 = 0 ;
25385 char *kwnames[] = {
25386 (char *) "mon", NULL
25387 };
25388
25389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25390 {
25391 arg1 = (int)(SWIG_As_int(obj0));
25392 if (SWIG_arg_fail(1)) SWIG_fail;
25393 }
25394 {
25395 PyThreadState* __tstate = wxPyBeginAllowThreads();
25396 result = wxDateSpan::Months(arg1);
25397
25398 wxPyEndAllowThreads(__tstate);
25399 if (PyErr_Occurred()) SWIG_fail;
25400 }
25401 {
25402 wxDateSpan * resultptr;
25403 resultptr = new wxDateSpan((wxDateSpan &)(result));
25404 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25405 }
25406 return resultobj;
25407 fail:
25408 return NULL;
25409 }
25410
25411
25412 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25413 PyObject *resultobj;
25414 wxDateSpan result;
25415 char *kwnames[] = {
25416 NULL
25417 };
25418
25419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25420 {
25421 PyThreadState* __tstate = wxPyBeginAllowThreads();
25422 result = wxDateSpan::Month();
25423
25424 wxPyEndAllowThreads(__tstate);
25425 if (PyErr_Occurred()) SWIG_fail;
25426 }
25427 {
25428 wxDateSpan * resultptr;
25429 resultptr = new wxDateSpan((wxDateSpan &)(result));
25430 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25431 }
25432 return resultobj;
25433 fail:
25434 return NULL;
25435 }
25436
25437
25438 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25439 PyObject *resultobj;
25440 int arg1 ;
25441 wxDateSpan result;
25442 PyObject * obj0 = 0 ;
25443 char *kwnames[] = {
25444 (char *) "years", NULL
25445 };
25446
25447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25448 {
25449 arg1 = (int)(SWIG_As_int(obj0));
25450 if (SWIG_arg_fail(1)) SWIG_fail;
25451 }
25452 {
25453 PyThreadState* __tstate = wxPyBeginAllowThreads();
25454 result = wxDateSpan::Years(arg1);
25455
25456 wxPyEndAllowThreads(__tstate);
25457 if (PyErr_Occurred()) SWIG_fail;
25458 }
25459 {
25460 wxDateSpan * resultptr;
25461 resultptr = new wxDateSpan((wxDateSpan &)(result));
25462 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25463 }
25464 return resultobj;
25465 fail:
25466 return NULL;
25467 }
25468
25469
25470 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25471 PyObject *resultobj;
25472 wxDateSpan result;
25473 char *kwnames[] = {
25474 NULL
25475 };
25476
25477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25478 {
25479 PyThreadState* __tstate = wxPyBeginAllowThreads();
25480 result = wxDateSpan::Year();
25481
25482 wxPyEndAllowThreads(__tstate);
25483 if (PyErr_Occurred()) SWIG_fail;
25484 }
25485 {
25486 wxDateSpan * resultptr;
25487 resultptr = new wxDateSpan((wxDateSpan &)(result));
25488 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25489 }
25490 return resultobj;
25491 fail:
25492 return NULL;
25493 }
25494
25495
25496 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25497 PyObject *resultobj;
25498 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25499 int arg2 ;
25500 wxDateSpan *result;
25501 PyObject * obj0 = 0 ;
25502 PyObject * obj1 = 0 ;
25503 char *kwnames[] = {
25504 (char *) "self",(char *) "n", NULL
25505 };
25506
25507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25509 if (SWIG_arg_fail(1)) SWIG_fail;
25510 {
25511 arg2 = (int)(SWIG_As_int(obj1));
25512 if (SWIG_arg_fail(2)) SWIG_fail;
25513 }
25514 {
25515 PyThreadState* __tstate = wxPyBeginAllowThreads();
25516 {
25517 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25518 result = (wxDateSpan *) &_result_ref;
25519 }
25520
25521 wxPyEndAllowThreads(__tstate);
25522 if (PyErr_Occurred()) SWIG_fail;
25523 }
25524 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25525 return resultobj;
25526 fail:
25527 return NULL;
25528 }
25529
25530
25531 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25532 PyObject *resultobj;
25533 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25534 int arg2 ;
25535 wxDateSpan *result;
25536 PyObject * obj0 = 0 ;
25537 PyObject * obj1 = 0 ;
25538 char *kwnames[] = {
25539 (char *) "self",(char *) "n", NULL
25540 };
25541
25542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25544 if (SWIG_arg_fail(1)) SWIG_fail;
25545 {
25546 arg2 = (int)(SWIG_As_int(obj1));
25547 if (SWIG_arg_fail(2)) SWIG_fail;
25548 }
25549 {
25550 PyThreadState* __tstate = wxPyBeginAllowThreads();
25551 {
25552 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25553 result = (wxDateSpan *) &_result_ref;
25554 }
25555
25556 wxPyEndAllowThreads(__tstate);
25557 if (PyErr_Occurred()) SWIG_fail;
25558 }
25559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25560 return resultobj;
25561 fail:
25562 return NULL;
25563 }
25564
25565
25566 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25567 PyObject *resultobj;
25568 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25569 int arg2 ;
25570 wxDateSpan *result;
25571 PyObject * obj0 = 0 ;
25572 PyObject * obj1 = 0 ;
25573 char *kwnames[] = {
25574 (char *) "self",(char *) "n", NULL
25575 };
25576
25577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25579 if (SWIG_arg_fail(1)) SWIG_fail;
25580 {
25581 arg2 = (int)(SWIG_As_int(obj1));
25582 if (SWIG_arg_fail(2)) SWIG_fail;
25583 }
25584 {
25585 PyThreadState* __tstate = wxPyBeginAllowThreads();
25586 {
25587 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25588 result = (wxDateSpan *) &_result_ref;
25589 }
25590
25591 wxPyEndAllowThreads(__tstate);
25592 if (PyErr_Occurred()) SWIG_fail;
25593 }
25594 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25595 return resultobj;
25596 fail:
25597 return NULL;
25598 }
25599
25600
25601 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25602 PyObject *resultobj;
25603 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25604 int arg2 ;
25605 wxDateSpan *result;
25606 PyObject * obj0 = 0 ;
25607 PyObject * obj1 = 0 ;
25608 char *kwnames[] = {
25609 (char *) "self",(char *) "n", NULL
25610 };
25611
25612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25614 if (SWIG_arg_fail(1)) SWIG_fail;
25615 {
25616 arg2 = (int)(SWIG_As_int(obj1));
25617 if (SWIG_arg_fail(2)) SWIG_fail;
25618 }
25619 {
25620 PyThreadState* __tstate = wxPyBeginAllowThreads();
25621 {
25622 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25623 result = (wxDateSpan *) &_result_ref;
25624 }
25625
25626 wxPyEndAllowThreads(__tstate);
25627 if (PyErr_Occurred()) SWIG_fail;
25628 }
25629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25630 return resultobj;
25631 fail:
25632 return NULL;
25633 }
25634
25635
25636 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25637 PyObject *resultobj;
25638 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25639 int result;
25640 PyObject * obj0 = 0 ;
25641 char *kwnames[] = {
25642 (char *) "self", NULL
25643 };
25644
25645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25647 if (SWIG_arg_fail(1)) SWIG_fail;
25648 {
25649 PyThreadState* __tstate = wxPyBeginAllowThreads();
25650 result = (int)((wxDateSpan const *)arg1)->GetYears();
25651
25652 wxPyEndAllowThreads(__tstate);
25653 if (PyErr_Occurred()) SWIG_fail;
25654 }
25655 {
25656 resultobj = SWIG_From_int((int)(result));
25657 }
25658 return resultobj;
25659 fail:
25660 return NULL;
25661 }
25662
25663
25664 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25665 PyObject *resultobj;
25666 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25667 int result;
25668 PyObject * obj0 = 0 ;
25669 char *kwnames[] = {
25670 (char *) "self", NULL
25671 };
25672
25673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25675 if (SWIG_arg_fail(1)) SWIG_fail;
25676 {
25677 PyThreadState* __tstate = wxPyBeginAllowThreads();
25678 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25679
25680 wxPyEndAllowThreads(__tstate);
25681 if (PyErr_Occurred()) SWIG_fail;
25682 }
25683 {
25684 resultobj = SWIG_From_int((int)(result));
25685 }
25686 return resultobj;
25687 fail:
25688 return NULL;
25689 }
25690
25691
25692 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25693 PyObject *resultobj;
25694 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25695 int result;
25696 PyObject * obj0 = 0 ;
25697 char *kwnames[] = {
25698 (char *) "self", NULL
25699 };
25700
25701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25703 if (SWIG_arg_fail(1)) SWIG_fail;
25704 {
25705 PyThreadState* __tstate = wxPyBeginAllowThreads();
25706 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25707
25708 wxPyEndAllowThreads(__tstate);
25709 if (PyErr_Occurred()) SWIG_fail;
25710 }
25711 {
25712 resultobj = SWIG_From_int((int)(result));
25713 }
25714 return resultobj;
25715 fail:
25716 return NULL;
25717 }
25718
25719
25720 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25721 PyObject *resultobj;
25722 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25723 int result;
25724 PyObject * obj0 = 0 ;
25725 char *kwnames[] = {
25726 (char *) "self", NULL
25727 };
25728
25729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25731 if (SWIG_arg_fail(1)) SWIG_fail;
25732 {
25733 PyThreadState* __tstate = wxPyBeginAllowThreads();
25734 result = (int)((wxDateSpan const *)arg1)->GetDays();
25735
25736 wxPyEndAllowThreads(__tstate);
25737 if (PyErr_Occurred()) SWIG_fail;
25738 }
25739 {
25740 resultobj = SWIG_From_int((int)(result));
25741 }
25742 return resultobj;
25743 fail:
25744 return NULL;
25745 }
25746
25747
25748 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25749 PyObject *resultobj;
25750 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25751 int result;
25752 PyObject * obj0 = 0 ;
25753 char *kwnames[] = {
25754 (char *) "self", NULL
25755 };
25756
25757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25759 if (SWIG_arg_fail(1)) SWIG_fail;
25760 {
25761 PyThreadState* __tstate = wxPyBeginAllowThreads();
25762 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25763
25764 wxPyEndAllowThreads(__tstate);
25765 if (PyErr_Occurred()) SWIG_fail;
25766 }
25767 {
25768 resultobj = SWIG_From_int((int)(result));
25769 }
25770 return resultobj;
25771 fail:
25772 return NULL;
25773 }
25774
25775
25776 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25777 PyObject *resultobj;
25778 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25779 wxDateSpan *arg2 = 0 ;
25780 wxDateSpan *result;
25781 PyObject * obj0 = 0 ;
25782 PyObject * obj1 = 0 ;
25783 char *kwnames[] = {
25784 (char *) "self",(char *) "other", NULL
25785 };
25786
25787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25789 if (SWIG_arg_fail(1)) SWIG_fail;
25790 {
25791 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25792 if (SWIG_arg_fail(2)) SWIG_fail;
25793 if (arg2 == NULL) {
25794 SWIG_null_ref("wxDateSpan");
25795 }
25796 if (SWIG_arg_fail(2)) SWIG_fail;
25797 }
25798 {
25799 PyThreadState* __tstate = wxPyBeginAllowThreads();
25800 {
25801 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25802 result = (wxDateSpan *) &_result_ref;
25803 }
25804
25805 wxPyEndAllowThreads(__tstate);
25806 if (PyErr_Occurred()) SWIG_fail;
25807 }
25808 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25809 return resultobj;
25810 fail:
25811 return NULL;
25812 }
25813
25814
25815 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25816 PyObject *resultobj;
25817 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25818 wxDateSpan *arg2 = 0 ;
25819 wxDateSpan *result;
25820 PyObject * obj0 = 0 ;
25821 PyObject * obj1 = 0 ;
25822 char *kwnames[] = {
25823 (char *) "self",(char *) "other", NULL
25824 };
25825
25826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25828 if (SWIG_arg_fail(1)) SWIG_fail;
25829 {
25830 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25831 if (SWIG_arg_fail(2)) SWIG_fail;
25832 if (arg2 == NULL) {
25833 SWIG_null_ref("wxDateSpan");
25834 }
25835 if (SWIG_arg_fail(2)) SWIG_fail;
25836 }
25837 {
25838 PyThreadState* __tstate = wxPyBeginAllowThreads();
25839 {
25840 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25841 result = (wxDateSpan *) &_result_ref;
25842 }
25843
25844 wxPyEndAllowThreads(__tstate);
25845 if (PyErr_Occurred()) SWIG_fail;
25846 }
25847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25848 return resultobj;
25849 fail:
25850 return NULL;
25851 }
25852
25853
25854 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25855 PyObject *resultobj;
25856 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25857 wxDateSpan *result;
25858 PyObject * obj0 = 0 ;
25859 char *kwnames[] = {
25860 (char *) "self", NULL
25861 };
25862
25863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25865 if (SWIG_arg_fail(1)) SWIG_fail;
25866 {
25867 PyThreadState* __tstate = wxPyBeginAllowThreads();
25868 {
25869 wxDateSpan &_result_ref = (arg1)->Neg();
25870 result = (wxDateSpan *) &_result_ref;
25871 }
25872
25873 wxPyEndAllowThreads(__tstate);
25874 if (PyErr_Occurred()) SWIG_fail;
25875 }
25876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25877 return resultobj;
25878 fail:
25879 return NULL;
25880 }
25881
25882
25883 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25884 PyObject *resultobj;
25885 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25886 int arg2 ;
25887 wxDateSpan *result;
25888 PyObject * obj0 = 0 ;
25889 PyObject * obj1 = 0 ;
25890 char *kwnames[] = {
25891 (char *) "self",(char *) "factor", NULL
25892 };
25893
25894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25896 if (SWIG_arg_fail(1)) SWIG_fail;
25897 {
25898 arg2 = (int)(SWIG_As_int(obj1));
25899 if (SWIG_arg_fail(2)) SWIG_fail;
25900 }
25901 {
25902 PyThreadState* __tstate = wxPyBeginAllowThreads();
25903 {
25904 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25905 result = (wxDateSpan *) &_result_ref;
25906 }
25907
25908 wxPyEndAllowThreads(__tstate);
25909 if (PyErr_Occurred()) SWIG_fail;
25910 }
25911 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25912 return resultobj;
25913 fail:
25914 return NULL;
25915 }
25916
25917
25918 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25919 PyObject *resultobj;
25920 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25921 wxDateSpan *arg2 = 0 ;
25922 wxDateSpan *result;
25923 PyObject * obj0 = 0 ;
25924 PyObject * obj1 = 0 ;
25925 char *kwnames[] = {
25926 (char *) "self",(char *) "other", NULL
25927 };
25928
25929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25931 if (SWIG_arg_fail(1)) SWIG_fail;
25932 {
25933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25934 if (SWIG_arg_fail(2)) SWIG_fail;
25935 if (arg2 == NULL) {
25936 SWIG_null_ref("wxDateSpan");
25937 }
25938 if (SWIG_arg_fail(2)) SWIG_fail;
25939 }
25940 {
25941 PyThreadState* __tstate = wxPyBeginAllowThreads();
25942 {
25943 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25944 result = (wxDateSpan *) &_result_ref;
25945 }
25946
25947 wxPyEndAllowThreads(__tstate);
25948 if (PyErr_Occurred()) SWIG_fail;
25949 }
25950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25951 return resultobj;
25952 fail:
25953 return NULL;
25954 }
25955
25956
25957 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25958 PyObject *resultobj;
25959 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25960 wxDateSpan *arg2 = 0 ;
25961 wxDateSpan *result;
25962 PyObject * obj0 = 0 ;
25963 PyObject * obj1 = 0 ;
25964 char *kwnames[] = {
25965 (char *) "self",(char *) "other", NULL
25966 };
25967
25968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25970 if (SWIG_arg_fail(1)) SWIG_fail;
25971 {
25972 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25973 if (SWIG_arg_fail(2)) SWIG_fail;
25974 if (arg2 == NULL) {
25975 SWIG_null_ref("wxDateSpan");
25976 }
25977 if (SWIG_arg_fail(2)) SWIG_fail;
25978 }
25979 {
25980 PyThreadState* __tstate = wxPyBeginAllowThreads();
25981 {
25982 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
25983 result = (wxDateSpan *) &_result_ref;
25984 }
25985
25986 wxPyEndAllowThreads(__tstate);
25987 if (PyErr_Occurred()) SWIG_fail;
25988 }
25989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25990 return resultobj;
25991 fail:
25992 return NULL;
25993 }
25994
25995
25996 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25997 PyObject *resultobj;
25998 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25999 wxDateSpan *result;
26000 PyObject * obj0 = 0 ;
26001 char *kwnames[] = {
26002 (char *) "self", NULL
26003 };
26004
26005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26007 if (SWIG_arg_fail(1)) SWIG_fail;
26008 {
26009 PyThreadState* __tstate = wxPyBeginAllowThreads();
26010 {
26011 wxDateSpan &_result_ref = (arg1)->operator -();
26012 result = (wxDateSpan *) &_result_ref;
26013 }
26014
26015 wxPyEndAllowThreads(__tstate);
26016 if (PyErr_Occurred()) SWIG_fail;
26017 }
26018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26019 return resultobj;
26020 fail:
26021 return NULL;
26022 }
26023
26024
26025 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26026 PyObject *resultobj;
26027 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26028 int arg2 ;
26029 wxDateSpan *result;
26030 PyObject * obj0 = 0 ;
26031 PyObject * obj1 = 0 ;
26032 char *kwnames[] = {
26033 (char *) "self",(char *) "factor", NULL
26034 };
26035
26036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26038 if (SWIG_arg_fail(1)) SWIG_fail;
26039 {
26040 arg2 = (int)(SWIG_As_int(obj1));
26041 if (SWIG_arg_fail(2)) SWIG_fail;
26042 }
26043 {
26044 PyThreadState* __tstate = wxPyBeginAllowThreads();
26045 {
26046 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26047 result = (wxDateSpan *) &_result_ref;
26048 }
26049
26050 wxPyEndAllowThreads(__tstate);
26051 if (PyErr_Occurred()) SWIG_fail;
26052 }
26053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26054 return resultobj;
26055 fail:
26056 return NULL;
26057 }
26058
26059
26060 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26061 PyObject *resultobj;
26062 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26063 wxDateSpan *arg2 = 0 ;
26064 wxDateSpan result;
26065 PyObject * obj0 = 0 ;
26066 PyObject * obj1 = 0 ;
26067 char *kwnames[] = {
26068 (char *) "self",(char *) "other", NULL
26069 };
26070
26071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26073 if (SWIG_arg_fail(1)) SWIG_fail;
26074 {
26075 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26076 if (SWIG_arg_fail(2)) SWIG_fail;
26077 if (arg2 == NULL) {
26078 SWIG_null_ref("wxDateSpan");
26079 }
26080 if (SWIG_arg_fail(2)) SWIG_fail;
26081 }
26082 {
26083 PyThreadState* __tstate = wxPyBeginAllowThreads();
26084 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26085
26086 wxPyEndAllowThreads(__tstate);
26087 if (PyErr_Occurred()) SWIG_fail;
26088 }
26089 {
26090 wxDateSpan * resultptr;
26091 resultptr = new wxDateSpan((wxDateSpan &)(result));
26092 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26093 }
26094 return resultobj;
26095 fail:
26096 return NULL;
26097 }
26098
26099
26100 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26101 PyObject *resultobj;
26102 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26103 wxDateSpan *arg2 = 0 ;
26104 wxDateSpan result;
26105 PyObject * obj0 = 0 ;
26106 PyObject * obj1 = 0 ;
26107 char *kwnames[] = {
26108 (char *) "self",(char *) "other", NULL
26109 };
26110
26111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26113 if (SWIG_arg_fail(1)) SWIG_fail;
26114 {
26115 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26116 if (SWIG_arg_fail(2)) SWIG_fail;
26117 if (arg2 == NULL) {
26118 SWIG_null_ref("wxDateSpan");
26119 }
26120 if (SWIG_arg_fail(2)) SWIG_fail;
26121 }
26122 {
26123 PyThreadState* __tstate = wxPyBeginAllowThreads();
26124 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26125
26126 wxPyEndAllowThreads(__tstate);
26127 if (PyErr_Occurred()) SWIG_fail;
26128 }
26129 {
26130 wxDateSpan * resultptr;
26131 resultptr = new wxDateSpan((wxDateSpan &)(result));
26132 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26133 }
26134 return resultobj;
26135 fail:
26136 return NULL;
26137 }
26138
26139
26140 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26141 PyObject *resultobj;
26142 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26143 int arg2 ;
26144 wxDateSpan result;
26145 PyObject * obj0 = 0 ;
26146 PyObject * obj1 = 0 ;
26147 char *kwnames[] = {
26148 (char *) "self",(char *) "n", NULL
26149 };
26150
26151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26153 if (SWIG_arg_fail(1)) SWIG_fail;
26154 {
26155 arg2 = (int)(SWIG_As_int(obj1));
26156 if (SWIG_arg_fail(2)) SWIG_fail;
26157 }
26158 {
26159 PyThreadState* __tstate = wxPyBeginAllowThreads();
26160 result = wxDateSpan___mul__(arg1,arg2);
26161
26162 wxPyEndAllowThreads(__tstate);
26163 if (PyErr_Occurred()) SWIG_fail;
26164 }
26165 {
26166 wxDateSpan * resultptr;
26167 resultptr = new wxDateSpan((wxDateSpan &)(result));
26168 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26169 }
26170 return resultobj;
26171 fail:
26172 return NULL;
26173 }
26174
26175
26176 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26177 PyObject *resultobj;
26178 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26179 int arg2 ;
26180 wxDateSpan result;
26181 PyObject * obj0 = 0 ;
26182 PyObject * obj1 = 0 ;
26183 char *kwnames[] = {
26184 (char *) "self",(char *) "n", NULL
26185 };
26186
26187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26189 if (SWIG_arg_fail(1)) SWIG_fail;
26190 {
26191 arg2 = (int)(SWIG_As_int(obj1));
26192 if (SWIG_arg_fail(2)) SWIG_fail;
26193 }
26194 {
26195 PyThreadState* __tstate = wxPyBeginAllowThreads();
26196 result = wxDateSpan___rmul__(arg1,arg2);
26197
26198 wxPyEndAllowThreads(__tstate);
26199 if (PyErr_Occurred()) SWIG_fail;
26200 }
26201 {
26202 wxDateSpan * resultptr;
26203 resultptr = new wxDateSpan((wxDateSpan &)(result));
26204 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26205 }
26206 return resultobj;
26207 fail:
26208 return NULL;
26209 }
26210
26211
26212 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26213 PyObject *resultobj;
26214 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26215 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26216 bool result;
26217 PyObject * obj0 = 0 ;
26218 PyObject * obj1 = 0 ;
26219 char *kwnames[] = {
26220 (char *) "self",(char *) "other", NULL
26221 };
26222
26223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26225 if (SWIG_arg_fail(1)) SWIG_fail;
26226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26227 if (SWIG_arg_fail(2)) SWIG_fail;
26228 {
26229 PyThreadState* __tstate = wxPyBeginAllowThreads();
26230 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26231
26232 wxPyEndAllowThreads(__tstate);
26233 if (PyErr_Occurred()) SWIG_fail;
26234 }
26235 {
26236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26237 }
26238 return resultobj;
26239 fail:
26240 return NULL;
26241 }
26242
26243
26244 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26245 PyObject *resultobj;
26246 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26247 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26248 bool result;
26249 PyObject * obj0 = 0 ;
26250 PyObject * obj1 = 0 ;
26251 char *kwnames[] = {
26252 (char *) "self",(char *) "other", NULL
26253 };
26254
26255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26257 if (SWIG_arg_fail(1)) SWIG_fail;
26258 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26259 if (SWIG_arg_fail(2)) SWIG_fail;
26260 {
26261 PyThreadState* __tstate = wxPyBeginAllowThreads();
26262 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26263
26264 wxPyEndAllowThreads(__tstate);
26265 if (PyErr_Occurred()) SWIG_fail;
26266 }
26267 {
26268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26269 }
26270 return resultobj;
26271 fail:
26272 return NULL;
26273 }
26274
26275
26276 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26277 PyObject *obj;
26278 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26279 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26280 Py_INCREF(obj);
26281 return Py_BuildValue((char *)"");
26282 }
26283 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26284 PyObject *resultobj;
26285 long result;
26286 char *kwnames[] = {
26287 NULL
26288 };
26289
26290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26291 {
26292 PyThreadState* __tstate = wxPyBeginAllowThreads();
26293 result = (long)wxGetLocalTime();
26294
26295 wxPyEndAllowThreads(__tstate);
26296 if (PyErr_Occurred()) SWIG_fail;
26297 }
26298 {
26299 resultobj = SWIG_From_long((long)(result));
26300 }
26301 return resultobj;
26302 fail:
26303 return NULL;
26304 }
26305
26306
26307 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26308 PyObject *resultobj;
26309 long result;
26310 char *kwnames[] = {
26311 NULL
26312 };
26313
26314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26315 {
26316 PyThreadState* __tstate = wxPyBeginAllowThreads();
26317 result = (long)wxGetUTCTime();
26318
26319 wxPyEndAllowThreads(__tstate);
26320 if (PyErr_Occurred()) SWIG_fail;
26321 }
26322 {
26323 resultobj = SWIG_From_long((long)(result));
26324 }
26325 return resultobj;
26326 fail:
26327 return NULL;
26328 }
26329
26330
26331 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26332 PyObject *resultobj;
26333 long result;
26334 char *kwnames[] = {
26335 NULL
26336 };
26337
26338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26339 {
26340 PyThreadState* __tstate = wxPyBeginAllowThreads();
26341 result = (long)wxGetCurrentTime();
26342
26343 wxPyEndAllowThreads(__tstate);
26344 if (PyErr_Occurred()) SWIG_fail;
26345 }
26346 {
26347 resultobj = SWIG_From_long((long)(result));
26348 }
26349 return resultobj;
26350 fail:
26351 return NULL;
26352 }
26353
26354
26355 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26356 PyObject *resultobj;
26357 wxLongLong result;
26358 char *kwnames[] = {
26359 NULL
26360 };
26361
26362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26363 {
26364 PyThreadState* __tstate = wxPyBeginAllowThreads();
26365 result = wxGetLocalTimeMillis();
26366
26367 wxPyEndAllowThreads(__tstate);
26368 if (PyErr_Occurred()) SWIG_fail;
26369 }
26370 {
26371 PyObject *hi, *lo, *shifter, *shifted;
26372 hi = PyLong_FromLong( (&result)->GetHi() );
26373 lo = PyLong_FromLong( (&result)->GetLo() );
26374 shifter = PyLong_FromLong(32);
26375 shifted = PyNumber_Lshift(hi, shifter);
26376 resultobj = PyNumber_Or(shifted, lo);
26377 Py_DECREF(hi);
26378 Py_DECREF(lo);
26379 Py_DECREF(shifter);
26380 Py_DECREF(shifted);
26381 }
26382 return resultobj;
26383 fail:
26384 return NULL;
26385 }
26386
26387
26388 static int _wrap_DefaultDateTime_set(PyObject *) {
26389 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26390 return 1;
26391 }
26392
26393
26394 static PyObject *_wrap_DefaultDateTime_get(void) {
26395 PyObject *pyobj;
26396
26397 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26398 return pyobj;
26399 }
26400
26401
26402 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26403 PyObject *resultobj;
26404 wxDataFormatId arg1 ;
26405 wxDataFormat *result;
26406 PyObject * obj0 = 0 ;
26407 char *kwnames[] = {
26408 (char *) "type", NULL
26409 };
26410
26411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26412 {
26413 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26414 if (SWIG_arg_fail(1)) SWIG_fail;
26415 }
26416 {
26417 PyThreadState* __tstate = wxPyBeginAllowThreads();
26418 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26419
26420 wxPyEndAllowThreads(__tstate);
26421 if (PyErr_Occurred()) SWIG_fail;
26422 }
26423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26424 return resultobj;
26425 fail:
26426 return NULL;
26427 }
26428
26429
26430 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26431 PyObject *resultobj;
26432 wxString *arg1 = 0 ;
26433 wxDataFormat *result;
26434 bool temp1 = false ;
26435 PyObject * obj0 = 0 ;
26436 char *kwnames[] = {
26437 (char *) "format", NULL
26438 };
26439
26440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26441 {
26442 arg1 = wxString_in_helper(obj0);
26443 if (arg1 == NULL) SWIG_fail;
26444 temp1 = true;
26445 }
26446 {
26447 PyThreadState* __tstate = wxPyBeginAllowThreads();
26448 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26449
26450 wxPyEndAllowThreads(__tstate);
26451 if (PyErr_Occurred()) SWIG_fail;
26452 }
26453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26454 {
26455 if (temp1)
26456 delete arg1;
26457 }
26458 return resultobj;
26459 fail:
26460 {
26461 if (temp1)
26462 delete arg1;
26463 }
26464 return NULL;
26465 }
26466
26467
26468 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26469 PyObject *resultobj;
26470 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26471 PyObject * obj0 = 0 ;
26472 char *kwnames[] = {
26473 (char *) "self", NULL
26474 };
26475
26476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26478 if (SWIG_arg_fail(1)) SWIG_fail;
26479 {
26480 PyThreadState* __tstate = wxPyBeginAllowThreads();
26481 delete arg1;
26482
26483 wxPyEndAllowThreads(__tstate);
26484 if (PyErr_Occurred()) SWIG_fail;
26485 }
26486 Py_INCREF(Py_None); resultobj = Py_None;
26487 return resultobj;
26488 fail:
26489 return NULL;
26490 }
26491
26492
26493 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26494 PyObject *resultobj;
26495 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26496 wxDataFormatId arg2 ;
26497 bool result;
26498 PyObject * obj0 = 0 ;
26499 PyObject * obj1 = 0 ;
26500
26501 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26503 if (SWIG_arg_fail(1)) SWIG_fail;
26504 {
26505 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26506 if (SWIG_arg_fail(2)) SWIG_fail;
26507 }
26508 {
26509 PyThreadState* __tstate = wxPyBeginAllowThreads();
26510 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26511
26512 wxPyEndAllowThreads(__tstate);
26513 if (PyErr_Occurred()) SWIG_fail;
26514 }
26515 {
26516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26517 }
26518 return resultobj;
26519 fail:
26520 return NULL;
26521 }
26522
26523
26524 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26525 PyObject *resultobj;
26526 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26527 wxDataFormatId arg2 ;
26528 bool result;
26529 PyObject * obj0 = 0 ;
26530 PyObject * obj1 = 0 ;
26531
26532 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26534 if (SWIG_arg_fail(1)) SWIG_fail;
26535 {
26536 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26537 if (SWIG_arg_fail(2)) SWIG_fail;
26538 }
26539 {
26540 PyThreadState* __tstate = wxPyBeginAllowThreads();
26541 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26542
26543 wxPyEndAllowThreads(__tstate);
26544 if (PyErr_Occurred()) SWIG_fail;
26545 }
26546 {
26547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26548 }
26549 return resultobj;
26550 fail:
26551 return NULL;
26552 }
26553
26554
26555 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26556 PyObject *resultobj;
26557 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26558 wxDataFormat *arg2 = 0 ;
26559 bool result;
26560 PyObject * obj0 = 0 ;
26561 PyObject * obj1 = 0 ;
26562
26563 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26565 if (SWIG_arg_fail(1)) SWIG_fail;
26566 {
26567 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26568 if (SWIG_arg_fail(2)) SWIG_fail;
26569 if (arg2 == NULL) {
26570 SWIG_null_ref("wxDataFormat");
26571 }
26572 if (SWIG_arg_fail(2)) SWIG_fail;
26573 }
26574 {
26575 PyThreadState* __tstate = wxPyBeginAllowThreads();
26576 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26577
26578 wxPyEndAllowThreads(__tstate);
26579 if (PyErr_Occurred()) SWIG_fail;
26580 }
26581 {
26582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26583 }
26584 return resultobj;
26585 fail:
26586 return NULL;
26587 }
26588
26589
26590 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26591 int argc;
26592 PyObject *argv[3];
26593 int ii;
26594
26595 argc = PyObject_Length(args);
26596 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26597 argv[ii] = PyTuple_GetItem(args,ii);
26598 }
26599 if (argc == 2) {
26600 int _v;
26601 {
26602 void *ptr;
26603 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26604 _v = 0;
26605 PyErr_Clear();
26606 } else {
26607 _v = 1;
26608 }
26609 }
26610 if (_v) {
26611 {
26612 void *ptr = 0;
26613 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26614 _v = 0;
26615 PyErr_Clear();
26616 } else {
26617 _v = (ptr != 0);
26618 }
26619 }
26620 if (_v) {
26621 return _wrap_DataFormat___eq____SWIG_1(self,args);
26622 }
26623 }
26624 }
26625 if (argc == 2) {
26626 int _v;
26627 {
26628 void *ptr;
26629 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26630 _v = 0;
26631 PyErr_Clear();
26632 } else {
26633 _v = 1;
26634 }
26635 }
26636 if (_v) {
26637 _v = SWIG_Check_int(argv[1]);
26638 if (_v) {
26639 return _wrap_DataFormat___eq____SWIG_0(self,args);
26640 }
26641 }
26642 }
26643
26644 Py_INCREF(Py_NotImplemented);
26645 return Py_NotImplemented;
26646 }
26647
26648
26649 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26650 PyObject *resultobj;
26651 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26652 wxDataFormat *arg2 = 0 ;
26653 bool result;
26654 PyObject * obj0 = 0 ;
26655 PyObject * obj1 = 0 ;
26656
26657 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26659 if (SWIG_arg_fail(1)) SWIG_fail;
26660 {
26661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26662 if (SWIG_arg_fail(2)) SWIG_fail;
26663 if (arg2 == NULL) {
26664 SWIG_null_ref("wxDataFormat");
26665 }
26666 if (SWIG_arg_fail(2)) SWIG_fail;
26667 }
26668 {
26669 PyThreadState* __tstate = wxPyBeginAllowThreads();
26670 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26671
26672 wxPyEndAllowThreads(__tstate);
26673 if (PyErr_Occurred()) SWIG_fail;
26674 }
26675 {
26676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26677 }
26678 return resultobj;
26679 fail:
26680 return NULL;
26681 }
26682
26683
26684 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26685 int argc;
26686 PyObject *argv[3];
26687 int ii;
26688
26689 argc = PyObject_Length(args);
26690 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26691 argv[ii] = PyTuple_GetItem(args,ii);
26692 }
26693 if (argc == 2) {
26694 int _v;
26695 {
26696 void *ptr;
26697 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26698 _v = 0;
26699 PyErr_Clear();
26700 } else {
26701 _v = 1;
26702 }
26703 }
26704 if (_v) {
26705 {
26706 void *ptr = 0;
26707 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26708 _v = 0;
26709 PyErr_Clear();
26710 } else {
26711 _v = (ptr != 0);
26712 }
26713 }
26714 if (_v) {
26715 return _wrap_DataFormat___ne____SWIG_1(self,args);
26716 }
26717 }
26718 }
26719 if (argc == 2) {
26720 int _v;
26721 {
26722 void *ptr;
26723 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26724 _v = 0;
26725 PyErr_Clear();
26726 } else {
26727 _v = 1;
26728 }
26729 }
26730 if (_v) {
26731 _v = SWIG_Check_int(argv[1]);
26732 if (_v) {
26733 return _wrap_DataFormat___ne____SWIG_0(self,args);
26734 }
26735 }
26736 }
26737
26738 Py_INCREF(Py_NotImplemented);
26739 return Py_NotImplemented;
26740 }
26741
26742
26743 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26744 PyObject *resultobj;
26745 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26746 wxDataFormatId arg2 ;
26747 PyObject * obj0 = 0 ;
26748 PyObject * obj1 = 0 ;
26749 char *kwnames[] = {
26750 (char *) "self",(char *) "format", NULL
26751 };
26752
26753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26755 if (SWIG_arg_fail(1)) SWIG_fail;
26756 {
26757 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26758 if (SWIG_arg_fail(2)) SWIG_fail;
26759 }
26760 {
26761 PyThreadState* __tstate = wxPyBeginAllowThreads();
26762 (arg1)->SetType((wxDataFormatId )arg2);
26763
26764 wxPyEndAllowThreads(__tstate);
26765 if (PyErr_Occurred()) SWIG_fail;
26766 }
26767 Py_INCREF(Py_None); resultobj = Py_None;
26768 return resultobj;
26769 fail:
26770 return NULL;
26771 }
26772
26773
26774 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26775 PyObject *resultobj;
26776 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26777 wxDataFormatId result;
26778 PyObject * obj0 = 0 ;
26779 char *kwnames[] = {
26780 (char *) "self", NULL
26781 };
26782
26783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26785 if (SWIG_arg_fail(1)) SWIG_fail;
26786 {
26787 PyThreadState* __tstate = wxPyBeginAllowThreads();
26788 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26789
26790 wxPyEndAllowThreads(__tstate);
26791 if (PyErr_Occurred()) SWIG_fail;
26792 }
26793 resultobj = SWIG_From_int((result));
26794 return resultobj;
26795 fail:
26796 return NULL;
26797 }
26798
26799
26800 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26801 PyObject *resultobj;
26802 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26803 wxString result;
26804 PyObject * obj0 = 0 ;
26805 char *kwnames[] = {
26806 (char *) "self", NULL
26807 };
26808
26809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26811 if (SWIG_arg_fail(1)) SWIG_fail;
26812 {
26813 PyThreadState* __tstate = wxPyBeginAllowThreads();
26814 result = ((wxDataFormat const *)arg1)->GetId();
26815
26816 wxPyEndAllowThreads(__tstate);
26817 if (PyErr_Occurred()) SWIG_fail;
26818 }
26819 {
26820 #if wxUSE_UNICODE
26821 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26822 #else
26823 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26824 #endif
26825 }
26826 return resultobj;
26827 fail:
26828 return NULL;
26829 }
26830
26831
26832 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26833 PyObject *resultobj;
26834 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26835 wxString *arg2 = 0 ;
26836 bool temp2 = false ;
26837 PyObject * obj0 = 0 ;
26838 PyObject * obj1 = 0 ;
26839 char *kwnames[] = {
26840 (char *) "self",(char *) "format", NULL
26841 };
26842
26843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26845 if (SWIG_arg_fail(1)) SWIG_fail;
26846 {
26847 arg2 = wxString_in_helper(obj1);
26848 if (arg2 == NULL) SWIG_fail;
26849 temp2 = true;
26850 }
26851 {
26852 PyThreadState* __tstate = wxPyBeginAllowThreads();
26853 (arg1)->SetId((wxString const &)*arg2);
26854
26855 wxPyEndAllowThreads(__tstate);
26856 if (PyErr_Occurred()) SWIG_fail;
26857 }
26858 Py_INCREF(Py_None); resultobj = Py_None;
26859 {
26860 if (temp2)
26861 delete arg2;
26862 }
26863 return resultobj;
26864 fail:
26865 {
26866 if (temp2)
26867 delete arg2;
26868 }
26869 return NULL;
26870 }
26871
26872
26873 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26874 PyObject *obj;
26875 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26876 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26877 Py_INCREF(obj);
26878 return Py_BuildValue((char *)"");
26879 }
26880 static int _wrap_FormatInvalid_set(PyObject *) {
26881 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26882 return 1;
26883 }
26884
26885
26886 static PyObject *_wrap_FormatInvalid_get(void) {
26887 PyObject *pyobj;
26888
26889 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26890 return pyobj;
26891 }
26892
26893
26894 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26895 PyObject *resultobj;
26896 wxDataObject *arg1 = (wxDataObject *) 0 ;
26897 PyObject * obj0 = 0 ;
26898 char *kwnames[] = {
26899 (char *) "self", NULL
26900 };
26901
26902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26904 if (SWIG_arg_fail(1)) SWIG_fail;
26905 {
26906 PyThreadState* __tstate = wxPyBeginAllowThreads();
26907 delete arg1;
26908
26909 wxPyEndAllowThreads(__tstate);
26910 if (PyErr_Occurred()) SWIG_fail;
26911 }
26912 Py_INCREF(Py_None); resultobj = Py_None;
26913 return resultobj;
26914 fail:
26915 return NULL;
26916 }
26917
26918
26919 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26920 PyObject *resultobj;
26921 wxDataObject *arg1 = (wxDataObject *) 0 ;
26922 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26923 SwigValueWrapper<wxDataFormat > result;
26924 PyObject * obj0 = 0 ;
26925 PyObject * obj1 = 0 ;
26926 char *kwnames[] = {
26927 (char *) "self",(char *) "dir", NULL
26928 };
26929
26930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26932 if (SWIG_arg_fail(1)) SWIG_fail;
26933 if (obj1) {
26934 {
26935 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26936 if (SWIG_arg_fail(2)) SWIG_fail;
26937 }
26938 }
26939 {
26940 PyThreadState* __tstate = wxPyBeginAllowThreads();
26941 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26942
26943 wxPyEndAllowThreads(__tstate);
26944 if (PyErr_Occurred()) SWIG_fail;
26945 }
26946 {
26947 wxDataFormat * resultptr;
26948 resultptr = new wxDataFormat((wxDataFormat &)(result));
26949 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26950 }
26951 return resultobj;
26952 fail:
26953 return NULL;
26954 }
26955
26956
26957 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26958 PyObject *resultobj;
26959 wxDataObject *arg1 = (wxDataObject *) 0 ;
26960 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26961 size_t result;
26962 PyObject * obj0 = 0 ;
26963 PyObject * obj1 = 0 ;
26964 char *kwnames[] = {
26965 (char *) "self",(char *) "dir", NULL
26966 };
26967
26968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26970 if (SWIG_arg_fail(1)) SWIG_fail;
26971 if (obj1) {
26972 {
26973 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26974 if (SWIG_arg_fail(2)) SWIG_fail;
26975 }
26976 }
26977 {
26978 PyThreadState* __tstate = wxPyBeginAllowThreads();
26979 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
26980
26981 wxPyEndAllowThreads(__tstate);
26982 if (PyErr_Occurred()) SWIG_fail;
26983 }
26984 {
26985 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26986 }
26987 return resultobj;
26988 fail:
26989 return NULL;
26990 }
26991
26992
26993 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
26994 PyObject *resultobj;
26995 wxDataObject *arg1 = (wxDataObject *) 0 ;
26996 wxDataFormat *arg2 = 0 ;
26997 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
26998 bool result;
26999 PyObject * obj0 = 0 ;
27000 PyObject * obj1 = 0 ;
27001 PyObject * obj2 = 0 ;
27002 char *kwnames[] = {
27003 (char *) "self",(char *) "format",(char *) "dir", NULL
27004 };
27005
27006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27008 if (SWIG_arg_fail(1)) SWIG_fail;
27009 {
27010 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27011 if (SWIG_arg_fail(2)) SWIG_fail;
27012 if (arg2 == NULL) {
27013 SWIG_null_ref("wxDataFormat");
27014 }
27015 if (SWIG_arg_fail(2)) SWIG_fail;
27016 }
27017 if (obj2) {
27018 {
27019 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27020 if (SWIG_arg_fail(3)) SWIG_fail;
27021 }
27022 }
27023 {
27024 PyThreadState* __tstate = wxPyBeginAllowThreads();
27025 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27026
27027 wxPyEndAllowThreads(__tstate);
27028 if (PyErr_Occurred()) SWIG_fail;
27029 }
27030 {
27031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27032 }
27033 return resultobj;
27034 fail:
27035 return NULL;
27036 }
27037
27038
27039 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27040 PyObject *resultobj;
27041 wxDataObject *arg1 = (wxDataObject *) 0 ;
27042 wxDataFormat *arg2 = 0 ;
27043 size_t result;
27044 PyObject * obj0 = 0 ;
27045 PyObject * obj1 = 0 ;
27046 char *kwnames[] = {
27047 (char *) "self",(char *) "format", NULL
27048 };
27049
27050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27052 if (SWIG_arg_fail(1)) SWIG_fail;
27053 {
27054 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27055 if (SWIG_arg_fail(2)) SWIG_fail;
27056 if (arg2 == NULL) {
27057 SWIG_null_ref("wxDataFormat");
27058 }
27059 if (SWIG_arg_fail(2)) SWIG_fail;
27060 }
27061 {
27062 PyThreadState* __tstate = wxPyBeginAllowThreads();
27063 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27064
27065 wxPyEndAllowThreads(__tstate);
27066 if (PyErr_Occurred()) SWIG_fail;
27067 }
27068 {
27069 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27070 }
27071 return resultobj;
27072 fail:
27073 return NULL;
27074 }
27075
27076
27077 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27078 PyObject *resultobj;
27079 wxDataObject *arg1 = (wxDataObject *) 0 ;
27080 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27081 PyObject *result;
27082 PyObject * obj0 = 0 ;
27083 PyObject * obj1 = 0 ;
27084 char *kwnames[] = {
27085 (char *) "self",(char *) "dir", NULL
27086 };
27087
27088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27090 if (SWIG_arg_fail(1)) SWIG_fail;
27091 if (obj1) {
27092 {
27093 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27094 if (SWIG_arg_fail(2)) SWIG_fail;
27095 }
27096 }
27097 {
27098 PyThreadState* __tstate = wxPyBeginAllowThreads();
27099 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27100
27101 wxPyEndAllowThreads(__tstate);
27102 if (PyErr_Occurred()) SWIG_fail;
27103 }
27104 resultobj = result;
27105 return resultobj;
27106 fail:
27107 return NULL;
27108 }
27109
27110
27111 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27112 PyObject *resultobj;
27113 wxDataObject *arg1 = (wxDataObject *) 0 ;
27114 wxDataFormat *arg2 = 0 ;
27115 PyObject *result;
27116 PyObject * obj0 = 0 ;
27117 PyObject * obj1 = 0 ;
27118 char *kwnames[] = {
27119 (char *) "self",(char *) "format", NULL
27120 };
27121
27122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27124 if (SWIG_arg_fail(1)) SWIG_fail;
27125 {
27126 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27127 if (SWIG_arg_fail(2)) SWIG_fail;
27128 if (arg2 == NULL) {
27129 SWIG_null_ref("wxDataFormat");
27130 }
27131 if (SWIG_arg_fail(2)) SWIG_fail;
27132 }
27133 {
27134 PyThreadState* __tstate = wxPyBeginAllowThreads();
27135 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27136
27137 wxPyEndAllowThreads(__tstate);
27138 if (PyErr_Occurred()) SWIG_fail;
27139 }
27140 resultobj = result;
27141 return resultobj;
27142 fail:
27143 return NULL;
27144 }
27145
27146
27147 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27148 PyObject *resultobj;
27149 wxDataObject *arg1 = (wxDataObject *) 0 ;
27150 wxDataFormat *arg2 = 0 ;
27151 PyObject *arg3 = (PyObject *) 0 ;
27152 bool result;
27153 PyObject * obj0 = 0 ;
27154 PyObject * obj1 = 0 ;
27155 PyObject * obj2 = 0 ;
27156 char *kwnames[] = {
27157 (char *) "self",(char *) "format",(char *) "data", NULL
27158 };
27159
27160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27162 if (SWIG_arg_fail(1)) SWIG_fail;
27163 {
27164 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27165 if (SWIG_arg_fail(2)) SWIG_fail;
27166 if (arg2 == NULL) {
27167 SWIG_null_ref("wxDataFormat");
27168 }
27169 if (SWIG_arg_fail(2)) SWIG_fail;
27170 }
27171 arg3 = obj2;
27172 {
27173 PyThreadState* __tstate = wxPyBeginAllowThreads();
27174 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27175
27176 wxPyEndAllowThreads(__tstate);
27177 if (PyErr_Occurred()) SWIG_fail;
27178 }
27179 {
27180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27181 }
27182 return resultobj;
27183 fail:
27184 return NULL;
27185 }
27186
27187
27188 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27189 PyObject *obj;
27190 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27191 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27192 Py_INCREF(obj);
27193 return Py_BuildValue((char *)"");
27194 }
27195 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27196 PyObject *resultobj;
27197 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27198 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27199 wxDataObjectSimple *result;
27200 PyObject * obj0 = 0 ;
27201 char *kwnames[] = {
27202 (char *) "format", NULL
27203 };
27204
27205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27206 if (obj0) {
27207 {
27208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27209 if (SWIG_arg_fail(1)) SWIG_fail;
27210 if (arg1 == NULL) {
27211 SWIG_null_ref("wxDataFormat");
27212 }
27213 if (SWIG_arg_fail(1)) SWIG_fail;
27214 }
27215 }
27216 {
27217 PyThreadState* __tstate = wxPyBeginAllowThreads();
27218 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27219
27220 wxPyEndAllowThreads(__tstate);
27221 if (PyErr_Occurred()) SWIG_fail;
27222 }
27223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27224 return resultobj;
27225 fail:
27226 return NULL;
27227 }
27228
27229
27230 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27231 PyObject *resultobj;
27232 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27233 wxDataFormat *result;
27234 PyObject * obj0 = 0 ;
27235 char *kwnames[] = {
27236 (char *) "self", NULL
27237 };
27238
27239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27241 if (SWIG_arg_fail(1)) SWIG_fail;
27242 {
27243 PyThreadState* __tstate = wxPyBeginAllowThreads();
27244 {
27245 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27246 result = (wxDataFormat *) &_result_ref;
27247 }
27248
27249 wxPyEndAllowThreads(__tstate);
27250 if (PyErr_Occurred()) SWIG_fail;
27251 }
27252 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27253 return resultobj;
27254 fail:
27255 return NULL;
27256 }
27257
27258
27259 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27260 PyObject *resultobj;
27261 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27262 wxDataFormat *arg2 = 0 ;
27263 PyObject * obj0 = 0 ;
27264 PyObject * obj1 = 0 ;
27265 char *kwnames[] = {
27266 (char *) "self",(char *) "format", NULL
27267 };
27268
27269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27271 if (SWIG_arg_fail(1)) SWIG_fail;
27272 {
27273 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27274 if (SWIG_arg_fail(2)) SWIG_fail;
27275 if (arg2 == NULL) {
27276 SWIG_null_ref("wxDataFormat");
27277 }
27278 if (SWIG_arg_fail(2)) SWIG_fail;
27279 }
27280 {
27281 PyThreadState* __tstate = wxPyBeginAllowThreads();
27282 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27283
27284 wxPyEndAllowThreads(__tstate);
27285 if (PyErr_Occurred()) SWIG_fail;
27286 }
27287 Py_INCREF(Py_None); resultobj = Py_None;
27288 return resultobj;
27289 fail:
27290 return NULL;
27291 }
27292
27293
27294 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27295 PyObject *resultobj;
27296 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27297 size_t result;
27298 PyObject * obj0 = 0 ;
27299 char *kwnames[] = {
27300 (char *) "self", NULL
27301 };
27302
27303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27305 if (SWIG_arg_fail(1)) SWIG_fail;
27306 {
27307 PyThreadState* __tstate = wxPyBeginAllowThreads();
27308 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27309
27310 wxPyEndAllowThreads(__tstate);
27311 if (PyErr_Occurred()) SWIG_fail;
27312 }
27313 {
27314 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27315 }
27316 return resultobj;
27317 fail:
27318 return NULL;
27319 }
27320
27321
27322 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27323 PyObject *resultobj;
27324 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27325 PyObject *result;
27326 PyObject * obj0 = 0 ;
27327 char *kwnames[] = {
27328 (char *) "self", NULL
27329 };
27330
27331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27333 if (SWIG_arg_fail(1)) SWIG_fail;
27334 {
27335 PyThreadState* __tstate = wxPyBeginAllowThreads();
27336 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27337
27338 wxPyEndAllowThreads(__tstate);
27339 if (PyErr_Occurred()) SWIG_fail;
27340 }
27341 resultobj = result;
27342 return resultobj;
27343 fail:
27344 return NULL;
27345 }
27346
27347
27348 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27349 PyObject *resultobj;
27350 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27351 PyObject *arg2 = (PyObject *) 0 ;
27352 bool result;
27353 PyObject * obj0 = 0 ;
27354 PyObject * obj1 = 0 ;
27355 char *kwnames[] = {
27356 (char *) "self",(char *) "data", NULL
27357 };
27358
27359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27361 if (SWIG_arg_fail(1)) SWIG_fail;
27362 arg2 = obj1;
27363 {
27364 PyThreadState* __tstate = wxPyBeginAllowThreads();
27365 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27366
27367 wxPyEndAllowThreads(__tstate);
27368 if (PyErr_Occurred()) SWIG_fail;
27369 }
27370 {
27371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27372 }
27373 return resultobj;
27374 fail:
27375 return NULL;
27376 }
27377
27378
27379 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27380 PyObject *obj;
27381 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27382 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27383 Py_INCREF(obj);
27384 return Py_BuildValue((char *)"");
27385 }
27386 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27387 PyObject *resultobj;
27388 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27389 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27390 wxPyDataObjectSimple *result;
27391 PyObject * obj0 = 0 ;
27392 char *kwnames[] = {
27393 (char *) "format", NULL
27394 };
27395
27396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27397 if (obj0) {
27398 {
27399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27400 if (SWIG_arg_fail(1)) SWIG_fail;
27401 if (arg1 == NULL) {
27402 SWIG_null_ref("wxDataFormat");
27403 }
27404 if (SWIG_arg_fail(1)) SWIG_fail;
27405 }
27406 }
27407 {
27408 PyThreadState* __tstate = wxPyBeginAllowThreads();
27409 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27410
27411 wxPyEndAllowThreads(__tstate);
27412 if (PyErr_Occurred()) SWIG_fail;
27413 }
27414 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27415 return resultobj;
27416 fail:
27417 return NULL;
27418 }
27419
27420
27421 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27422 PyObject *resultobj;
27423 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27424 PyObject *arg2 = (PyObject *) 0 ;
27425 PyObject *arg3 = (PyObject *) 0 ;
27426 PyObject * obj0 = 0 ;
27427 PyObject * obj1 = 0 ;
27428 PyObject * obj2 = 0 ;
27429 char *kwnames[] = {
27430 (char *) "self",(char *) "self",(char *) "_class", NULL
27431 };
27432
27433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27435 if (SWIG_arg_fail(1)) SWIG_fail;
27436 arg2 = obj1;
27437 arg3 = obj2;
27438 {
27439 PyThreadState* __tstate = wxPyBeginAllowThreads();
27440 (arg1)->_setCallbackInfo(arg2,arg3);
27441
27442 wxPyEndAllowThreads(__tstate);
27443 if (PyErr_Occurred()) SWIG_fail;
27444 }
27445 Py_INCREF(Py_None); resultobj = Py_None;
27446 return resultobj;
27447 fail:
27448 return NULL;
27449 }
27450
27451
27452 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27453 PyObject *obj;
27454 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27455 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27456 Py_INCREF(obj);
27457 return Py_BuildValue((char *)"");
27458 }
27459 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27460 PyObject *resultobj;
27461 wxDataObjectComposite *result;
27462 char *kwnames[] = {
27463 NULL
27464 };
27465
27466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27467 {
27468 PyThreadState* __tstate = wxPyBeginAllowThreads();
27469 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27470
27471 wxPyEndAllowThreads(__tstate);
27472 if (PyErr_Occurred()) SWIG_fail;
27473 }
27474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27475 return resultobj;
27476 fail:
27477 return NULL;
27478 }
27479
27480
27481 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27482 PyObject *resultobj;
27483 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27484 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27485 bool arg3 = (bool) false ;
27486 PyObject * obj0 = 0 ;
27487 PyObject * obj1 = 0 ;
27488 PyObject * obj2 = 0 ;
27489 char *kwnames[] = {
27490 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27491 };
27492
27493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27495 if (SWIG_arg_fail(1)) SWIG_fail;
27496 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27497 if (SWIG_arg_fail(2)) SWIG_fail;
27498 if (obj2) {
27499 {
27500 arg3 = (bool)(SWIG_As_bool(obj2));
27501 if (SWIG_arg_fail(3)) SWIG_fail;
27502 }
27503 }
27504 {
27505 PyThreadState* __tstate = wxPyBeginAllowThreads();
27506 (arg1)->Add(arg2,arg3);
27507
27508 wxPyEndAllowThreads(__tstate);
27509 if (PyErr_Occurred()) SWIG_fail;
27510 }
27511 Py_INCREF(Py_None); resultobj = Py_None;
27512 return resultobj;
27513 fail:
27514 return NULL;
27515 }
27516
27517
27518 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27519 PyObject *obj;
27520 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27521 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27522 Py_INCREF(obj);
27523 return Py_BuildValue((char *)"");
27524 }
27525 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27526 PyObject *resultobj;
27527 wxString const &arg1_defvalue = wxPyEmptyString ;
27528 wxString *arg1 = (wxString *) &arg1_defvalue ;
27529 wxTextDataObject *result;
27530 bool temp1 = false ;
27531 PyObject * obj0 = 0 ;
27532 char *kwnames[] = {
27533 (char *) "text", NULL
27534 };
27535
27536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27537 if (obj0) {
27538 {
27539 arg1 = wxString_in_helper(obj0);
27540 if (arg1 == NULL) SWIG_fail;
27541 temp1 = true;
27542 }
27543 }
27544 {
27545 PyThreadState* __tstate = wxPyBeginAllowThreads();
27546 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27547
27548 wxPyEndAllowThreads(__tstate);
27549 if (PyErr_Occurred()) SWIG_fail;
27550 }
27551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27552 {
27553 if (temp1)
27554 delete arg1;
27555 }
27556 return resultobj;
27557 fail:
27558 {
27559 if (temp1)
27560 delete arg1;
27561 }
27562 return NULL;
27563 }
27564
27565
27566 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27567 PyObject *resultobj;
27568 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27569 size_t result;
27570 PyObject * obj0 = 0 ;
27571 char *kwnames[] = {
27572 (char *) "self", NULL
27573 };
27574
27575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27577 if (SWIG_arg_fail(1)) SWIG_fail;
27578 {
27579 PyThreadState* __tstate = wxPyBeginAllowThreads();
27580 result = (size_t)(arg1)->GetTextLength();
27581
27582 wxPyEndAllowThreads(__tstate);
27583 if (PyErr_Occurred()) SWIG_fail;
27584 }
27585 {
27586 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27587 }
27588 return resultobj;
27589 fail:
27590 return NULL;
27591 }
27592
27593
27594 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27595 PyObject *resultobj;
27596 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27597 wxString result;
27598 PyObject * obj0 = 0 ;
27599 char *kwnames[] = {
27600 (char *) "self", NULL
27601 };
27602
27603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27605 if (SWIG_arg_fail(1)) SWIG_fail;
27606 {
27607 PyThreadState* __tstate = wxPyBeginAllowThreads();
27608 result = (arg1)->GetText();
27609
27610 wxPyEndAllowThreads(__tstate);
27611 if (PyErr_Occurred()) SWIG_fail;
27612 }
27613 {
27614 #if wxUSE_UNICODE
27615 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27616 #else
27617 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27618 #endif
27619 }
27620 return resultobj;
27621 fail:
27622 return NULL;
27623 }
27624
27625
27626 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27627 PyObject *resultobj;
27628 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27629 wxString *arg2 = 0 ;
27630 bool temp2 = false ;
27631 PyObject * obj0 = 0 ;
27632 PyObject * obj1 = 0 ;
27633 char *kwnames[] = {
27634 (char *) "self",(char *) "text", NULL
27635 };
27636
27637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27639 if (SWIG_arg_fail(1)) SWIG_fail;
27640 {
27641 arg2 = wxString_in_helper(obj1);
27642 if (arg2 == NULL) SWIG_fail;
27643 temp2 = true;
27644 }
27645 {
27646 PyThreadState* __tstate = wxPyBeginAllowThreads();
27647 (arg1)->SetText((wxString const &)*arg2);
27648
27649 wxPyEndAllowThreads(__tstate);
27650 if (PyErr_Occurred()) SWIG_fail;
27651 }
27652 Py_INCREF(Py_None); resultobj = Py_None;
27653 {
27654 if (temp2)
27655 delete arg2;
27656 }
27657 return resultobj;
27658 fail:
27659 {
27660 if (temp2)
27661 delete arg2;
27662 }
27663 return NULL;
27664 }
27665
27666
27667 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27668 PyObject *obj;
27669 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27670 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27671 Py_INCREF(obj);
27672 return Py_BuildValue((char *)"");
27673 }
27674 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27675 PyObject *resultobj;
27676 wxString const &arg1_defvalue = wxPyEmptyString ;
27677 wxString *arg1 = (wxString *) &arg1_defvalue ;
27678 wxPyTextDataObject *result;
27679 bool temp1 = false ;
27680 PyObject * obj0 = 0 ;
27681 char *kwnames[] = {
27682 (char *) "text", NULL
27683 };
27684
27685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27686 if (obj0) {
27687 {
27688 arg1 = wxString_in_helper(obj0);
27689 if (arg1 == NULL) SWIG_fail;
27690 temp1 = true;
27691 }
27692 }
27693 {
27694 PyThreadState* __tstate = wxPyBeginAllowThreads();
27695 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27696
27697 wxPyEndAllowThreads(__tstate);
27698 if (PyErr_Occurred()) SWIG_fail;
27699 }
27700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27701 {
27702 if (temp1)
27703 delete arg1;
27704 }
27705 return resultobj;
27706 fail:
27707 {
27708 if (temp1)
27709 delete arg1;
27710 }
27711 return NULL;
27712 }
27713
27714
27715 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27716 PyObject *resultobj;
27717 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27718 PyObject *arg2 = (PyObject *) 0 ;
27719 PyObject *arg3 = (PyObject *) 0 ;
27720 PyObject * obj0 = 0 ;
27721 PyObject * obj1 = 0 ;
27722 PyObject * obj2 = 0 ;
27723 char *kwnames[] = {
27724 (char *) "self",(char *) "self",(char *) "_class", NULL
27725 };
27726
27727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27729 if (SWIG_arg_fail(1)) SWIG_fail;
27730 arg2 = obj1;
27731 arg3 = obj2;
27732 {
27733 PyThreadState* __tstate = wxPyBeginAllowThreads();
27734 (arg1)->_setCallbackInfo(arg2,arg3);
27735
27736 wxPyEndAllowThreads(__tstate);
27737 if (PyErr_Occurred()) SWIG_fail;
27738 }
27739 Py_INCREF(Py_None); resultobj = Py_None;
27740 return resultobj;
27741 fail:
27742 return NULL;
27743 }
27744
27745
27746 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27747 PyObject *obj;
27748 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27749 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27750 Py_INCREF(obj);
27751 return Py_BuildValue((char *)"");
27752 }
27753 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27754 PyObject *resultobj;
27755 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27756 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27757 wxBitmapDataObject *result;
27758 PyObject * obj0 = 0 ;
27759 char *kwnames[] = {
27760 (char *) "bitmap", NULL
27761 };
27762
27763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27764 if (obj0) {
27765 {
27766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27767 if (SWIG_arg_fail(1)) SWIG_fail;
27768 if (arg1 == NULL) {
27769 SWIG_null_ref("wxBitmap");
27770 }
27771 if (SWIG_arg_fail(1)) SWIG_fail;
27772 }
27773 }
27774 {
27775 PyThreadState* __tstate = wxPyBeginAllowThreads();
27776 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27777
27778 wxPyEndAllowThreads(__tstate);
27779 if (PyErr_Occurred()) SWIG_fail;
27780 }
27781 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27782 return resultobj;
27783 fail:
27784 return NULL;
27785 }
27786
27787
27788 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27789 PyObject *resultobj;
27790 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27791 wxBitmap result;
27792 PyObject * obj0 = 0 ;
27793 char *kwnames[] = {
27794 (char *) "self", NULL
27795 };
27796
27797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27799 if (SWIG_arg_fail(1)) SWIG_fail;
27800 {
27801 PyThreadState* __tstate = wxPyBeginAllowThreads();
27802 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27803
27804 wxPyEndAllowThreads(__tstate);
27805 if (PyErr_Occurred()) SWIG_fail;
27806 }
27807 {
27808 wxBitmap * resultptr;
27809 resultptr = new wxBitmap((wxBitmap &)(result));
27810 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27811 }
27812 return resultobj;
27813 fail:
27814 return NULL;
27815 }
27816
27817
27818 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27819 PyObject *resultobj;
27820 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27821 wxBitmap *arg2 = 0 ;
27822 PyObject * obj0 = 0 ;
27823 PyObject * obj1 = 0 ;
27824 char *kwnames[] = {
27825 (char *) "self",(char *) "bitmap", NULL
27826 };
27827
27828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27830 if (SWIG_arg_fail(1)) SWIG_fail;
27831 {
27832 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27833 if (SWIG_arg_fail(2)) SWIG_fail;
27834 if (arg2 == NULL) {
27835 SWIG_null_ref("wxBitmap");
27836 }
27837 if (SWIG_arg_fail(2)) SWIG_fail;
27838 }
27839 {
27840 PyThreadState* __tstate = wxPyBeginAllowThreads();
27841 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27842
27843 wxPyEndAllowThreads(__tstate);
27844 if (PyErr_Occurred()) SWIG_fail;
27845 }
27846 Py_INCREF(Py_None); resultobj = Py_None;
27847 return resultobj;
27848 fail:
27849 return NULL;
27850 }
27851
27852
27853 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27854 PyObject *obj;
27855 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27856 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27857 Py_INCREF(obj);
27858 return Py_BuildValue((char *)"");
27859 }
27860 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27861 PyObject *resultobj;
27862 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27863 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27864 wxPyBitmapDataObject *result;
27865 PyObject * obj0 = 0 ;
27866 char *kwnames[] = {
27867 (char *) "bitmap", NULL
27868 };
27869
27870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27871 if (obj0) {
27872 {
27873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27874 if (SWIG_arg_fail(1)) SWIG_fail;
27875 if (arg1 == NULL) {
27876 SWIG_null_ref("wxBitmap");
27877 }
27878 if (SWIG_arg_fail(1)) SWIG_fail;
27879 }
27880 }
27881 {
27882 PyThreadState* __tstate = wxPyBeginAllowThreads();
27883 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27884
27885 wxPyEndAllowThreads(__tstate);
27886 if (PyErr_Occurred()) SWIG_fail;
27887 }
27888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27889 return resultobj;
27890 fail:
27891 return NULL;
27892 }
27893
27894
27895 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27896 PyObject *resultobj;
27897 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27898 PyObject *arg2 = (PyObject *) 0 ;
27899 PyObject *arg3 = (PyObject *) 0 ;
27900 PyObject * obj0 = 0 ;
27901 PyObject * obj1 = 0 ;
27902 PyObject * obj2 = 0 ;
27903 char *kwnames[] = {
27904 (char *) "self",(char *) "self",(char *) "_class", NULL
27905 };
27906
27907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27909 if (SWIG_arg_fail(1)) SWIG_fail;
27910 arg2 = obj1;
27911 arg3 = obj2;
27912 {
27913 PyThreadState* __tstate = wxPyBeginAllowThreads();
27914 (arg1)->_setCallbackInfo(arg2,arg3);
27915
27916 wxPyEndAllowThreads(__tstate);
27917 if (PyErr_Occurred()) SWIG_fail;
27918 }
27919 Py_INCREF(Py_None); resultobj = Py_None;
27920 return resultobj;
27921 fail:
27922 return NULL;
27923 }
27924
27925
27926 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27927 PyObject *obj;
27928 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27929 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27930 Py_INCREF(obj);
27931 return Py_BuildValue((char *)"");
27932 }
27933 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27934 PyObject *resultobj;
27935 wxFileDataObject *result;
27936 char *kwnames[] = {
27937 NULL
27938 };
27939
27940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27941 {
27942 PyThreadState* __tstate = wxPyBeginAllowThreads();
27943 result = (wxFileDataObject *)new wxFileDataObject();
27944
27945 wxPyEndAllowThreads(__tstate);
27946 if (PyErr_Occurred()) SWIG_fail;
27947 }
27948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27949 return resultobj;
27950 fail:
27951 return NULL;
27952 }
27953
27954
27955 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27956 PyObject *resultobj;
27957 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27958 wxArrayString *result;
27959 PyObject * obj0 = 0 ;
27960 char *kwnames[] = {
27961 (char *) "self", NULL
27962 };
27963
27964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27966 if (SWIG_arg_fail(1)) SWIG_fail;
27967 {
27968 PyThreadState* __tstate = wxPyBeginAllowThreads();
27969 {
27970 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27971 result = (wxArrayString *) &_result_ref;
27972 }
27973
27974 wxPyEndAllowThreads(__tstate);
27975 if (PyErr_Occurred()) SWIG_fail;
27976 }
27977 {
27978 resultobj = wxArrayString2PyList_helper(*result);
27979 }
27980 return resultobj;
27981 fail:
27982 return NULL;
27983 }
27984
27985
27986 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
27987 PyObject *resultobj;
27988 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27989 wxString *arg2 = 0 ;
27990 bool temp2 = false ;
27991 PyObject * obj0 = 0 ;
27992 PyObject * obj1 = 0 ;
27993 char *kwnames[] = {
27994 (char *) "self",(char *) "filename", NULL
27995 };
27996
27997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
27998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27999 if (SWIG_arg_fail(1)) SWIG_fail;
28000 {
28001 arg2 = wxString_in_helper(obj1);
28002 if (arg2 == NULL) SWIG_fail;
28003 temp2 = true;
28004 }
28005 {
28006 PyThreadState* __tstate = wxPyBeginAllowThreads();
28007 (arg1)->AddFile((wxString const &)*arg2);
28008
28009 wxPyEndAllowThreads(__tstate);
28010 if (PyErr_Occurred()) SWIG_fail;
28011 }
28012 Py_INCREF(Py_None); resultobj = Py_None;
28013 {
28014 if (temp2)
28015 delete arg2;
28016 }
28017 return resultobj;
28018 fail:
28019 {
28020 if (temp2)
28021 delete arg2;
28022 }
28023 return NULL;
28024 }
28025
28026
28027 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28028 PyObject *obj;
28029 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28030 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28031 Py_INCREF(obj);
28032 return Py_BuildValue((char *)"");
28033 }
28034 static PyObject *_wrap_new_CustomDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28035 PyObject *resultobj;
28036 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
28037 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
28038 wxCustomDataObject *result;
28039 PyObject * obj0 = 0 ;
28040 char *kwnames[] = {
28041 (char *) "format", NULL
28042 };
28043
28044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_CustomDataObject",kwnames,&obj0)) goto fail;
28045 if (obj0) {
28046 {
28047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28048 if (SWIG_arg_fail(1)) SWIG_fail;
28049 if (arg1 == NULL) {
28050 SWIG_null_ref("wxDataFormat");
28051 }
28052 if (SWIG_arg_fail(1)) SWIG_fail;
28053 }
28054 }
28055 {
28056 PyThreadState* __tstate = wxPyBeginAllowThreads();
28057 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28058
28059 wxPyEndAllowThreads(__tstate);
28060 if (PyErr_Occurred()) SWIG_fail;
28061 }
28062 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28063 return resultobj;
28064 fail:
28065 return NULL;
28066 }
28067
28068
28069 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28070 PyObject *resultobj;
28071 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28072 PyObject *arg2 = (PyObject *) 0 ;
28073 bool result;
28074 PyObject * obj0 = 0 ;
28075 PyObject * obj1 = 0 ;
28076 char *kwnames[] = {
28077 (char *) "self",(char *) "data", NULL
28078 };
28079
28080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28082 if (SWIG_arg_fail(1)) SWIG_fail;
28083 arg2 = obj1;
28084 {
28085 PyThreadState* __tstate = wxPyBeginAllowThreads();
28086 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28087
28088 wxPyEndAllowThreads(__tstate);
28089 if (PyErr_Occurred()) SWIG_fail;
28090 }
28091 {
28092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28093 }
28094 return resultobj;
28095 fail:
28096 return NULL;
28097 }
28098
28099
28100 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28101 PyObject *resultobj;
28102 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28103 size_t result;
28104 PyObject * obj0 = 0 ;
28105 char *kwnames[] = {
28106 (char *) "self", NULL
28107 };
28108
28109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28111 if (SWIG_arg_fail(1)) SWIG_fail;
28112 {
28113 PyThreadState* __tstate = wxPyBeginAllowThreads();
28114 result = (size_t)(arg1)->GetSize();
28115
28116 wxPyEndAllowThreads(__tstate);
28117 if (PyErr_Occurred()) SWIG_fail;
28118 }
28119 {
28120 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28121 }
28122 return resultobj;
28123 fail:
28124 return NULL;
28125 }
28126
28127
28128 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28129 PyObject *resultobj;
28130 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28131 PyObject *result;
28132 PyObject * obj0 = 0 ;
28133 char *kwnames[] = {
28134 (char *) "self", NULL
28135 };
28136
28137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28139 if (SWIG_arg_fail(1)) SWIG_fail;
28140 {
28141 PyThreadState* __tstate = wxPyBeginAllowThreads();
28142 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28143
28144 wxPyEndAllowThreads(__tstate);
28145 if (PyErr_Occurred()) SWIG_fail;
28146 }
28147 resultobj = result;
28148 return resultobj;
28149 fail:
28150 return NULL;
28151 }
28152
28153
28154 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28155 PyObject *obj;
28156 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28157 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28158 Py_INCREF(obj);
28159 return Py_BuildValue((char *)"");
28160 }
28161 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28162 PyObject *resultobj;
28163 wxURLDataObject *result;
28164 char *kwnames[] = {
28165 NULL
28166 };
28167
28168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28169 {
28170 PyThreadState* __tstate = wxPyBeginAllowThreads();
28171 result = (wxURLDataObject *)new wxURLDataObject();
28172
28173 wxPyEndAllowThreads(__tstate);
28174 if (PyErr_Occurred()) SWIG_fail;
28175 }
28176 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28177 return resultobj;
28178 fail:
28179 return NULL;
28180 }
28181
28182
28183 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28184 PyObject *resultobj;
28185 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28186 wxString result;
28187 PyObject * obj0 = 0 ;
28188 char *kwnames[] = {
28189 (char *) "self", NULL
28190 };
28191
28192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28194 if (SWIG_arg_fail(1)) SWIG_fail;
28195 {
28196 PyThreadState* __tstate = wxPyBeginAllowThreads();
28197 result = (arg1)->GetURL();
28198
28199 wxPyEndAllowThreads(__tstate);
28200 if (PyErr_Occurred()) SWIG_fail;
28201 }
28202 {
28203 #if wxUSE_UNICODE
28204 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28205 #else
28206 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28207 #endif
28208 }
28209 return resultobj;
28210 fail:
28211 return NULL;
28212 }
28213
28214
28215 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28216 PyObject *resultobj;
28217 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28218 wxString *arg2 = 0 ;
28219 bool temp2 = false ;
28220 PyObject * obj0 = 0 ;
28221 PyObject * obj1 = 0 ;
28222 char *kwnames[] = {
28223 (char *) "self",(char *) "url", NULL
28224 };
28225
28226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28228 if (SWIG_arg_fail(1)) SWIG_fail;
28229 {
28230 arg2 = wxString_in_helper(obj1);
28231 if (arg2 == NULL) SWIG_fail;
28232 temp2 = true;
28233 }
28234 {
28235 PyThreadState* __tstate = wxPyBeginAllowThreads();
28236 (arg1)->SetURL((wxString const &)*arg2);
28237
28238 wxPyEndAllowThreads(__tstate);
28239 if (PyErr_Occurred()) SWIG_fail;
28240 }
28241 Py_INCREF(Py_None); resultobj = Py_None;
28242 {
28243 if (temp2)
28244 delete arg2;
28245 }
28246 return resultobj;
28247 fail:
28248 {
28249 if (temp2)
28250 delete arg2;
28251 }
28252 return NULL;
28253 }
28254
28255
28256 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28257 PyObject *obj;
28258 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28259 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28260 Py_INCREF(obj);
28261 return Py_BuildValue((char *)"");
28262 }
28263 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28264 PyObject *resultobj;
28265 wxMetafileDataObject *result;
28266 char *kwnames[] = {
28267 NULL
28268 };
28269
28270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28271 {
28272 PyThreadState* __tstate = wxPyBeginAllowThreads();
28273 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28274
28275 wxPyEndAllowThreads(__tstate);
28276 if (PyErr_Occurred()) SWIG_fail;
28277 }
28278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28279 return resultobj;
28280 fail:
28281 return NULL;
28282 }
28283
28284
28285 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28286 PyObject *obj;
28287 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28288 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28289 Py_INCREF(obj);
28290 return Py_BuildValue((char *)"");
28291 }
28292 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28293 PyObject *resultobj;
28294 wxDragResult arg1 ;
28295 bool result;
28296 PyObject * obj0 = 0 ;
28297 char *kwnames[] = {
28298 (char *) "res", NULL
28299 };
28300
28301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28302 {
28303 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28304 if (SWIG_arg_fail(1)) SWIG_fail;
28305 }
28306 {
28307 PyThreadState* __tstate = wxPyBeginAllowThreads();
28308 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28309
28310 wxPyEndAllowThreads(__tstate);
28311 if (PyErr_Occurred()) SWIG_fail;
28312 }
28313 {
28314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28315 }
28316 return resultobj;
28317 fail:
28318 return NULL;
28319 }
28320
28321
28322 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28323 PyObject *resultobj;
28324 wxWindow *arg1 = (wxWindow *) 0 ;
28325 wxIcon const &arg2_defvalue = wxNullIcon ;
28326 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
28327 wxIcon const &arg3_defvalue = wxNullIcon ;
28328 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
28329 wxIcon const &arg4_defvalue = wxNullIcon ;
28330 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
28331 wxPyDropSource *result;
28332 PyObject * obj0 = 0 ;
28333 PyObject * obj1 = 0 ;
28334 PyObject * obj2 = 0 ;
28335 PyObject * obj3 = 0 ;
28336 char *kwnames[] = {
28337 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28338 };
28339
28340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28342 if (SWIG_arg_fail(1)) SWIG_fail;
28343 if (obj1) {
28344 {
28345 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28346 if (SWIG_arg_fail(2)) SWIG_fail;
28347 if (arg2 == NULL) {
28348 SWIG_null_ref("wxIcon");
28349 }
28350 if (SWIG_arg_fail(2)) SWIG_fail;
28351 }
28352 }
28353 if (obj2) {
28354 {
28355 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28356 if (SWIG_arg_fail(3)) SWIG_fail;
28357 if (arg3 == NULL) {
28358 SWIG_null_ref("wxIcon");
28359 }
28360 if (SWIG_arg_fail(3)) SWIG_fail;
28361 }
28362 }
28363 if (obj3) {
28364 {
28365 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28366 if (SWIG_arg_fail(4)) SWIG_fail;
28367 if (arg4 == NULL) {
28368 SWIG_null_ref("wxIcon");
28369 }
28370 if (SWIG_arg_fail(4)) SWIG_fail;
28371 }
28372 }
28373 {
28374 PyThreadState* __tstate = wxPyBeginAllowThreads();
28375 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
28376
28377 wxPyEndAllowThreads(__tstate);
28378 if (PyErr_Occurred()) SWIG_fail;
28379 }
28380 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28381 return resultobj;
28382 fail:
28383 return NULL;
28384 }
28385
28386
28387 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28388 PyObject *resultobj;
28389 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28390 PyObject *arg2 = (PyObject *) 0 ;
28391 PyObject *arg3 = (PyObject *) 0 ;
28392 int arg4 ;
28393 PyObject * obj0 = 0 ;
28394 PyObject * obj1 = 0 ;
28395 PyObject * obj2 = 0 ;
28396 PyObject * obj3 = 0 ;
28397 char *kwnames[] = {
28398 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28399 };
28400
28401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28403 if (SWIG_arg_fail(1)) SWIG_fail;
28404 arg2 = obj1;
28405 arg3 = obj2;
28406 {
28407 arg4 = (int)(SWIG_As_int(obj3));
28408 if (SWIG_arg_fail(4)) SWIG_fail;
28409 }
28410 {
28411 PyThreadState* __tstate = wxPyBeginAllowThreads();
28412 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28413
28414 wxPyEndAllowThreads(__tstate);
28415 if (PyErr_Occurred()) SWIG_fail;
28416 }
28417 Py_INCREF(Py_None); resultobj = Py_None;
28418 return resultobj;
28419 fail:
28420 return NULL;
28421 }
28422
28423
28424 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28425 PyObject *resultobj;
28426 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28427 PyObject * obj0 = 0 ;
28428 char *kwnames[] = {
28429 (char *) "self", NULL
28430 };
28431
28432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28434 if (SWIG_arg_fail(1)) SWIG_fail;
28435 {
28436 PyThreadState* __tstate = wxPyBeginAllowThreads();
28437 delete arg1;
28438
28439 wxPyEndAllowThreads(__tstate);
28440 if (PyErr_Occurred()) SWIG_fail;
28441 }
28442 Py_INCREF(Py_None); resultobj = Py_None;
28443 return resultobj;
28444 fail:
28445 return NULL;
28446 }
28447
28448
28449 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28450 PyObject *resultobj;
28451 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28452 wxDataObject *arg2 = 0 ;
28453 PyObject * obj0 = 0 ;
28454 PyObject * obj1 = 0 ;
28455 char *kwnames[] = {
28456 (char *) "self",(char *) "data", NULL
28457 };
28458
28459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28461 if (SWIG_arg_fail(1)) SWIG_fail;
28462 {
28463 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28464 if (SWIG_arg_fail(2)) SWIG_fail;
28465 if (arg2 == NULL) {
28466 SWIG_null_ref("wxDataObject");
28467 }
28468 if (SWIG_arg_fail(2)) SWIG_fail;
28469 }
28470 {
28471 PyThreadState* __tstate = wxPyBeginAllowThreads();
28472 (arg1)->SetData(*arg2);
28473
28474 wxPyEndAllowThreads(__tstate);
28475 if (PyErr_Occurred()) SWIG_fail;
28476 }
28477 Py_INCREF(Py_None); resultobj = Py_None;
28478 return resultobj;
28479 fail:
28480 return NULL;
28481 }
28482
28483
28484 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28485 PyObject *resultobj;
28486 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28487 wxDataObject *result;
28488 PyObject * obj0 = 0 ;
28489 char *kwnames[] = {
28490 (char *) "self", NULL
28491 };
28492
28493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28495 if (SWIG_arg_fail(1)) SWIG_fail;
28496 {
28497 PyThreadState* __tstate = wxPyBeginAllowThreads();
28498 result = (wxDataObject *)(arg1)->GetDataObject();
28499
28500 wxPyEndAllowThreads(__tstate);
28501 if (PyErr_Occurred()) SWIG_fail;
28502 }
28503 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28504 return resultobj;
28505 fail:
28506 return NULL;
28507 }
28508
28509
28510 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28511 PyObject *resultobj;
28512 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28513 wxDragResult arg2 ;
28514 wxCursor *arg3 = 0 ;
28515 PyObject * obj0 = 0 ;
28516 PyObject * obj1 = 0 ;
28517 PyObject * obj2 = 0 ;
28518 char *kwnames[] = {
28519 (char *) "self",(char *) "res",(char *) "cursor", NULL
28520 };
28521
28522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28524 if (SWIG_arg_fail(1)) SWIG_fail;
28525 {
28526 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28527 if (SWIG_arg_fail(2)) SWIG_fail;
28528 }
28529 {
28530 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28531 if (SWIG_arg_fail(3)) SWIG_fail;
28532 if (arg3 == NULL) {
28533 SWIG_null_ref("wxCursor");
28534 }
28535 if (SWIG_arg_fail(3)) SWIG_fail;
28536 }
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28540
28541 wxPyEndAllowThreads(__tstate);
28542 if (PyErr_Occurred()) SWIG_fail;
28543 }
28544 Py_INCREF(Py_None); resultobj = Py_None;
28545 return resultobj;
28546 fail:
28547 return NULL;
28548 }
28549
28550
28551 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28552 PyObject *resultobj;
28553 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28554 int arg2 = (int) wxDrag_CopyOnly ;
28555 wxDragResult result;
28556 PyObject * obj0 = 0 ;
28557 PyObject * obj1 = 0 ;
28558 char *kwnames[] = {
28559 (char *) "self",(char *) "flags", NULL
28560 };
28561
28562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28564 if (SWIG_arg_fail(1)) SWIG_fail;
28565 if (obj1) {
28566 {
28567 arg2 = (int)(SWIG_As_int(obj1));
28568 if (SWIG_arg_fail(2)) SWIG_fail;
28569 }
28570 }
28571 {
28572 PyThreadState* __tstate = wxPyBeginAllowThreads();
28573 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28574
28575 wxPyEndAllowThreads(__tstate);
28576 if (PyErr_Occurred()) SWIG_fail;
28577 }
28578 resultobj = SWIG_From_int((result));
28579 return resultobj;
28580 fail:
28581 return NULL;
28582 }
28583
28584
28585 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28586 PyObject *resultobj;
28587 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28588 wxDragResult arg2 ;
28589 bool result;
28590 PyObject * obj0 = 0 ;
28591 PyObject * obj1 = 0 ;
28592 char *kwnames[] = {
28593 (char *) "self",(char *) "effect", NULL
28594 };
28595
28596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28598 if (SWIG_arg_fail(1)) SWIG_fail;
28599 {
28600 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28601 if (SWIG_arg_fail(2)) SWIG_fail;
28602 }
28603 {
28604 PyThreadState* __tstate = wxPyBeginAllowThreads();
28605 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28606
28607 wxPyEndAllowThreads(__tstate);
28608 if (PyErr_Occurred()) SWIG_fail;
28609 }
28610 {
28611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28612 }
28613 return resultobj;
28614 fail:
28615 return NULL;
28616 }
28617
28618
28619 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28620 PyObject *obj;
28621 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28622 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28623 Py_INCREF(obj);
28624 return Py_BuildValue((char *)"");
28625 }
28626 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28627 PyObject *resultobj;
28628 wxDataObject *arg1 = (wxDataObject *) NULL ;
28629 wxPyDropTarget *result;
28630 PyObject * obj0 = 0 ;
28631 char *kwnames[] = {
28632 (char *) "dataObject", NULL
28633 };
28634
28635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28636 if (obj0) {
28637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28638 if (SWIG_arg_fail(1)) SWIG_fail;
28639 }
28640 {
28641 PyThreadState* __tstate = wxPyBeginAllowThreads();
28642 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28643
28644 wxPyEndAllowThreads(__tstate);
28645 if (PyErr_Occurred()) SWIG_fail;
28646 }
28647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28648 return resultobj;
28649 fail:
28650 return NULL;
28651 }
28652
28653
28654 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28655 PyObject *resultobj;
28656 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28657 PyObject *arg2 = (PyObject *) 0 ;
28658 PyObject *arg3 = (PyObject *) 0 ;
28659 PyObject * obj0 = 0 ;
28660 PyObject * obj1 = 0 ;
28661 PyObject * obj2 = 0 ;
28662 char *kwnames[] = {
28663 (char *) "self",(char *) "self",(char *) "_class", NULL
28664 };
28665
28666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28668 if (SWIG_arg_fail(1)) SWIG_fail;
28669 arg2 = obj1;
28670 arg3 = obj2;
28671 {
28672 PyThreadState* __tstate = wxPyBeginAllowThreads();
28673 (arg1)->_setCallbackInfo(arg2,arg3);
28674
28675 wxPyEndAllowThreads(__tstate);
28676 if (PyErr_Occurred()) SWIG_fail;
28677 }
28678 Py_INCREF(Py_None); resultobj = Py_None;
28679 return resultobj;
28680 fail:
28681 return NULL;
28682 }
28683
28684
28685 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28686 PyObject *resultobj;
28687 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28688 PyObject * obj0 = 0 ;
28689 char *kwnames[] = {
28690 (char *) "self", NULL
28691 };
28692
28693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28695 if (SWIG_arg_fail(1)) SWIG_fail;
28696 {
28697 PyThreadState* __tstate = wxPyBeginAllowThreads();
28698 delete arg1;
28699
28700 wxPyEndAllowThreads(__tstate);
28701 if (PyErr_Occurred()) SWIG_fail;
28702 }
28703 Py_INCREF(Py_None); resultobj = Py_None;
28704 return resultobj;
28705 fail:
28706 return NULL;
28707 }
28708
28709
28710 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28711 PyObject *resultobj;
28712 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28713 wxDataObject *result;
28714 PyObject * obj0 = 0 ;
28715 char *kwnames[] = {
28716 (char *) "self", NULL
28717 };
28718
28719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28721 if (SWIG_arg_fail(1)) SWIG_fail;
28722 {
28723 PyThreadState* __tstate = wxPyBeginAllowThreads();
28724 result = (wxDataObject *)(arg1)->GetDataObject();
28725
28726 wxPyEndAllowThreads(__tstate);
28727 if (PyErr_Occurred()) SWIG_fail;
28728 }
28729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28730 return resultobj;
28731 fail:
28732 return NULL;
28733 }
28734
28735
28736 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28737 PyObject *resultobj;
28738 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28739 wxDataObject *arg2 = (wxDataObject *) 0 ;
28740 PyObject * obj0 = 0 ;
28741 PyObject * obj1 = 0 ;
28742 char *kwnames[] = {
28743 (char *) "self",(char *) "dataObject", NULL
28744 };
28745
28746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28748 if (SWIG_arg_fail(1)) SWIG_fail;
28749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28750 if (SWIG_arg_fail(2)) SWIG_fail;
28751 {
28752 PyThreadState* __tstate = wxPyBeginAllowThreads();
28753 (arg1)->SetDataObject(arg2);
28754
28755 wxPyEndAllowThreads(__tstate);
28756 if (PyErr_Occurred()) SWIG_fail;
28757 }
28758 Py_INCREF(Py_None); resultobj = Py_None;
28759 return resultobj;
28760 fail:
28761 return NULL;
28762 }
28763
28764
28765 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28766 PyObject *resultobj;
28767 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28768 int arg2 ;
28769 int arg3 ;
28770 wxDragResult arg4 ;
28771 wxDragResult result;
28772 PyObject * obj0 = 0 ;
28773 PyObject * obj1 = 0 ;
28774 PyObject * obj2 = 0 ;
28775 PyObject * obj3 = 0 ;
28776 char *kwnames[] = {
28777 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28778 };
28779
28780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28782 if (SWIG_arg_fail(1)) SWIG_fail;
28783 {
28784 arg2 = (int)(SWIG_As_int(obj1));
28785 if (SWIG_arg_fail(2)) SWIG_fail;
28786 }
28787 {
28788 arg3 = (int)(SWIG_As_int(obj2));
28789 if (SWIG_arg_fail(3)) SWIG_fail;
28790 }
28791 {
28792 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28793 if (SWIG_arg_fail(4)) SWIG_fail;
28794 }
28795 {
28796 PyThreadState* __tstate = wxPyBeginAllowThreads();
28797 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28798
28799 wxPyEndAllowThreads(__tstate);
28800 if (PyErr_Occurred()) SWIG_fail;
28801 }
28802 resultobj = SWIG_From_int((result));
28803 return resultobj;
28804 fail:
28805 return NULL;
28806 }
28807
28808
28809 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28810 PyObject *resultobj;
28811 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28812 int arg2 ;
28813 int arg3 ;
28814 wxDragResult arg4 ;
28815 wxDragResult result;
28816 PyObject * obj0 = 0 ;
28817 PyObject * obj1 = 0 ;
28818 PyObject * obj2 = 0 ;
28819 PyObject * obj3 = 0 ;
28820 char *kwnames[] = {
28821 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28822 };
28823
28824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28826 if (SWIG_arg_fail(1)) SWIG_fail;
28827 {
28828 arg2 = (int)(SWIG_As_int(obj1));
28829 if (SWIG_arg_fail(2)) SWIG_fail;
28830 }
28831 {
28832 arg3 = (int)(SWIG_As_int(obj2));
28833 if (SWIG_arg_fail(3)) SWIG_fail;
28834 }
28835 {
28836 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28837 if (SWIG_arg_fail(4)) SWIG_fail;
28838 }
28839 {
28840 PyThreadState* __tstate = wxPyBeginAllowThreads();
28841 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28842
28843 wxPyEndAllowThreads(__tstate);
28844 if (PyErr_Occurred()) SWIG_fail;
28845 }
28846 resultobj = SWIG_From_int((result));
28847 return resultobj;
28848 fail:
28849 return NULL;
28850 }
28851
28852
28853 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28854 PyObject *resultobj;
28855 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28856 PyObject * obj0 = 0 ;
28857 char *kwnames[] = {
28858 (char *) "self", NULL
28859 };
28860
28861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28863 if (SWIG_arg_fail(1)) SWIG_fail;
28864 {
28865 PyThreadState* __tstate = wxPyBeginAllowThreads();
28866 (arg1)->base_OnLeave();
28867
28868 wxPyEndAllowThreads(__tstate);
28869 if (PyErr_Occurred()) SWIG_fail;
28870 }
28871 Py_INCREF(Py_None); resultobj = Py_None;
28872 return resultobj;
28873 fail:
28874 return NULL;
28875 }
28876
28877
28878 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28879 PyObject *resultobj;
28880 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28881 int arg2 ;
28882 int arg3 ;
28883 bool result;
28884 PyObject * obj0 = 0 ;
28885 PyObject * obj1 = 0 ;
28886 PyObject * obj2 = 0 ;
28887 char *kwnames[] = {
28888 (char *) "self",(char *) "x",(char *) "y", NULL
28889 };
28890
28891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28893 if (SWIG_arg_fail(1)) SWIG_fail;
28894 {
28895 arg2 = (int)(SWIG_As_int(obj1));
28896 if (SWIG_arg_fail(2)) SWIG_fail;
28897 }
28898 {
28899 arg3 = (int)(SWIG_As_int(obj2));
28900 if (SWIG_arg_fail(3)) SWIG_fail;
28901 }
28902 {
28903 PyThreadState* __tstate = wxPyBeginAllowThreads();
28904 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28905
28906 wxPyEndAllowThreads(__tstate);
28907 if (PyErr_Occurred()) SWIG_fail;
28908 }
28909 {
28910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28911 }
28912 return resultobj;
28913 fail:
28914 return NULL;
28915 }
28916
28917
28918 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28919 PyObject *resultobj;
28920 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28921 bool result;
28922 PyObject * obj0 = 0 ;
28923 char *kwnames[] = {
28924 (char *) "self", NULL
28925 };
28926
28927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
28928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28929 if (SWIG_arg_fail(1)) SWIG_fail;
28930 {
28931 PyThreadState* __tstate = wxPyBeginAllowThreads();
28932 result = (bool)(arg1)->GetData();
28933
28934 wxPyEndAllowThreads(__tstate);
28935 if (PyErr_Occurred()) SWIG_fail;
28936 }
28937 {
28938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28939 }
28940 return resultobj;
28941 fail:
28942 return NULL;
28943 }
28944
28945
28946 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
28947 PyObject *obj;
28948 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28949 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
28950 Py_INCREF(obj);
28951 return Py_BuildValue((char *)"");
28952 }
28953 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28954 PyObject *resultobj;
28955 wxPyTextDropTarget *result;
28956 char *kwnames[] = {
28957 NULL
28958 };
28959
28960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
28961 {
28962 PyThreadState* __tstate = wxPyBeginAllowThreads();
28963 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
28964
28965 wxPyEndAllowThreads(__tstate);
28966 if (PyErr_Occurred()) SWIG_fail;
28967 }
28968 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
28969 return resultobj;
28970 fail:
28971 return NULL;
28972 }
28973
28974
28975 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28976 PyObject *resultobj;
28977 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28978 PyObject *arg2 = (PyObject *) 0 ;
28979 PyObject *arg3 = (PyObject *) 0 ;
28980 PyObject * obj0 = 0 ;
28981 PyObject * obj1 = 0 ;
28982 PyObject * obj2 = 0 ;
28983 char *kwnames[] = {
28984 (char *) "self",(char *) "self",(char *) "_class", NULL
28985 };
28986
28987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28989 if (SWIG_arg_fail(1)) SWIG_fail;
28990 arg2 = obj1;
28991 arg3 = obj2;
28992 {
28993 PyThreadState* __tstate = wxPyBeginAllowThreads();
28994 (arg1)->_setCallbackInfo(arg2,arg3);
28995
28996 wxPyEndAllowThreads(__tstate);
28997 if (PyErr_Occurred()) SWIG_fail;
28998 }
28999 Py_INCREF(Py_None); resultobj = Py_None;
29000 return resultobj;
29001 fail:
29002 return NULL;
29003 }
29004
29005
29006 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29007 PyObject *resultobj;
29008 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29009 int arg2 ;
29010 int arg3 ;
29011 wxDragResult arg4 ;
29012 wxDragResult result;
29013 PyObject * obj0 = 0 ;
29014 PyObject * obj1 = 0 ;
29015 PyObject * obj2 = 0 ;
29016 PyObject * obj3 = 0 ;
29017 char *kwnames[] = {
29018 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29019 };
29020
29021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29023 if (SWIG_arg_fail(1)) SWIG_fail;
29024 {
29025 arg2 = (int)(SWIG_As_int(obj1));
29026 if (SWIG_arg_fail(2)) SWIG_fail;
29027 }
29028 {
29029 arg3 = (int)(SWIG_As_int(obj2));
29030 if (SWIG_arg_fail(3)) SWIG_fail;
29031 }
29032 {
29033 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29034 if (SWIG_arg_fail(4)) SWIG_fail;
29035 }
29036 {
29037 PyThreadState* __tstate = wxPyBeginAllowThreads();
29038 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29039
29040 wxPyEndAllowThreads(__tstate);
29041 if (PyErr_Occurred()) SWIG_fail;
29042 }
29043 resultobj = SWIG_From_int((result));
29044 return resultobj;
29045 fail:
29046 return NULL;
29047 }
29048
29049
29050 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29051 PyObject *resultobj;
29052 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29053 int arg2 ;
29054 int arg3 ;
29055 wxDragResult arg4 ;
29056 wxDragResult result;
29057 PyObject * obj0 = 0 ;
29058 PyObject * obj1 = 0 ;
29059 PyObject * obj2 = 0 ;
29060 PyObject * obj3 = 0 ;
29061 char *kwnames[] = {
29062 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29063 };
29064
29065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29067 if (SWIG_arg_fail(1)) SWIG_fail;
29068 {
29069 arg2 = (int)(SWIG_As_int(obj1));
29070 if (SWIG_arg_fail(2)) SWIG_fail;
29071 }
29072 {
29073 arg3 = (int)(SWIG_As_int(obj2));
29074 if (SWIG_arg_fail(3)) SWIG_fail;
29075 }
29076 {
29077 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29078 if (SWIG_arg_fail(4)) SWIG_fail;
29079 }
29080 {
29081 PyThreadState* __tstate = wxPyBeginAllowThreads();
29082 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29083
29084 wxPyEndAllowThreads(__tstate);
29085 if (PyErr_Occurred()) SWIG_fail;
29086 }
29087 resultobj = SWIG_From_int((result));
29088 return resultobj;
29089 fail:
29090 return NULL;
29091 }
29092
29093
29094 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29095 PyObject *resultobj;
29096 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29097 PyObject * obj0 = 0 ;
29098 char *kwnames[] = {
29099 (char *) "self", NULL
29100 };
29101
29102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29104 if (SWIG_arg_fail(1)) SWIG_fail;
29105 {
29106 PyThreadState* __tstate = wxPyBeginAllowThreads();
29107 (arg1)->base_OnLeave();
29108
29109 wxPyEndAllowThreads(__tstate);
29110 if (PyErr_Occurred()) SWIG_fail;
29111 }
29112 Py_INCREF(Py_None); resultobj = Py_None;
29113 return resultobj;
29114 fail:
29115 return NULL;
29116 }
29117
29118
29119 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29120 PyObject *resultobj;
29121 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29122 int arg2 ;
29123 int arg3 ;
29124 bool result;
29125 PyObject * obj0 = 0 ;
29126 PyObject * obj1 = 0 ;
29127 PyObject * obj2 = 0 ;
29128 char *kwnames[] = {
29129 (char *) "self",(char *) "x",(char *) "y", NULL
29130 };
29131
29132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29134 if (SWIG_arg_fail(1)) SWIG_fail;
29135 {
29136 arg2 = (int)(SWIG_As_int(obj1));
29137 if (SWIG_arg_fail(2)) SWIG_fail;
29138 }
29139 {
29140 arg3 = (int)(SWIG_As_int(obj2));
29141 if (SWIG_arg_fail(3)) SWIG_fail;
29142 }
29143 {
29144 PyThreadState* __tstate = wxPyBeginAllowThreads();
29145 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29146
29147 wxPyEndAllowThreads(__tstate);
29148 if (PyErr_Occurred()) SWIG_fail;
29149 }
29150 {
29151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29152 }
29153 return resultobj;
29154 fail:
29155 return NULL;
29156 }
29157
29158
29159 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29160 PyObject *resultobj;
29161 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29162 int arg2 ;
29163 int arg3 ;
29164 wxDragResult arg4 ;
29165 wxDragResult result;
29166 PyObject * obj0 = 0 ;
29167 PyObject * obj1 = 0 ;
29168 PyObject * obj2 = 0 ;
29169 PyObject * obj3 = 0 ;
29170 char *kwnames[] = {
29171 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29172 };
29173
29174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29176 if (SWIG_arg_fail(1)) SWIG_fail;
29177 {
29178 arg2 = (int)(SWIG_As_int(obj1));
29179 if (SWIG_arg_fail(2)) SWIG_fail;
29180 }
29181 {
29182 arg3 = (int)(SWIG_As_int(obj2));
29183 if (SWIG_arg_fail(3)) SWIG_fail;
29184 }
29185 {
29186 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29187 if (SWIG_arg_fail(4)) SWIG_fail;
29188 }
29189 {
29190 PyThreadState* __tstate = wxPyBeginAllowThreads();
29191 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29192
29193 wxPyEndAllowThreads(__tstate);
29194 if (PyErr_Occurred()) SWIG_fail;
29195 }
29196 resultobj = SWIG_From_int((result));
29197 return resultobj;
29198 fail:
29199 return NULL;
29200 }
29201
29202
29203 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29204 PyObject *obj;
29205 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29206 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29207 Py_INCREF(obj);
29208 return Py_BuildValue((char *)"");
29209 }
29210 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29211 PyObject *resultobj;
29212 wxPyFileDropTarget *result;
29213 char *kwnames[] = {
29214 NULL
29215 };
29216
29217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29218 {
29219 PyThreadState* __tstate = wxPyBeginAllowThreads();
29220 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29221
29222 wxPyEndAllowThreads(__tstate);
29223 if (PyErr_Occurred()) SWIG_fail;
29224 }
29225 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29226 return resultobj;
29227 fail:
29228 return NULL;
29229 }
29230
29231
29232 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29233 PyObject *resultobj;
29234 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29235 PyObject *arg2 = (PyObject *) 0 ;
29236 PyObject *arg3 = (PyObject *) 0 ;
29237 PyObject * obj0 = 0 ;
29238 PyObject * obj1 = 0 ;
29239 PyObject * obj2 = 0 ;
29240 char *kwnames[] = {
29241 (char *) "self",(char *) "self",(char *) "_class", NULL
29242 };
29243
29244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29246 if (SWIG_arg_fail(1)) SWIG_fail;
29247 arg2 = obj1;
29248 arg3 = obj2;
29249 {
29250 PyThreadState* __tstate = wxPyBeginAllowThreads();
29251 (arg1)->_setCallbackInfo(arg2,arg3);
29252
29253 wxPyEndAllowThreads(__tstate);
29254 if (PyErr_Occurred()) SWIG_fail;
29255 }
29256 Py_INCREF(Py_None); resultobj = Py_None;
29257 return resultobj;
29258 fail:
29259 return NULL;
29260 }
29261
29262
29263 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29264 PyObject *resultobj;
29265 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29266 int arg2 ;
29267 int arg3 ;
29268 wxDragResult arg4 ;
29269 wxDragResult result;
29270 PyObject * obj0 = 0 ;
29271 PyObject * obj1 = 0 ;
29272 PyObject * obj2 = 0 ;
29273 PyObject * obj3 = 0 ;
29274 char *kwnames[] = {
29275 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29276 };
29277
29278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29280 if (SWIG_arg_fail(1)) SWIG_fail;
29281 {
29282 arg2 = (int)(SWIG_As_int(obj1));
29283 if (SWIG_arg_fail(2)) SWIG_fail;
29284 }
29285 {
29286 arg3 = (int)(SWIG_As_int(obj2));
29287 if (SWIG_arg_fail(3)) SWIG_fail;
29288 }
29289 {
29290 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29291 if (SWIG_arg_fail(4)) SWIG_fail;
29292 }
29293 {
29294 PyThreadState* __tstate = wxPyBeginAllowThreads();
29295 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29296
29297 wxPyEndAllowThreads(__tstate);
29298 if (PyErr_Occurred()) SWIG_fail;
29299 }
29300 resultobj = SWIG_From_int((result));
29301 return resultobj;
29302 fail:
29303 return NULL;
29304 }
29305
29306
29307 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29308 PyObject *resultobj;
29309 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29310 int arg2 ;
29311 int arg3 ;
29312 wxDragResult arg4 ;
29313 wxDragResult result;
29314 PyObject * obj0 = 0 ;
29315 PyObject * obj1 = 0 ;
29316 PyObject * obj2 = 0 ;
29317 PyObject * obj3 = 0 ;
29318 char *kwnames[] = {
29319 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29320 };
29321
29322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29324 if (SWIG_arg_fail(1)) SWIG_fail;
29325 {
29326 arg2 = (int)(SWIG_As_int(obj1));
29327 if (SWIG_arg_fail(2)) SWIG_fail;
29328 }
29329 {
29330 arg3 = (int)(SWIG_As_int(obj2));
29331 if (SWIG_arg_fail(3)) SWIG_fail;
29332 }
29333 {
29334 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29335 if (SWIG_arg_fail(4)) SWIG_fail;
29336 }
29337 {
29338 PyThreadState* __tstate = wxPyBeginAllowThreads();
29339 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29340
29341 wxPyEndAllowThreads(__tstate);
29342 if (PyErr_Occurred()) SWIG_fail;
29343 }
29344 resultobj = SWIG_From_int((result));
29345 return resultobj;
29346 fail:
29347 return NULL;
29348 }
29349
29350
29351 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29352 PyObject *resultobj;
29353 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29354 PyObject * obj0 = 0 ;
29355 char *kwnames[] = {
29356 (char *) "self", NULL
29357 };
29358
29359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29361 if (SWIG_arg_fail(1)) SWIG_fail;
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 (arg1)->base_OnLeave();
29365
29366 wxPyEndAllowThreads(__tstate);
29367 if (PyErr_Occurred()) SWIG_fail;
29368 }
29369 Py_INCREF(Py_None); resultobj = Py_None;
29370 return resultobj;
29371 fail:
29372 return NULL;
29373 }
29374
29375
29376 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29377 PyObject *resultobj;
29378 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29379 int arg2 ;
29380 int arg3 ;
29381 bool result;
29382 PyObject * obj0 = 0 ;
29383 PyObject * obj1 = 0 ;
29384 PyObject * obj2 = 0 ;
29385 char *kwnames[] = {
29386 (char *) "self",(char *) "x",(char *) "y", NULL
29387 };
29388
29389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29391 if (SWIG_arg_fail(1)) SWIG_fail;
29392 {
29393 arg2 = (int)(SWIG_As_int(obj1));
29394 if (SWIG_arg_fail(2)) SWIG_fail;
29395 }
29396 {
29397 arg3 = (int)(SWIG_As_int(obj2));
29398 if (SWIG_arg_fail(3)) SWIG_fail;
29399 }
29400 {
29401 PyThreadState* __tstate = wxPyBeginAllowThreads();
29402 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29403
29404 wxPyEndAllowThreads(__tstate);
29405 if (PyErr_Occurred()) SWIG_fail;
29406 }
29407 {
29408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29409 }
29410 return resultobj;
29411 fail:
29412 return NULL;
29413 }
29414
29415
29416 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29417 PyObject *resultobj;
29418 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29419 int arg2 ;
29420 int arg3 ;
29421 wxDragResult arg4 ;
29422 wxDragResult result;
29423 PyObject * obj0 = 0 ;
29424 PyObject * obj1 = 0 ;
29425 PyObject * obj2 = 0 ;
29426 PyObject * obj3 = 0 ;
29427 char *kwnames[] = {
29428 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29429 };
29430
29431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29433 if (SWIG_arg_fail(1)) SWIG_fail;
29434 {
29435 arg2 = (int)(SWIG_As_int(obj1));
29436 if (SWIG_arg_fail(2)) SWIG_fail;
29437 }
29438 {
29439 arg3 = (int)(SWIG_As_int(obj2));
29440 if (SWIG_arg_fail(3)) SWIG_fail;
29441 }
29442 {
29443 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29444 if (SWIG_arg_fail(4)) SWIG_fail;
29445 }
29446 {
29447 PyThreadState* __tstate = wxPyBeginAllowThreads();
29448 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29449
29450 wxPyEndAllowThreads(__tstate);
29451 if (PyErr_Occurred()) SWIG_fail;
29452 }
29453 resultobj = SWIG_From_int((result));
29454 return resultobj;
29455 fail:
29456 return NULL;
29457 }
29458
29459
29460 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29461 PyObject *obj;
29462 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29463 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29464 Py_INCREF(obj);
29465 return Py_BuildValue((char *)"");
29466 }
29467 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29468 PyObject *resultobj;
29469 wxClipboard *result;
29470 char *kwnames[] = {
29471 NULL
29472 };
29473
29474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29475 {
29476 PyThreadState* __tstate = wxPyBeginAllowThreads();
29477 result = (wxClipboard *)new wxClipboard();
29478
29479 wxPyEndAllowThreads(__tstate);
29480 if (PyErr_Occurred()) SWIG_fail;
29481 }
29482 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29483 return resultobj;
29484 fail:
29485 return NULL;
29486 }
29487
29488
29489 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29490 PyObject *resultobj;
29491 wxClipboard *arg1 = (wxClipboard *) 0 ;
29492 PyObject * obj0 = 0 ;
29493 char *kwnames[] = {
29494 (char *) "self", NULL
29495 };
29496
29497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29499 if (SWIG_arg_fail(1)) SWIG_fail;
29500 {
29501 PyThreadState* __tstate = wxPyBeginAllowThreads();
29502 delete arg1;
29503
29504 wxPyEndAllowThreads(__tstate);
29505 if (PyErr_Occurred()) SWIG_fail;
29506 }
29507 Py_INCREF(Py_None); resultobj = Py_None;
29508 return resultobj;
29509 fail:
29510 return NULL;
29511 }
29512
29513
29514 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29515 PyObject *resultobj;
29516 wxClipboard *arg1 = (wxClipboard *) 0 ;
29517 bool result;
29518 PyObject * obj0 = 0 ;
29519 char *kwnames[] = {
29520 (char *) "self", NULL
29521 };
29522
29523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29525 if (SWIG_arg_fail(1)) SWIG_fail;
29526 {
29527 PyThreadState* __tstate = wxPyBeginAllowThreads();
29528 result = (bool)(arg1)->Open();
29529
29530 wxPyEndAllowThreads(__tstate);
29531 if (PyErr_Occurred()) SWIG_fail;
29532 }
29533 {
29534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29535 }
29536 return resultobj;
29537 fail:
29538 return NULL;
29539 }
29540
29541
29542 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29543 PyObject *resultobj;
29544 wxClipboard *arg1 = (wxClipboard *) 0 ;
29545 PyObject * obj0 = 0 ;
29546 char *kwnames[] = {
29547 (char *) "self", NULL
29548 };
29549
29550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29552 if (SWIG_arg_fail(1)) SWIG_fail;
29553 {
29554 PyThreadState* __tstate = wxPyBeginAllowThreads();
29555 (arg1)->Close();
29556
29557 wxPyEndAllowThreads(__tstate);
29558 if (PyErr_Occurred()) SWIG_fail;
29559 }
29560 Py_INCREF(Py_None); resultobj = Py_None;
29561 return resultobj;
29562 fail:
29563 return NULL;
29564 }
29565
29566
29567 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29568 PyObject *resultobj;
29569 wxClipboard *arg1 = (wxClipboard *) 0 ;
29570 bool result;
29571 PyObject * obj0 = 0 ;
29572 char *kwnames[] = {
29573 (char *) "self", NULL
29574 };
29575
29576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29578 if (SWIG_arg_fail(1)) SWIG_fail;
29579 {
29580 PyThreadState* __tstate = wxPyBeginAllowThreads();
29581 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29582
29583 wxPyEndAllowThreads(__tstate);
29584 if (PyErr_Occurred()) SWIG_fail;
29585 }
29586 {
29587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29588 }
29589 return resultobj;
29590 fail:
29591 return NULL;
29592 }
29593
29594
29595 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29596 PyObject *resultobj;
29597 wxClipboard *arg1 = (wxClipboard *) 0 ;
29598 wxDataObject *arg2 = (wxDataObject *) 0 ;
29599 bool result;
29600 PyObject * obj0 = 0 ;
29601 PyObject * obj1 = 0 ;
29602 char *kwnames[] = {
29603 (char *) "self",(char *) "data", NULL
29604 };
29605
29606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29608 if (SWIG_arg_fail(1)) SWIG_fail;
29609 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29610 if (SWIG_arg_fail(2)) SWIG_fail;
29611 {
29612 PyThreadState* __tstate = wxPyBeginAllowThreads();
29613 result = (bool)(arg1)->AddData(arg2);
29614
29615 wxPyEndAllowThreads(__tstate);
29616 if (PyErr_Occurred()) SWIG_fail;
29617 }
29618 {
29619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29620 }
29621 return resultobj;
29622 fail:
29623 return NULL;
29624 }
29625
29626
29627 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29628 PyObject *resultobj;
29629 wxClipboard *arg1 = (wxClipboard *) 0 ;
29630 wxDataObject *arg2 = (wxDataObject *) 0 ;
29631 bool result;
29632 PyObject * obj0 = 0 ;
29633 PyObject * obj1 = 0 ;
29634 char *kwnames[] = {
29635 (char *) "self",(char *) "data", NULL
29636 };
29637
29638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29640 if (SWIG_arg_fail(1)) SWIG_fail;
29641 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29642 if (SWIG_arg_fail(2)) SWIG_fail;
29643 {
29644 PyThreadState* __tstate = wxPyBeginAllowThreads();
29645 result = (bool)(arg1)->SetData(arg2);
29646
29647 wxPyEndAllowThreads(__tstate);
29648 if (PyErr_Occurred()) SWIG_fail;
29649 }
29650 {
29651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29652 }
29653 return resultobj;
29654 fail:
29655 return NULL;
29656 }
29657
29658
29659 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29660 PyObject *resultobj;
29661 wxClipboard *arg1 = (wxClipboard *) 0 ;
29662 wxDataFormat *arg2 = 0 ;
29663 bool result;
29664 PyObject * obj0 = 0 ;
29665 PyObject * obj1 = 0 ;
29666 char *kwnames[] = {
29667 (char *) "self",(char *) "format", NULL
29668 };
29669
29670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29672 if (SWIG_arg_fail(1)) SWIG_fail;
29673 {
29674 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29675 if (SWIG_arg_fail(2)) SWIG_fail;
29676 if (arg2 == NULL) {
29677 SWIG_null_ref("wxDataFormat");
29678 }
29679 if (SWIG_arg_fail(2)) SWIG_fail;
29680 }
29681 {
29682 PyThreadState* __tstate = wxPyBeginAllowThreads();
29683 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29684
29685 wxPyEndAllowThreads(__tstate);
29686 if (PyErr_Occurred()) SWIG_fail;
29687 }
29688 {
29689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29690 }
29691 return resultobj;
29692 fail:
29693 return NULL;
29694 }
29695
29696
29697 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29698 PyObject *resultobj;
29699 wxClipboard *arg1 = (wxClipboard *) 0 ;
29700 wxDataObject *arg2 = 0 ;
29701 bool result;
29702 PyObject * obj0 = 0 ;
29703 PyObject * obj1 = 0 ;
29704 char *kwnames[] = {
29705 (char *) "self",(char *) "data", NULL
29706 };
29707
29708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29710 if (SWIG_arg_fail(1)) SWIG_fail;
29711 {
29712 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29713 if (SWIG_arg_fail(2)) SWIG_fail;
29714 if (arg2 == NULL) {
29715 SWIG_null_ref("wxDataObject");
29716 }
29717 if (SWIG_arg_fail(2)) SWIG_fail;
29718 }
29719 {
29720 PyThreadState* __tstate = wxPyBeginAllowThreads();
29721 result = (bool)(arg1)->GetData(*arg2);
29722
29723 wxPyEndAllowThreads(__tstate);
29724 if (PyErr_Occurred()) SWIG_fail;
29725 }
29726 {
29727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29728 }
29729 return resultobj;
29730 fail:
29731 return NULL;
29732 }
29733
29734
29735 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29736 PyObject *resultobj;
29737 wxClipboard *arg1 = (wxClipboard *) 0 ;
29738 PyObject * obj0 = 0 ;
29739 char *kwnames[] = {
29740 (char *) "self", NULL
29741 };
29742
29743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29745 if (SWIG_arg_fail(1)) SWIG_fail;
29746 {
29747 PyThreadState* __tstate = wxPyBeginAllowThreads();
29748 (arg1)->Clear();
29749
29750 wxPyEndAllowThreads(__tstate);
29751 if (PyErr_Occurred()) SWIG_fail;
29752 }
29753 Py_INCREF(Py_None); resultobj = Py_None;
29754 return resultobj;
29755 fail:
29756 return NULL;
29757 }
29758
29759
29760 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29761 PyObject *resultobj;
29762 wxClipboard *arg1 = (wxClipboard *) 0 ;
29763 bool result;
29764 PyObject * obj0 = 0 ;
29765 char *kwnames[] = {
29766 (char *) "self", NULL
29767 };
29768
29769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29771 if (SWIG_arg_fail(1)) SWIG_fail;
29772 {
29773 PyThreadState* __tstate = wxPyBeginAllowThreads();
29774 result = (bool)(arg1)->Flush();
29775
29776 wxPyEndAllowThreads(__tstate);
29777 if (PyErr_Occurred()) SWIG_fail;
29778 }
29779 {
29780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29781 }
29782 return resultobj;
29783 fail:
29784 return NULL;
29785 }
29786
29787
29788 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29789 PyObject *resultobj;
29790 wxClipboard *arg1 = (wxClipboard *) 0 ;
29791 bool arg2 = (bool) true ;
29792 PyObject * obj0 = 0 ;
29793 PyObject * obj1 = 0 ;
29794 char *kwnames[] = {
29795 (char *) "self",(char *) "primary", NULL
29796 };
29797
29798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29800 if (SWIG_arg_fail(1)) SWIG_fail;
29801 if (obj1) {
29802 {
29803 arg2 = (bool)(SWIG_As_bool(obj1));
29804 if (SWIG_arg_fail(2)) SWIG_fail;
29805 }
29806 }
29807 {
29808 PyThreadState* __tstate = wxPyBeginAllowThreads();
29809 (arg1)->UsePrimarySelection(arg2);
29810
29811 wxPyEndAllowThreads(__tstate);
29812 if (PyErr_Occurred()) SWIG_fail;
29813 }
29814 Py_INCREF(Py_None); resultobj = Py_None;
29815 return resultobj;
29816 fail:
29817 return NULL;
29818 }
29819
29820
29821 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29822 PyObject *resultobj;
29823 wxClipboard *result;
29824 char *kwnames[] = {
29825 NULL
29826 };
29827
29828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29829 {
29830 PyThreadState* __tstate = wxPyBeginAllowThreads();
29831 result = (wxClipboard *)wxClipboard::Get();
29832
29833 wxPyEndAllowThreads(__tstate);
29834 if (PyErr_Occurred()) SWIG_fail;
29835 }
29836 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29837 return resultobj;
29838 fail:
29839 return NULL;
29840 }
29841
29842
29843 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
29844 PyObject *obj;
29845 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29846 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
29847 Py_INCREF(obj);
29848 return Py_BuildValue((char *)"");
29849 }
29850 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29851 PyObject *resultobj;
29852 wxClipboard *arg1 = (wxClipboard *) NULL ;
29853 wxClipboardLocker *result;
29854 PyObject * obj0 = 0 ;
29855 char *kwnames[] = {
29856 (char *) "clipboard", NULL
29857 };
29858
29859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
29860 if (obj0) {
29861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29862 if (SWIG_arg_fail(1)) SWIG_fail;
29863 }
29864 {
29865 PyThreadState* __tstate = wxPyBeginAllowThreads();
29866 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
29867
29868 wxPyEndAllowThreads(__tstate);
29869 if (PyErr_Occurred()) SWIG_fail;
29870 }
29871 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
29872 return resultobj;
29873 fail:
29874 return NULL;
29875 }
29876
29877
29878 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29879 PyObject *resultobj;
29880 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29881 PyObject * obj0 = 0 ;
29882 char *kwnames[] = {
29883 (char *) "self", NULL
29884 };
29885
29886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
29887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29888 if (SWIG_arg_fail(1)) SWIG_fail;
29889 {
29890 PyThreadState* __tstate = wxPyBeginAllowThreads();
29891 delete arg1;
29892
29893 wxPyEndAllowThreads(__tstate);
29894 if (PyErr_Occurred()) SWIG_fail;
29895 }
29896 Py_INCREF(Py_None); resultobj = Py_None;
29897 return resultobj;
29898 fail:
29899 return NULL;
29900 }
29901
29902
29903 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
29904 PyObject *resultobj;
29905 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29906 bool result;
29907 PyObject * obj0 = 0 ;
29908 char *kwnames[] = {
29909 (char *) "self", NULL
29910 };
29911
29912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
29913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29914 if (SWIG_arg_fail(1)) SWIG_fail;
29915 {
29916 PyThreadState* __tstate = wxPyBeginAllowThreads();
29917 result = (bool)wxClipboardLocker___nonzero__(arg1);
29918
29919 wxPyEndAllowThreads(__tstate);
29920 if (PyErr_Occurred()) SWIG_fail;
29921 }
29922 {
29923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29924 }
29925 return resultobj;
29926 fail:
29927 return NULL;
29928 }
29929
29930
29931 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
29932 PyObject *obj;
29933 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29934 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
29935 Py_INCREF(obj);
29936 return Py_BuildValue((char *)"");
29937 }
29938 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29939 PyObject *resultobj;
29940 int arg1 = (int) 0 ;
29941 int arg2 = (int) 0 ;
29942 int arg3 = (int) 0 ;
29943 int arg4 = (int) 0 ;
29944 wxVideoMode *result;
29945 PyObject * obj0 = 0 ;
29946 PyObject * obj1 = 0 ;
29947 PyObject * obj2 = 0 ;
29948 PyObject * obj3 = 0 ;
29949 char *kwnames[] = {
29950 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
29951 };
29952
29953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29954 if (obj0) {
29955 {
29956 arg1 = (int)(SWIG_As_int(obj0));
29957 if (SWIG_arg_fail(1)) SWIG_fail;
29958 }
29959 }
29960 if (obj1) {
29961 {
29962 arg2 = (int)(SWIG_As_int(obj1));
29963 if (SWIG_arg_fail(2)) SWIG_fail;
29964 }
29965 }
29966 if (obj2) {
29967 {
29968 arg3 = (int)(SWIG_As_int(obj2));
29969 if (SWIG_arg_fail(3)) SWIG_fail;
29970 }
29971 }
29972 if (obj3) {
29973 {
29974 arg4 = (int)(SWIG_As_int(obj3));
29975 if (SWIG_arg_fail(4)) SWIG_fail;
29976 }
29977 }
29978 {
29979 PyThreadState* __tstate = wxPyBeginAllowThreads();
29980 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
29981
29982 wxPyEndAllowThreads(__tstate);
29983 if (PyErr_Occurred()) SWIG_fail;
29984 }
29985 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
29986 return resultobj;
29987 fail:
29988 return NULL;
29989 }
29990
29991
29992 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29993 PyObject *resultobj;
29994 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29995 PyObject * obj0 = 0 ;
29996 char *kwnames[] = {
29997 (char *) "self", NULL
29998 };
29999
30000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30002 if (SWIG_arg_fail(1)) SWIG_fail;
30003 {
30004 PyThreadState* __tstate = wxPyBeginAllowThreads();
30005 delete arg1;
30006
30007 wxPyEndAllowThreads(__tstate);
30008 if (PyErr_Occurred()) SWIG_fail;
30009 }
30010 Py_INCREF(Py_None); resultobj = Py_None;
30011 return resultobj;
30012 fail:
30013 return NULL;
30014 }
30015
30016
30017 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30018 PyObject *resultobj;
30019 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30020 wxVideoMode *arg2 = 0 ;
30021 bool result;
30022 PyObject * obj0 = 0 ;
30023 PyObject * obj1 = 0 ;
30024 char *kwnames[] = {
30025 (char *) "self",(char *) "other", NULL
30026 };
30027
30028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30030 if (SWIG_arg_fail(1)) SWIG_fail;
30031 {
30032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30033 if (SWIG_arg_fail(2)) SWIG_fail;
30034 if (arg2 == NULL) {
30035 SWIG_null_ref("wxVideoMode");
30036 }
30037 if (SWIG_arg_fail(2)) SWIG_fail;
30038 }
30039 {
30040 PyThreadState* __tstate = wxPyBeginAllowThreads();
30041 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30042
30043 wxPyEndAllowThreads(__tstate);
30044 if (PyErr_Occurred()) SWIG_fail;
30045 }
30046 {
30047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30048 }
30049 return resultobj;
30050 fail:
30051 return NULL;
30052 }
30053
30054
30055 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30056 PyObject *resultobj;
30057 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30058 int result;
30059 PyObject * obj0 = 0 ;
30060 char *kwnames[] = {
30061 (char *) "self", NULL
30062 };
30063
30064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30066 if (SWIG_arg_fail(1)) SWIG_fail;
30067 {
30068 PyThreadState* __tstate = wxPyBeginAllowThreads();
30069 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30070
30071 wxPyEndAllowThreads(__tstate);
30072 if (PyErr_Occurred()) SWIG_fail;
30073 }
30074 {
30075 resultobj = SWIG_From_int((int)(result));
30076 }
30077 return resultobj;
30078 fail:
30079 return NULL;
30080 }
30081
30082
30083 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30084 PyObject *resultobj;
30085 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30086 int result;
30087 PyObject * obj0 = 0 ;
30088 char *kwnames[] = {
30089 (char *) "self", NULL
30090 };
30091
30092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30094 if (SWIG_arg_fail(1)) SWIG_fail;
30095 {
30096 PyThreadState* __tstate = wxPyBeginAllowThreads();
30097 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30098
30099 wxPyEndAllowThreads(__tstate);
30100 if (PyErr_Occurred()) SWIG_fail;
30101 }
30102 {
30103 resultobj = SWIG_From_int((int)(result));
30104 }
30105 return resultobj;
30106 fail:
30107 return NULL;
30108 }
30109
30110
30111 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30112 PyObject *resultobj;
30113 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30114 int result;
30115 PyObject * obj0 = 0 ;
30116 char *kwnames[] = {
30117 (char *) "self", NULL
30118 };
30119
30120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30122 if (SWIG_arg_fail(1)) SWIG_fail;
30123 {
30124 PyThreadState* __tstate = wxPyBeginAllowThreads();
30125 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30126
30127 wxPyEndAllowThreads(__tstate);
30128 if (PyErr_Occurred()) SWIG_fail;
30129 }
30130 {
30131 resultobj = SWIG_From_int((int)(result));
30132 }
30133 return resultobj;
30134 fail:
30135 return NULL;
30136 }
30137
30138
30139 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30140 PyObject *resultobj;
30141 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30142 bool result;
30143 PyObject * obj0 = 0 ;
30144 char *kwnames[] = {
30145 (char *) "self", NULL
30146 };
30147
30148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30150 if (SWIG_arg_fail(1)) SWIG_fail;
30151 {
30152 PyThreadState* __tstate = wxPyBeginAllowThreads();
30153 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30154
30155 wxPyEndAllowThreads(__tstate);
30156 if (PyErr_Occurred()) SWIG_fail;
30157 }
30158 {
30159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30160 }
30161 return resultobj;
30162 fail:
30163 return NULL;
30164 }
30165
30166
30167 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30168 PyObject *resultobj;
30169 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30170 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30171 bool result;
30172 PyObject * obj0 = 0 ;
30173 PyObject * obj1 = 0 ;
30174 char *kwnames[] = {
30175 (char *) "self",(char *) "other", NULL
30176 };
30177
30178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30180 if (SWIG_arg_fail(1)) SWIG_fail;
30181 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30182 if (SWIG_arg_fail(2)) SWIG_fail;
30183 {
30184 PyThreadState* __tstate = wxPyBeginAllowThreads();
30185 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30186
30187 wxPyEndAllowThreads(__tstate);
30188 if (PyErr_Occurred()) SWIG_fail;
30189 }
30190 {
30191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30192 }
30193 return resultobj;
30194 fail:
30195 return NULL;
30196 }
30197
30198
30199 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30200 PyObject *resultobj;
30201 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30202 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30203 bool result;
30204 PyObject * obj0 = 0 ;
30205 PyObject * obj1 = 0 ;
30206 char *kwnames[] = {
30207 (char *) "self",(char *) "other", NULL
30208 };
30209
30210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30212 if (SWIG_arg_fail(1)) SWIG_fail;
30213 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30214 if (SWIG_arg_fail(2)) SWIG_fail;
30215 {
30216 PyThreadState* __tstate = wxPyBeginAllowThreads();
30217 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30218
30219 wxPyEndAllowThreads(__tstate);
30220 if (PyErr_Occurred()) SWIG_fail;
30221 }
30222 {
30223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30224 }
30225 return resultobj;
30226 fail:
30227 return NULL;
30228 }
30229
30230
30231 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30232 PyObject *resultobj;
30233 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30234 int arg2 ;
30235 PyObject * obj0 = 0 ;
30236 PyObject * obj1 = 0 ;
30237 char *kwnames[] = {
30238 (char *) "self",(char *) "w", NULL
30239 };
30240
30241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30243 if (SWIG_arg_fail(1)) SWIG_fail;
30244 {
30245 arg2 = (int)(SWIG_As_int(obj1));
30246 if (SWIG_arg_fail(2)) SWIG_fail;
30247 }
30248 if (arg1) (arg1)->w = arg2;
30249
30250 Py_INCREF(Py_None); resultobj = Py_None;
30251 return resultobj;
30252 fail:
30253 return NULL;
30254 }
30255
30256
30257 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30258 PyObject *resultobj;
30259 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30260 int result;
30261 PyObject * obj0 = 0 ;
30262 char *kwnames[] = {
30263 (char *) "self", NULL
30264 };
30265
30266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30268 if (SWIG_arg_fail(1)) SWIG_fail;
30269 result = (int) ((arg1)->w);
30270
30271 {
30272 resultobj = SWIG_From_int((int)(result));
30273 }
30274 return resultobj;
30275 fail:
30276 return NULL;
30277 }
30278
30279
30280 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30281 PyObject *resultobj;
30282 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30283 int arg2 ;
30284 PyObject * obj0 = 0 ;
30285 PyObject * obj1 = 0 ;
30286 char *kwnames[] = {
30287 (char *) "self",(char *) "h", NULL
30288 };
30289
30290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30292 if (SWIG_arg_fail(1)) SWIG_fail;
30293 {
30294 arg2 = (int)(SWIG_As_int(obj1));
30295 if (SWIG_arg_fail(2)) SWIG_fail;
30296 }
30297 if (arg1) (arg1)->h = arg2;
30298
30299 Py_INCREF(Py_None); resultobj = Py_None;
30300 return resultobj;
30301 fail:
30302 return NULL;
30303 }
30304
30305
30306 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30307 PyObject *resultobj;
30308 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30309 int result;
30310 PyObject * obj0 = 0 ;
30311 char *kwnames[] = {
30312 (char *) "self", NULL
30313 };
30314
30315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30317 if (SWIG_arg_fail(1)) SWIG_fail;
30318 result = (int) ((arg1)->h);
30319
30320 {
30321 resultobj = SWIG_From_int((int)(result));
30322 }
30323 return resultobj;
30324 fail:
30325 return NULL;
30326 }
30327
30328
30329 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30330 PyObject *resultobj;
30331 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30332 int arg2 ;
30333 PyObject * obj0 = 0 ;
30334 PyObject * obj1 = 0 ;
30335 char *kwnames[] = {
30336 (char *) "self",(char *) "bpp", NULL
30337 };
30338
30339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30341 if (SWIG_arg_fail(1)) SWIG_fail;
30342 {
30343 arg2 = (int)(SWIG_As_int(obj1));
30344 if (SWIG_arg_fail(2)) SWIG_fail;
30345 }
30346 if (arg1) (arg1)->bpp = arg2;
30347
30348 Py_INCREF(Py_None); resultobj = Py_None;
30349 return resultobj;
30350 fail:
30351 return NULL;
30352 }
30353
30354
30355 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30356 PyObject *resultobj;
30357 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30358 int result;
30359 PyObject * obj0 = 0 ;
30360 char *kwnames[] = {
30361 (char *) "self", NULL
30362 };
30363
30364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30366 if (SWIG_arg_fail(1)) SWIG_fail;
30367 result = (int) ((arg1)->bpp);
30368
30369 {
30370 resultobj = SWIG_From_int((int)(result));
30371 }
30372 return resultobj;
30373 fail:
30374 return NULL;
30375 }
30376
30377
30378 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30379 PyObject *resultobj;
30380 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30381 int arg2 ;
30382 PyObject * obj0 = 0 ;
30383 PyObject * obj1 = 0 ;
30384 char *kwnames[] = {
30385 (char *) "self",(char *) "refresh", NULL
30386 };
30387
30388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30390 if (SWIG_arg_fail(1)) SWIG_fail;
30391 {
30392 arg2 = (int)(SWIG_As_int(obj1));
30393 if (SWIG_arg_fail(2)) SWIG_fail;
30394 }
30395 if (arg1) (arg1)->refresh = arg2;
30396
30397 Py_INCREF(Py_None); resultobj = Py_None;
30398 return resultobj;
30399 fail:
30400 return NULL;
30401 }
30402
30403
30404 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30405 PyObject *resultobj;
30406 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30407 int result;
30408 PyObject * obj0 = 0 ;
30409 char *kwnames[] = {
30410 (char *) "self", NULL
30411 };
30412
30413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30415 if (SWIG_arg_fail(1)) SWIG_fail;
30416 result = (int) ((arg1)->refresh);
30417
30418 {
30419 resultobj = SWIG_From_int((int)(result));
30420 }
30421 return resultobj;
30422 fail:
30423 return NULL;
30424 }
30425
30426
30427 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30428 PyObject *obj;
30429 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30430 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30431 Py_INCREF(obj);
30432 return Py_BuildValue((char *)"");
30433 }
30434 static int _wrap_DefaultVideoMode_set(PyObject *) {
30435 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30436 return 1;
30437 }
30438
30439
30440 static PyObject *_wrap_DefaultVideoMode_get(void) {
30441 PyObject *pyobj;
30442
30443 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30444 return pyobj;
30445 }
30446
30447
30448 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30449 PyObject *resultobj;
30450 size_t arg1 = (size_t) 0 ;
30451 wxDisplay *result;
30452 PyObject * obj0 = 0 ;
30453 char *kwnames[] = {
30454 (char *) "index", NULL
30455 };
30456
30457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30458 if (obj0) {
30459 {
30460 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30461 if (SWIG_arg_fail(1)) SWIG_fail;
30462 }
30463 }
30464 {
30465 PyThreadState* __tstate = wxPyBeginAllowThreads();
30466 result = (wxDisplay *)new wxDisplay(arg1);
30467
30468 wxPyEndAllowThreads(__tstate);
30469 if (PyErr_Occurred()) SWIG_fail;
30470 }
30471 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30472 return resultobj;
30473 fail:
30474 return NULL;
30475 }
30476
30477
30478 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30479 PyObject *resultobj;
30480 wxDisplay *arg1 = (wxDisplay *) 0 ;
30481 PyObject * obj0 = 0 ;
30482 char *kwnames[] = {
30483 (char *) "self", NULL
30484 };
30485
30486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30488 if (SWIG_arg_fail(1)) SWIG_fail;
30489 {
30490 PyThreadState* __tstate = wxPyBeginAllowThreads();
30491 delete arg1;
30492
30493 wxPyEndAllowThreads(__tstate);
30494 if (PyErr_Occurred()) SWIG_fail;
30495 }
30496 Py_INCREF(Py_None); resultobj = Py_None;
30497 return resultobj;
30498 fail:
30499 return NULL;
30500 }
30501
30502
30503 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30504 PyObject *resultobj;
30505 size_t result;
30506 char *kwnames[] = {
30507 NULL
30508 };
30509
30510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30511 {
30512 PyThreadState* __tstate = wxPyBeginAllowThreads();
30513 result = (size_t)wxDisplay::GetCount();
30514
30515 wxPyEndAllowThreads(__tstate);
30516 if (PyErr_Occurred()) SWIG_fail;
30517 }
30518 {
30519 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30520 }
30521 return resultobj;
30522 fail:
30523 return NULL;
30524 }
30525
30526
30527 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30528 PyObject *resultobj;
30529 wxPoint *arg1 = 0 ;
30530 int result;
30531 wxPoint temp1 ;
30532 PyObject * obj0 = 0 ;
30533 char *kwnames[] = {
30534 (char *) "pt", NULL
30535 };
30536
30537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30538 {
30539 arg1 = &temp1;
30540 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30541 }
30542 {
30543 PyThreadState* __tstate = wxPyBeginAllowThreads();
30544 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30545
30546 wxPyEndAllowThreads(__tstate);
30547 if (PyErr_Occurred()) SWIG_fail;
30548 }
30549 {
30550 resultobj = SWIG_From_int((int)(result));
30551 }
30552 return resultobj;
30553 fail:
30554 return NULL;
30555 }
30556
30557
30558 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30559 PyObject *resultobj;
30560 wxWindow *arg1 = (wxWindow *) 0 ;
30561 int result;
30562 PyObject * obj0 = 0 ;
30563 char *kwnames[] = {
30564 (char *) "window", NULL
30565 };
30566
30567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30569 if (SWIG_arg_fail(1)) SWIG_fail;
30570 {
30571 PyThreadState* __tstate = wxPyBeginAllowThreads();
30572 result = (int)Display_GetFromWindow(arg1);
30573
30574 wxPyEndAllowThreads(__tstate);
30575 if (PyErr_Occurred()) SWIG_fail;
30576 }
30577 {
30578 resultobj = SWIG_From_int((int)(result));
30579 }
30580 return resultobj;
30581 fail:
30582 return NULL;
30583 }
30584
30585
30586 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30587 PyObject *resultobj;
30588 wxDisplay *arg1 = (wxDisplay *) 0 ;
30589 bool result;
30590 PyObject * obj0 = 0 ;
30591 char *kwnames[] = {
30592 (char *) "self", NULL
30593 };
30594
30595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30597 if (SWIG_arg_fail(1)) SWIG_fail;
30598 {
30599 PyThreadState* __tstate = wxPyBeginAllowThreads();
30600 result = (bool)((wxDisplay const *)arg1)->IsOk();
30601
30602 wxPyEndAllowThreads(__tstate);
30603 if (PyErr_Occurred()) SWIG_fail;
30604 }
30605 {
30606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30607 }
30608 return resultobj;
30609 fail:
30610 return NULL;
30611 }
30612
30613
30614 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30615 PyObject *resultobj;
30616 wxDisplay *arg1 = (wxDisplay *) 0 ;
30617 wxRect result;
30618 PyObject * obj0 = 0 ;
30619 char *kwnames[] = {
30620 (char *) "self", NULL
30621 };
30622
30623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30625 if (SWIG_arg_fail(1)) SWIG_fail;
30626 {
30627 PyThreadState* __tstate = wxPyBeginAllowThreads();
30628 result = ((wxDisplay const *)arg1)->GetGeometry();
30629
30630 wxPyEndAllowThreads(__tstate);
30631 if (PyErr_Occurred()) SWIG_fail;
30632 }
30633 {
30634 wxRect * resultptr;
30635 resultptr = new wxRect((wxRect &)(result));
30636 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30637 }
30638 return resultobj;
30639 fail:
30640 return NULL;
30641 }
30642
30643
30644 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30645 PyObject *resultobj;
30646 wxDisplay *arg1 = (wxDisplay *) 0 ;
30647 wxString result;
30648 PyObject * obj0 = 0 ;
30649 char *kwnames[] = {
30650 (char *) "self", NULL
30651 };
30652
30653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30655 if (SWIG_arg_fail(1)) SWIG_fail;
30656 {
30657 PyThreadState* __tstate = wxPyBeginAllowThreads();
30658 result = ((wxDisplay const *)arg1)->GetName();
30659
30660 wxPyEndAllowThreads(__tstate);
30661 if (PyErr_Occurred()) SWIG_fail;
30662 }
30663 {
30664 #if wxUSE_UNICODE
30665 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30666 #else
30667 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30668 #endif
30669 }
30670 return resultobj;
30671 fail:
30672 return NULL;
30673 }
30674
30675
30676 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30677 PyObject *resultobj;
30678 wxDisplay *arg1 = (wxDisplay *) 0 ;
30679 bool result;
30680 PyObject * obj0 = 0 ;
30681 char *kwnames[] = {
30682 (char *) "self", NULL
30683 };
30684
30685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30687 if (SWIG_arg_fail(1)) SWIG_fail;
30688 {
30689 PyThreadState* __tstate = wxPyBeginAllowThreads();
30690 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30691
30692 wxPyEndAllowThreads(__tstate);
30693 if (PyErr_Occurred()) SWIG_fail;
30694 }
30695 {
30696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30697 }
30698 return resultobj;
30699 fail:
30700 return NULL;
30701 }
30702
30703
30704 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30705 PyObject *resultobj;
30706 wxDisplay *arg1 = (wxDisplay *) 0 ;
30707 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30708 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30709 PyObject *result;
30710 PyObject * obj0 = 0 ;
30711 PyObject * obj1 = 0 ;
30712 char *kwnames[] = {
30713 (char *) "self",(char *) "mode", NULL
30714 };
30715
30716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30718 if (SWIG_arg_fail(1)) SWIG_fail;
30719 if (obj1) {
30720 {
30721 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30722 if (SWIG_arg_fail(2)) SWIG_fail;
30723 if (arg2 == NULL) {
30724 SWIG_null_ref("wxVideoMode");
30725 }
30726 if (SWIG_arg_fail(2)) SWIG_fail;
30727 }
30728 }
30729 {
30730 PyThreadState* __tstate = wxPyBeginAllowThreads();
30731 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30732
30733 wxPyEndAllowThreads(__tstate);
30734 if (PyErr_Occurred()) SWIG_fail;
30735 }
30736 resultobj = result;
30737 return resultobj;
30738 fail:
30739 return NULL;
30740 }
30741
30742
30743 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30744 PyObject *resultobj;
30745 wxDisplay *arg1 = (wxDisplay *) 0 ;
30746 wxVideoMode result;
30747 PyObject * obj0 = 0 ;
30748 char *kwnames[] = {
30749 (char *) "self", NULL
30750 };
30751
30752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30754 if (SWIG_arg_fail(1)) SWIG_fail;
30755 {
30756 PyThreadState* __tstate = wxPyBeginAllowThreads();
30757 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30758
30759 wxPyEndAllowThreads(__tstate);
30760 if (PyErr_Occurred()) SWIG_fail;
30761 }
30762 {
30763 wxVideoMode * resultptr;
30764 resultptr = new wxVideoMode((wxVideoMode &)(result));
30765 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30766 }
30767 return resultobj;
30768 fail:
30769 return NULL;
30770 }
30771
30772
30773 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30774 PyObject *resultobj;
30775 wxDisplay *arg1 = (wxDisplay *) 0 ;
30776 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30777 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30778 bool result;
30779 PyObject * obj0 = 0 ;
30780 PyObject * obj1 = 0 ;
30781 char *kwnames[] = {
30782 (char *) "self",(char *) "mode", NULL
30783 };
30784
30785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30787 if (SWIG_arg_fail(1)) SWIG_fail;
30788 if (obj1) {
30789 {
30790 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30791 if (SWIG_arg_fail(2)) SWIG_fail;
30792 if (arg2 == NULL) {
30793 SWIG_null_ref("wxVideoMode");
30794 }
30795 if (SWIG_arg_fail(2)) SWIG_fail;
30796 }
30797 }
30798 {
30799 PyThreadState* __tstate = wxPyBeginAllowThreads();
30800 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30801
30802 wxPyEndAllowThreads(__tstate);
30803 if (PyErr_Occurred()) SWIG_fail;
30804 }
30805 {
30806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30807 }
30808 return resultobj;
30809 fail:
30810 return NULL;
30811 }
30812
30813
30814 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30815 PyObject *resultobj;
30816 wxDisplay *arg1 = (wxDisplay *) 0 ;
30817 PyObject * obj0 = 0 ;
30818 char *kwnames[] = {
30819 (char *) "self", NULL
30820 };
30821
30822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30824 if (SWIG_arg_fail(1)) SWIG_fail;
30825 {
30826 PyThreadState* __tstate = wxPyBeginAllowThreads();
30827 (arg1)->ResetMode();
30828
30829 wxPyEndAllowThreads(__tstate);
30830 if (PyErr_Occurred()) SWIG_fail;
30831 }
30832 Py_INCREF(Py_None); resultobj = Py_None;
30833 return resultobj;
30834 fail:
30835 return NULL;
30836 }
30837
30838
30839 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30840 PyObject *obj;
30841 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30842 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
30843 Py_INCREF(obj);
30844 return Py_BuildValue((char *)"");
30845 }
30846 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30847 PyObject *resultobj;
30848 wxStandardPaths *result;
30849 char *kwnames[] = {
30850 NULL
30851 };
30852
30853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
30854 {
30855 PyThreadState* __tstate = wxPyBeginAllowThreads();
30856 result = (wxStandardPaths *)StandardPaths_Get();
30857
30858 wxPyEndAllowThreads(__tstate);
30859 if (PyErr_Occurred()) SWIG_fail;
30860 }
30861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
30862 return resultobj;
30863 fail:
30864 return NULL;
30865 }
30866
30867
30868 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30869 PyObject *resultobj;
30870 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30871 wxString result;
30872 PyObject * obj0 = 0 ;
30873 char *kwnames[] = {
30874 (char *) "self", NULL
30875 };
30876
30877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
30878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30879 if (SWIG_arg_fail(1)) SWIG_fail;
30880 {
30881 PyThreadState* __tstate = wxPyBeginAllowThreads();
30882 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
30883
30884 wxPyEndAllowThreads(__tstate);
30885 if (PyErr_Occurred()) SWIG_fail;
30886 }
30887 {
30888 #if wxUSE_UNICODE
30889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30890 #else
30891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30892 #endif
30893 }
30894 return resultobj;
30895 fail:
30896 return NULL;
30897 }
30898
30899
30900 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30901 PyObject *resultobj;
30902 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30903 wxString result;
30904 PyObject * obj0 = 0 ;
30905 char *kwnames[] = {
30906 (char *) "self", NULL
30907 };
30908
30909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
30910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30911 if (SWIG_arg_fail(1)) SWIG_fail;
30912 {
30913 PyThreadState* __tstate = wxPyBeginAllowThreads();
30914 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
30915
30916 wxPyEndAllowThreads(__tstate);
30917 if (PyErr_Occurred()) SWIG_fail;
30918 }
30919 {
30920 #if wxUSE_UNICODE
30921 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30922 #else
30923 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30924 #endif
30925 }
30926 return resultobj;
30927 fail:
30928 return NULL;
30929 }
30930
30931
30932 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30933 PyObject *resultobj;
30934 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30935 wxString result;
30936 PyObject * obj0 = 0 ;
30937 char *kwnames[] = {
30938 (char *) "self", NULL
30939 };
30940
30941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
30942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30943 if (SWIG_arg_fail(1)) SWIG_fail;
30944 {
30945 PyThreadState* __tstate = wxPyBeginAllowThreads();
30946 result = ((wxStandardPaths const *)arg1)->GetDataDir();
30947
30948 wxPyEndAllowThreads(__tstate);
30949 if (PyErr_Occurred()) SWIG_fail;
30950 }
30951 {
30952 #if wxUSE_UNICODE
30953 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30954 #else
30955 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30956 #endif
30957 }
30958 return resultobj;
30959 fail:
30960 return NULL;
30961 }
30962
30963
30964 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30965 PyObject *resultobj;
30966 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30967 wxString result;
30968 PyObject * obj0 = 0 ;
30969 char *kwnames[] = {
30970 (char *) "self", NULL
30971 };
30972
30973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
30974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30975 if (SWIG_arg_fail(1)) SWIG_fail;
30976 {
30977 PyThreadState* __tstate = wxPyBeginAllowThreads();
30978 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
30979
30980 wxPyEndAllowThreads(__tstate);
30981 if (PyErr_Occurred()) SWIG_fail;
30982 }
30983 {
30984 #if wxUSE_UNICODE
30985 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30986 #else
30987 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30988 #endif
30989 }
30990 return resultobj;
30991 fail:
30992 return NULL;
30993 }
30994
30995
30996 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30997 PyObject *resultobj;
30998 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30999 wxString result;
31000 PyObject * obj0 = 0 ;
31001 char *kwnames[] = {
31002 (char *) "self", NULL
31003 };
31004
31005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31007 if (SWIG_arg_fail(1)) SWIG_fail;
31008 {
31009 PyThreadState* __tstate = wxPyBeginAllowThreads();
31010 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31011
31012 wxPyEndAllowThreads(__tstate);
31013 if (PyErr_Occurred()) SWIG_fail;
31014 }
31015 {
31016 #if wxUSE_UNICODE
31017 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31018 #else
31019 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31020 #endif
31021 }
31022 return resultobj;
31023 fail:
31024 return NULL;
31025 }
31026
31027
31028 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31029 PyObject *resultobj;
31030 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31031 wxString result;
31032 PyObject * obj0 = 0 ;
31033 char *kwnames[] = {
31034 (char *) "self", NULL
31035 };
31036
31037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31039 if (SWIG_arg_fail(1)) SWIG_fail;
31040 {
31041 PyThreadState* __tstate = wxPyBeginAllowThreads();
31042 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31043
31044 wxPyEndAllowThreads(__tstate);
31045 if (PyErr_Occurred()) SWIG_fail;
31046 }
31047 {
31048 #if wxUSE_UNICODE
31049 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31050 #else
31051 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31052 #endif
31053 }
31054 return resultobj;
31055 fail:
31056 return NULL;
31057 }
31058
31059
31060 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31061 PyObject *resultobj;
31062 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31063 wxString result;
31064 PyObject * obj0 = 0 ;
31065 char *kwnames[] = {
31066 (char *) "self", NULL
31067 };
31068
31069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31071 if (SWIG_arg_fail(1)) SWIG_fail;
31072 {
31073 PyThreadState* __tstate = wxPyBeginAllowThreads();
31074 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31075
31076 wxPyEndAllowThreads(__tstate);
31077 if (PyErr_Occurred()) SWIG_fail;
31078 }
31079 {
31080 #if wxUSE_UNICODE
31081 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31082 #else
31083 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31084 #endif
31085 }
31086 return resultobj;
31087 fail:
31088 return NULL;
31089 }
31090
31091
31092 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31093 PyObject *resultobj;
31094 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31095 wxString *arg2 = 0 ;
31096 bool temp2 = false ;
31097 PyObject * obj0 = 0 ;
31098 PyObject * obj1 = 0 ;
31099 char *kwnames[] = {
31100 (char *) "self",(char *) "prefix", NULL
31101 };
31102
31103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31105 if (SWIG_arg_fail(1)) SWIG_fail;
31106 {
31107 arg2 = wxString_in_helper(obj1);
31108 if (arg2 == NULL) SWIG_fail;
31109 temp2 = true;
31110 }
31111 {
31112 PyThreadState* __tstate = wxPyBeginAllowThreads();
31113 (arg1)->SetInstallPrefix((wxString const &)*arg2);
31114
31115 wxPyEndAllowThreads(__tstate);
31116 if (PyErr_Occurred()) SWIG_fail;
31117 }
31118 Py_INCREF(Py_None); resultobj = Py_None;
31119 {
31120 if (temp2)
31121 delete arg2;
31122 }
31123 return resultobj;
31124 fail:
31125 {
31126 if (temp2)
31127 delete arg2;
31128 }
31129 return NULL;
31130 }
31131
31132
31133 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31134 PyObject *resultobj;
31135 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31136 wxString result;
31137 PyObject * obj0 = 0 ;
31138 char *kwnames[] = {
31139 (char *) "self", NULL
31140 };
31141
31142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31144 if (SWIG_arg_fail(1)) SWIG_fail;
31145 {
31146 PyThreadState* __tstate = wxPyBeginAllowThreads();
31147 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
31148
31149 wxPyEndAllowThreads(__tstate);
31150 if (PyErr_Occurred()) SWIG_fail;
31151 }
31152 {
31153 #if wxUSE_UNICODE
31154 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31155 #else
31156 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31157 #endif
31158 }
31159 return resultobj;
31160 fail:
31161 return NULL;
31162 }
31163
31164
31165 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31166 PyObject *obj;
31167 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31168 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31169 Py_INCREF(obj);
31170 return Py_BuildValue((char *)"");
31171 }
31172 static PyMethodDef SwigMethods[] = {
31173 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31174 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31175 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31176 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31177 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31178 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31179 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31180 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31181 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31182 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31183 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31184 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31185 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31186 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31187 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31188 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31189 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31190 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31191 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31192 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31193 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31194 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31195 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31196 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31197 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31198 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31199 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31200 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31201 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31202 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31203 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31204 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31205 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31206 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31207 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31208 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31209 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31210 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31211 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31212 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31213 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31214 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31215 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31216 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31217 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31218 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31219 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31220 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31221 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31222 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31223 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31224 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31225 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31226 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31227 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31228 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31229 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31230 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31231 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31232 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31233 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31234 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31235 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31236 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31237 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31238 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31239 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31240 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31241 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31242 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31243 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31244 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31245 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31246 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31247 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31248 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31249 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31250 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31251 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31252 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31253 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31254 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31255 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31256 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31257 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31258 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31259 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31260 { (char *)"delete_Caret", (PyCFunction) _wrap_delete_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31261 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31262 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31263 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31264 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31265 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31266 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31267 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31268 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31269 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31270 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31271 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31272 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31273 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31274 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31275 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31276 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31277 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31278 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31279 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31280 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31281 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31282 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31283 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31284 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31285 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31286 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31287 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31288 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31289 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31290 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31291 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31292 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31293 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31294 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31295 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31296 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31297 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31298 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31299 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31300 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31301 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31302 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31303 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31304 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31305 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31306 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31307 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31308 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31309 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31310 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31311 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31312 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31313 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31314 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31315 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31316 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31317 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31318 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31319 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31320 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31321 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31322 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31323 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31324 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31325 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31326 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31327 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31328 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31329 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31330 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31331 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31332 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31333 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31335 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31338 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31339 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31342 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31369 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31371 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31373 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31375 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31382 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31388 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31402 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31406 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31409 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31426 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31434 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31481 { (char *)"JoystickEvent_m_pos_set", (PyCFunction) _wrap_JoystickEvent_m_pos_set, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"JoystickEvent_m_pos_get", (PyCFunction) _wrap_JoystickEvent_m_pos_get, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"JoystickEvent_m_zPosition_set", (PyCFunction) _wrap_JoystickEvent_m_zPosition_set, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"JoystickEvent_m_zPosition_get", (PyCFunction) _wrap_JoystickEvent_m_zPosition_get, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"JoystickEvent_m_buttonChange_set", (PyCFunction) _wrap_JoystickEvent_m_buttonChange_set, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"JoystickEvent_m_buttonChange_get", (PyCFunction) _wrap_JoystickEvent_m_buttonChange_get, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"JoystickEvent_m_buttonState_set", (PyCFunction) _wrap_JoystickEvent_m_buttonState_set, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"JoystickEvent_m_buttonState_get", (PyCFunction) _wrap_JoystickEvent_m_buttonState_get, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"JoystickEvent_m_joyStick_set", (PyCFunction) _wrap_JoystickEvent_m_joyStick_set, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"JoystickEvent_m_joyStick_get", (PyCFunction) _wrap_JoystickEvent_m_joyStick_get, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31509 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31519 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31535 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31551 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31565 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31574 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31617 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31620 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31623 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31627 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31720 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31721 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31722 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31723 { (char *)"DateTime___lt__", _wrap_DateTime___lt__, METH_VARARGS, NULL},
31724 { (char *)"DateTime___le__", _wrap_DateTime___le__, METH_VARARGS, NULL},
31725 { (char *)"DateTime___gt__", _wrap_DateTime___gt__, METH_VARARGS, NULL},
31726 { (char *)"DateTime___ge__", _wrap_DateTime___ge__, METH_VARARGS, NULL},
31727 { (char *)"DateTime___eq__", _wrap_DateTime___eq__, METH_VARARGS, NULL},
31728 { (char *)"DateTime___ne__", _wrap_DateTime___ne__, METH_VARARGS, NULL},
31729 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31740 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31785 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31819 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31827 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31828 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31833 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31842 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31849 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
31852 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
31855 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
31860 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
31863 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
31867 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
31870 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
31874 { (char *)"new_CustomDataObject", (PyCFunction) _wrap_new_CustomDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
31879 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
31883 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
31885 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
31895 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
31906 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
31914 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
31922 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
31936 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
31940 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
31958 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
31972 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
31983 { NULL, NULL, 0, NULL }
31984 };
31985
31986
31987 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
31988
31989 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
31990 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
31991 }
31992 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
31993 return (void *)((wxEvent *) ((wxMenuEvent *) x));
31994 }
31995 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
31996 return (void *)((wxEvent *) ((wxCloseEvent *) x));
31997 }
31998 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
31999 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32000 }
32001 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32002 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32003 }
32004 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32005 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32006 }
32007 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32008 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32009 }
32010 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32011 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32012 }
32013 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32014 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32015 }
32016 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32017 return (void *)((wxEvent *) ((wxPyEvent *) x));
32018 }
32019 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32020 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32021 }
32022 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32023 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32024 }
32025 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32026 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32027 }
32028 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32029 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32030 }
32031 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32032 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32033 }
32034 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32035 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32036 }
32037 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32038 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32039 }
32040 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32041 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32042 }
32043 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32044 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32045 }
32046 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32047 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32048 }
32049 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32050 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32051 }
32052 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32053 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32054 }
32055 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32056 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32057 }
32058 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32059 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32060 }
32061 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32062 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32063 }
32064 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32065 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32066 }
32067 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32068 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32069 }
32070 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32071 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32072 }
32073 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32074 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32075 }
32076 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32077 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32078 }
32079 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32080 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32081 }
32082 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32083 return (void *)((wxEvent *) ((wxShowEvent *) x));
32084 }
32085 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32086 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32087 }
32088 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32089 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32090 }
32091 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32092 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32093 }
32094 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32095 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32096 }
32097 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32098 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32099 }
32100 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32101 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32102 }
32103 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32104 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32105 }
32106 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32107 return (void *)((wxConfigBase *) ((wxConfig *) x));
32108 }
32109 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32110 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32111 }
32112 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32113 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32114 }
32115 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32116 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32117 }
32118 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32119 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32120 }
32121 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32122 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32123 }
32124 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32125 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32126 }
32127 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32128 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32129 }
32130 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32131 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32132 }
32133 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32134 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32135 }
32136 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32137 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32138 }
32139 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32140 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32141 }
32142 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32143 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32144 }
32145 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32146 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32147 }
32148 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32149 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32150 }
32151 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32152 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32153 }
32154 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32155 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32156 }
32157 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32158 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32159 }
32160 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32161 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32162 }
32163 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32164 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32165 }
32166 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32167 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32168 }
32169 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32170 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32171 }
32172 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32173 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32174 }
32175 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32176 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32177 }
32178 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32179 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32180 }
32181 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32182 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32183 }
32184 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32185 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32186 }
32187 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32188 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32189 }
32190 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32191 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32192 }
32193 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32194 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32195 }
32196 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32197 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32198 }
32199 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32200 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32201 }
32202 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32203 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32204 }
32205 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32206 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32207 }
32208 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32209 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32210 }
32211 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32212 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32213 }
32214 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32215 return (void *)((wxObject *) ((wxSizerItem *) x));
32216 }
32217 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32218 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32219 }
32220 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32221 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32222 }
32223 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32224 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32225 }
32226 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32227 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32228 }
32229 static void *_p_wxSizerTo_p_wxObject(void *x) {
32230 return (void *)((wxObject *) ((wxSizer *) x));
32231 }
32232 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32233 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32234 }
32235 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32236 return (void *)((wxObject *) ((wxFileHistory *) x));
32237 }
32238 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32239 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32240 }
32241 static void *_p_wxEventTo_p_wxObject(void *x) {
32242 return (void *)((wxObject *) ((wxEvent *) x));
32243 }
32244 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32245 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32246 }
32247 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32248 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32249 }
32250 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32251 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32252 }
32253 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32254 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32255 }
32256 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32257 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32258 }
32259 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32260 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32261 }
32262 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32263 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32264 }
32265 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32266 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32267 }
32268 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32269 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32270 }
32271 static void *_p_wxControlTo_p_wxObject(void *x) {
32272 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32273 }
32274 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32275 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32276 }
32277 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32278 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32279 }
32280 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32281 return (void *)((wxObject *) ((wxFSFile *) x));
32282 }
32283 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32284 return (void *)((wxObject *) ((wxClipboard *) x));
32285 }
32286 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32287 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32288 }
32289 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32290 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32291 }
32292 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32293 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32294 }
32295 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32296 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32297 }
32298 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32299 return (void *)((wxObject *) ((wxToolTip *) x));
32300 }
32301 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32302 return (void *)((wxObject *) ((wxMenuItem *) x));
32303 }
32304 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32305 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32306 }
32307 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32308 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32309 }
32310 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32311 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32312 }
32313 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32314 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32315 }
32316 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32317 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32318 }
32319 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32320 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32321 }
32322 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32323 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32324 }
32325 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32326 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32327 }
32328 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32329 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32330 }
32331 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32332 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32333 }
32334 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32335 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32336 }
32337 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32338 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32339 }
32340 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32341 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32342 }
32343 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32344 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32345 }
32346 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32347 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32348 }
32349 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32350 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32351 }
32352 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32353 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32354 }
32355 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32356 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32357 }
32358 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32359 return (void *)((wxObject *) ((wxImageHandler *) x));
32360 }
32361 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32362 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32363 }
32364 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32365 return (void *)((wxObject *) ((wxEvtHandler *) x));
32366 }
32367 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32368 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32369 }
32370 static void *_p_wxImageTo_p_wxObject(void *x) {
32371 return (void *)((wxObject *) ((wxImage *) x));
32372 }
32373 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32374 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32375 }
32376 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32377 return (void *)((wxObject *) ((wxSystemOptions *) x));
32378 }
32379 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32380 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32381 }
32382 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32383 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32384 }
32385 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32386 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32387 }
32388 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32389 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32390 }
32391 static void *_p_wxWindowTo_p_wxObject(void *x) {
32392 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32393 }
32394 static void *_p_wxMenuTo_p_wxObject(void *x) {
32395 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32396 }
32397 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32398 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32399 }
32400 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32401 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32402 }
32403 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32404 return (void *)((wxObject *) ((wxFileSystem *) x));
32405 }
32406 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32407 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32408 }
32409 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32410 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32411 }
32412 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32413 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32414 }
32415 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32416 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32417 }
32418 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32419 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32420 }
32421 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32422 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32423 }
32424 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32425 return (void *)((wxObject *) ((wxBusyInfo *) x));
32426 }
32427 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32428 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32429 }
32430 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32431 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32432 }
32433 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32434 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32435 }
32436 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32437 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32438 }
32439 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32440 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32441 }
32442 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32443 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32444 }
32445 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32446 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32447 }
32448 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32449 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32450 }
32451 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32452 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32453 }
32454 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32455 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32456 }
32457 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32458 return (void *)((wxLog *) ((wxLogStderr *) x));
32459 }
32460 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32461 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32462 }
32463 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32464 return (void *)((wxLog *) ((wxLogWindow *) x));
32465 }
32466 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32467 return (void *)((wxLog *) ((wxLogChain *) x));
32468 }
32469 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32470 return (void *)((wxLog *) ((wxLogGui *) x));
32471 }
32472 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32473 return (void *)((wxLog *) ((wxPyLog *) x));
32474 }
32475 static void *_p_wxControlTo_p_wxWindow(void *x) {
32476 return (void *)((wxWindow *) ((wxControl *) x));
32477 }
32478 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32479 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32480 }
32481 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32482 return (void *)((wxWindow *) ((wxMenuBar *) x));
32483 }
32484 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32485 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32486 }
32487 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32488 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32489 }
32490 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}};
32491 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}};
32492 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}};
32493 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}};
32494 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}};
32495 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}};
32496 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}};
32497 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}};
32498 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}};
32499 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}};
32500 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}};
32501 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}};
32502 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}};
32503 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}};
32504 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}};
32505 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}};
32506 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}};
32507 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}};
32508 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}};
32509 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}};
32510 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}};
32511 static swig_type_info _swigt__p_wxDC[] = {{"_p_wxDC", 0, "wxDC *", 0, 0, 0, 0},{"_p_wxDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32512 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}};
32513 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}};
32514 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}};
32515 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}};
32516 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}};
32517 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}};
32518 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}};
32519 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}};
32520 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}};
32521 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}};
32522 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}};
32523 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}};
32524 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}};
32525 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}};
32526 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}};
32527 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}};
32528 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}};
32529 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}};
32530 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}};
32531 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}};
32532 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}};
32533 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}};
32534 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}};
32535 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}};
32536 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}};
32537 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}};
32538 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}};
32539 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}};
32540 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}};
32541 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}};
32542 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}};
32543 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}};
32544 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}};
32545 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}};
32546 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}};
32547 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}};
32548 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}};
32549 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}};
32550 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}};
32551 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}};
32552 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}};
32553 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}};
32554 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}};
32555 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}};
32556 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}};
32557 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}};
32558 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}};
32559 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}};
32560 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_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}};
32561 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}};
32562 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}};
32563 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}};
32564 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}};
32565 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}};
32566 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}};
32567 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}};
32568 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}};
32569 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}};
32570 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}};
32571 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}};
32572 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}};
32573 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}};
32574 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}};
32575 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}};
32576 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}};
32577 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}};
32578 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}};
32579 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}};
32580 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}};
32581 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}};
32582 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}};
32583 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}};
32584 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}};
32585 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}};
32586
32587 static swig_type_info *swig_types_initial[] = {
32588 _swigt__p_wxLogChain,
32589 _swigt__p_wxMutexGuiLocker,
32590 _swigt__p_wxFileHistory,
32591 _swigt__p_wxLog,
32592 _swigt__p_wxMenu,
32593 _swigt__p_wxEvent,
32594 _swigt__p_wxDateTime__TimeZone,
32595 _swigt__p_wxConfigBase,
32596 _swigt__p_wxDisplay,
32597 _swigt__p_wxFileType,
32598 _swigt__p_wxLogGui,
32599 _swigt__p_wxFont,
32600 _swigt__p_wxDataFormat,
32601 _swigt__p_wxTimerEvent,
32602 _swigt__p_wxCaret,
32603 _swigt__ptrdiff_t,
32604 _swigt__std__ptrdiff_t,
32605 _swigt__p_int,
32606 _swigt__p_wxSize,
32607 _swigt__p_wxClipboard,
32608 _swigt__p_wxStopWatch,
32609 _swigt__p_wxDC,
32610 _swigt__p_wxClipboardLocker,
32611 _swigt__p_wxIcon,
32612 _swigt__p_wxLogStderr,
32613 _swigt__p_wxLogTextCtrl,
32614 _swigt__p_wxTextCtrl,
32615 _swigt__p_wxBusyCursor,
32616 _swigt__p_wxBitmapDataObject,
32617 _swigt__p_wxTextDataObject,
32618 _swigt__p_wxDataObject,
32619 _swigt__p_wxPyTextDataObject,
32620 _swigt__p_wxPyBitmapDataObject,
32621 _swigt__p_wxFileDataObject,
32622 _swigt__p_wxCustomDataObject,
32623 _swigt__p_wxURLDataObject,
32624 _swigt__p_wxMetafileDataObject,
32625 _swigt__p_wxSound,
32626 _swigt__p_wxTimerRunner,
32627 _swigt__p_wxLogWindow,
32628 _swigt__p_wxTimeSpan,
32629 _swigt__p_wxArrayString,
32630 _swigt__p_wxWindowDisabler,
32631 _swigt__p_form_ops_t,
32632 _swigt__p_wxToolTip,
32633 _swigt__p_wxDataObjectComposite,
32634 _swigt__p_wxSystemSettings,
32635 _swigt__p_wxFileConfig,
32636 _swigt__p_wxVideoMode,
32637 _swigt__p_wxDataObjectSimple,
32638 _swigt__p_wxPyDataObjectSimple,
32639 _swigt__p_wxDuplexMode,
32640 _swigt__p_wxEvtHandler,
32641 _swigt__p_wxRect,
32642 _swigt__p_char,
32643 _swigt__p_wxSingleInstanceChecker,
32644 _swigt__p_wxStandardPaths,
32645 _swigt__p_wxFileTypeInfo,
32646 _swigt__p_wxFrame,
32647 _swigt__p_wxTimer,
32648 _swigt__p_wxPaperSize,
32649 _swigt__p_wxMimeTypesManager,
32650 _swigt__p_wxPyArtProvider,
32651 _swigt__p_wxPyTipProvider,
32652 _swigt__p_wxTipProvider,
32653 _swigt__p_wxJoystick,
32654 _swigt__p_wxSystemOptions,
32655 _swigt__p_wxPoint,
32656 _swigt__p_wxJoystickEvent,
32657 _swigt__p_wxCursor,
32658 _swigt__p_wxObject,
32659 _swigt__p_wxOutputStream,
32660 _swigt__p_wxDateTime,
32661 _swigt__p_wxPyDropSource,
32662 _swigt__p_unsigned_long,
32663 _swigt__p_wxKillError,
32664 _swigt__p_wxWindow,
32665 _swigt__p_wxString,
32666 _swigt__p_wxPyProcess,
32667 _swigt__p_wxBitmap,
32668 _swigt__p_wxConfig,
32669 _swigt__unsigned_int,
32670 _swigt__p_unsigned_int,
32671 _swigt__p_unsigned_char,
32672 _swigt__p_wxChar,
32673 _swigt__p_wxBusyInfo,
32674 _swigt__p_wxPyDropTarget,
32675 _swigt__p_wxPyTextDropTarget,
32676 _swigt__p_wxPyFileDropTarget,
32677 _swigt__p_wxProcessEvent,
32678 _swigt__p_wxPyLog,
32679 _swigt__p_wxLogNull,
32680 _swigt__p_wxColour,
32681 _swigt__p_wxPyTimer,
32682 _swigt__p_wxConfigPathChanger,
32683 _swigt__p_wxDateSpan,
32684 0
32685 };
32686
32687
32688 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32689
32690 static swig_const_info swig_const_table[] = {
32691 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32692 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32693 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32694 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32695 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32696 {0, 0, 0, 0.0, 0, 0}};
32697
32698 #ifdef __cplusplus
32699 }
32700 #endif
32701
32702
32703 #ifdef __cplusplus
32704 extern "C" {
32705 #endif
32706
32707 /* Python-specific SWIG API */
32708 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32709 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32710 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32711
32712 /* -----------------------------------------------------------------------------
32713 * global variable support code.
32714 * ----------------------------------------------------------------------------- */
32715
32716 typedef struct swig_globalvar {
32717 char *name; /* Name of global variable */
32718 PyObject *(*get_attr)(); /* Return the current value */
32719 int (*set_attr)(PyObject *); /* Set the value */
32720 struct swig_globalvar *next;
32721 } swig_globalvar;
32722
32723 typedef struct swig_varlinkobject {
32724 PyObject_HEAD
32725 swig_globalvar *vars;
32726 } swig_varlinkobject;
32727
32728 static PyObject *
32729 swig_varlink_repr(swig_varlinkobject *v) {
32730 v = v;
32731 return PyString_FromString("<Swig global variables>");
32732 }
32733
32734 static int
32735 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32736 swig_globalvar *var;
32737 flags = flags;
32738 fprintf(fp,"Swig global variables { ");
32739 for (var = v->vars; var; var=var->next) {
32740 fprintf(fp,"%s", var->name);
32741 if (var->next) fprintf(fp,", ");
32742 }
32743 fprintf(fp," }\n");
32744 return 0;
32745 }
32746
32747 static PyObject *
32748 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32749 swig_globalvar *var = v->vars;
32750 while (var) {
32751 if (strcmp(var->name,n) == 0) {
32752 return (*var->get_attr)();
32753 }
32754 var = var->next;
32755 }
32756 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32757 return NULL;
32758 }
32759
32760 static int
32761 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32762 swig_globalvar *var = v->vars;
32763 while (var) {
32764 if (strcmp(var->name,n) == 0) {
32765 return (*var->set_attr)(p);
32766 }
32767 var = var->next;
32768 }
32769 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32770 return 1;
32771 }
32772
32773 static PyTypeObject varlinktype = {
32774 PyObject_HEAD_INIT(0)
32775 0, /* Number of items in variable part (ob_size) */
32776 (char *)"swigvarlink", /* Type name (tp_name) */
32777 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32778 0, /* Itemsize (tp_itemsize) */
32779 0, /* Deallocator (tp_dealloc) */
32780 (printfunc) swig_varlink_print, /* Print (tp_print) */
32781 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32782 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32783 0, /* tp_compare */
32784 (reprfunc) swig_varlink_repr, /* tp_repr */
32785 0, /* tp_as_number */
32786 0, /* tp_as_sequence */
32787 0, /* tp_as_mapping */
32788 0, /* tp_hash */
32789 0, /* tp_call */
32790 0, /* tp_str */
32791 0, /* tp_getattro */
32792 0, /* tp_setattro */
32793 0, /* tp_as_buffer */
32794 0, /* tp_flags */
32795 0, /* tp_doc */
32796 #if PY_VERSION_HEX >= 0x02000000
32797 0, /* tp_traverse */
32798 0, /* tp_clear */
32799 #endif
32800 #if PY_VERSION_HEX >= 0x02010000
32801 0, /* tp_richcompare */
32802 0, /* tp_weaklistoffset */
32803 #endif
32804 #if PY_VERSION_HEX >= 0x02020000
32805 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32806 #endif
32807 #if PY_VERSION_HEX >= 0x02030000
32808 0, /* tp_del */
32809 #endif
32810 #ifdef COUNT_ALLOCS
32811 0,0,0,0 /* tp_alloc -> tp_next */
32812 #endif
32813 };
32814
32815 /* Create a variable linking object for use later */
32816 static PyObject *
32817 SWIG_Python_newvarlink(void) {
32818 swig_varlinkobject *result = 0;
32819 result = PyMem_NEW(swig_varlinkobject,1);
32820 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32821 result->ob_type = &varlinktype;
32822 result->vars = 0;
32823 result->ob_refcnt = 0;
32824 Py_XINCREF((PyObject *) result);
32825 return ((PyObject*) result);
32826 }
32827
32828 static void
32829 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32830 swig_varlinkobject *v;
32831 swig_globalvar *gv;
32832 v= (swig_varlinkobject *) p;
32833 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32834 gv->name = (char *) malloc(strlen(name)+1);
32835 strcpy(gv->name,name);
32836 gv->get_attr = get_attr;
32837 gv->set_attr = set_attr;
32838 gv->next = v->vars;
32839 v->vars = gv;
32840 }
32841
32842 /* -----------------------------------------------------------------------------
32843 * constants/methods manipulation
32844 * ----------------------------------------------------------------------------- */
32845
32846 /* Install Constants */
32847 static void
32848 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32849 PyObject *obj = 0;
32850 size_t i;
32851 for (i = 0; constants[i].type; i++) {
32852 switch(constants[i].type) {
32853 case SWIG_PY_INT:
32854 obj = PyInt_FromLong(constants[i].lvalue);
32855 break;
32856 case SWIG_PY_FLOAT:
32857 obj = PyFloat_FromDouble(constants[i].dvalue);
32858 break;
32859 case SWIG_PY_STRING:
32860 if (constants[i].pvalue) {
32861 obj = PyString_FromString((char *) constants[i].pvalue);
32862 } else {
32863 Py_INCREF(Py_None);
32864 obj = Py_None;
32865 }
32866 break;
32867 case SWIG_PY_POINTER:
32868 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32869 break;
32870 case SWIG_PY_BINARY:
32871 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32872 break;
32873 default:
32874 obj = 0;
32875 break;
32876 }
32877 if (obj) {
32878 PyDict_SetItemString(d,constants[i].name,obj);
32879 Py_DECREF(obj);
32880 }
32881 }
32882 }
32883
32884 /* -----------------------------------------------------------------------------*/
32885 /* Fix SwigMethods to carry the callback ptrs when needed */
32886 /* -----------------------------------------------------------------------------*/
32887
32888 static void
32889 SWIG_Python_FixMethods(PyMethodDef *methods,
32890 swig_const_info *const_table,
32891 swig_type_info **types,
32892 swig_type_info **types_initial) {
32893 size_t i;
32894 for (i = 0; methods[i].ml_name; ++i) {
32895 char *c = methods[i].ml_doc;
32896 if (c && (c = strstr(c, "swig_ptr: "))) {
32897 int j;
32898 swig_const_info *ci = 0;
32899 char *name = c + 10;
32900 for (j = 0; const_table[j].type; j++) {
32901 if (strncmp(const_table[j].name, name,
32902 strlen(const_table[j].name)) == 0) {
32903 ci = &(const_table[j]);
32904 break;
32905 }
32906 }
32907 if (ci) {
32908 size_t shift = (ci->ptype) - types;
32909 swig_type_info *ty = types_initial[shift];
32910 size_t ldoc = (c - methods[i].ml_doc);
32911 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32912 char *ndoc = (char*)malloc(ldoc + lptr + 10);
32913 char *buff = ndoc;
32914 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
32915 strncpy(buff, methods[i].ml_doc, ldoc);
32916 buff += ldoc;
32917 strncpy(buff, "swig_ptr: ", 10);
32918 buff += 10;
32919 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32920 methods[i].ml_doc = ndoc;
32921 }
32922 }
32923 }
32924 }
32925
32926 /* -----------------------------------------------------------------------------*
32927 * Initialize type list
32928 * -----------------------------------------------------------------------------*/
32929
32930 #if PY_MAJOR_VERSION < 2
32931 /* PyModule_AddObject function was introduced in Python 2.0. The following function
32932 is copied out of Python/modsupport.c in python version 2.3.4 */
32933 static int
32934 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
32935 {
32936 PyObject *dict;
32937 if (!PyModule_Check(m)) {
32938 PyErr_SetString(PyExc_TypeError,
32939 "PyModule_AddObject() needs module as first arg");
32940 return -1;
32941 }
32942 if (!o) {
32943 PyErr_SetString(PyExc_TypeError,
32944 "PyModule_AddObject() needs non-NULL value");
32945 return -1;
32946 }
32947
32948 dict = PyModule_GetDict(m);
32949 if (dict == NULL) {
32950 /* Internal error -- modules must have a dict! */
32951 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
32952 PyModule_GetName(m));
32953 return -1;
32954 }
32955 if (PyDict_SetItemString(dict, name, o))
32956 return -1;
32957 Py_DECREF(o);
32958 return 0;
32959 }
32960 #endif
32961
32962 static swig_type_info **
32963 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
32964 static PyMethodDef swig_empty_runtime_method_table[] = {
32965 {
32966 NULL, NULL, 0, NULL
32967 }
32968 };/* Sentinel */
32969
32970 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
32971 swig_empty_runtime_method_table);
32972 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
32973 if (pointer && module) {
32974 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
32975 }
32976 return type_list_handle;
32977 }
32978
32979 static swig_type_info **
32980 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
32981 swig_type_info **type_pointer;
32982
32983 /* first check if module already created */
32984 type_pointer = SWIG_Python_GetTypeListHandle();
32985 if (type_pointer) {
32986 return type_pointer;
32987 } else {
32988 /* create a new module and variable */
32989 return SWIG_Python_SetTypeListHandle(type_list_handle);
32990 }
32991 }
32992
32993 #ifdef __cplusplus
32994 }
32995 #endif
32996
32997 /* -----------------------------------------------------------------------------*
32998 * Partial Init method
32999 * -----------------------------------------------------------------------------*/
33000
33001 #ifdef SWIG_LINK_RUNTIME
33002 #ifdef __cplusplus
33003 extern "C"
33004 #endif
33005 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33006 #endif
33007
33008 #ifdef __cplusplus
33009 extern "C"
33010 #endif
33011 SWIGEXPORT(void) SWIG_init(void) {
33012 static PyObject *SWIG_globals = 0;
33013 static int typeinit = 0;
33014 PyObject *m, *d;
33015 int i;
33016 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33017
33018 /* Fix SwigMethods to carry the callback ptrs when needed */
33019 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33020
33021 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33022 d = PyModule_GetDict(m);
33023
33024 if (!typeinit) {
33025 #ifdef SWIG_LINK_RUNTIME
33026 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33027 #else
33028 # ifndef SWIG_STATIC_RUNTIME
33029 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33030 # endif
33031 #endif
33032 for (i = 0; swig_types_initial[i]; i++) {
33033 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33034 }
33035 typeinit = 1;
33036 }
33037 SWIG_InstallConstants(d,swig_const_table);
33038
33039 {
33040 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33041 }
33042 {
33043 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33044 }
33045 {
33046 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33047 }
33048 {
33049 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33050 }
33051 {
33052 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33053 }
33054 {
33055 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33056 }
33057 {
33058 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33059 }
33060 {
33061 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33062 }
33063 {
33064 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33065 }
33066 {
33067 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33068 }
33069 {
33070 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33071 }
33072 {
33073 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33074 }
33075 {
33076 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33077 }
33078 {
33079 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33080 }
33081 {
33082 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33083 }
33084 {
33085 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33086 }
33087 {
33088 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33089 }
33090 {
33091 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33092 }
33093 {
33094 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33095 }
33096 {
33097 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33098 }
33099 {
33100 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33101 }
33102 {
33103 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33104 }
33105 {
33106 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33107 }
33108 {
33109 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33110 }
33111 {
33112 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33113 }
33114 {
33115 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33116 }
33117 {
33118 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33119 }
33120 {
33121 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33122 }
33123 {
33124 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33125 }
33126 {
33127 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33128 }
33129 {
33130 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33131 }
33132 {
33133 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33134 }
33135 {
33136 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33137 }
33138 {
33139 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33140 }
33141 {
33142 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33143 }
33144 {
33145 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33146 }
33147 {
33148 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33149 }
33150 {
33151 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33152 }
33153 {
33154 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33155 }
33156 {
33157 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33158 }
33159 {
33160 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33161 }
33162 {
33163 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33164 }
33165 {
33166 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33167 }
33168 {
33169 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33170 }
33171 {
33172 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33173 }
33174 {
33175 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33176 }
33177 {
33178 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33179 }
33180 {
33181 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33182 }
33183 {
33184 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33185 }
33186 {
33187 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33188 }
33189 {
33190 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33191 }
33192 {
33193 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33194 }
33195 {
33196 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33197 }
33198 {
33199 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33200 }
33201 {
33202 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33203 }
33204 {
33205 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33206 }
33207 {
33208 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33209 }
33210 {
33211 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33212 }
33213 {
33214 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33215 }
33216 {
33217 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33218 }
33219 {
33220 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33221 }
33222 {
33223 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33224 }
33225 {
33226 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33227 }
33228 {
33229 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33230 }
33231 {
33232 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33233 }
33234 {
33235 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33236 }
33237 {
33238 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33239 }
33240 {
33241 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33242 }
33243 {
33244 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33245 }
33246 {
33247 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33248 }
33249 {
33250 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33251 }
33252 {
33253 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33254 }
33255 {
33256 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33257 }
33258 {
33259 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33260 }
33261 {
33262 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33263 }
33264 {
33265 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33266 }
33267 {
33268 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33269 }
33270 {
33271 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33272 }
33273 {
33274 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33275 }
33276 {
33277 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33278 }
33279 {
33280 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33281 }
33282 {
33283 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33284 }
33285 {
33286 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33287 }
33288 {
33289 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33290 }
33291 {
33292 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33293 }
33294 {
33295 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33296 }
33297 {
33298 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33299 }
33300 {
33301 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33302 }
33303 {
33304 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33305 }
33306 {
33307 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33308 }
33309 {
33310 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33311 }
33312 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33313 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33314 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33315 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33316 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33317 {
33318 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33319 }
33320 {
33321 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33322 }
33323 {
33324 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33325 }
33326 {
33327 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33328 }
33329 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33330
33331 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33332
33333 {
33334 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33335 }
33336 {
33337 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33338 }
33339 {
33340 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33341 }
33342 {
33343 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33344 }
33345 {
33346 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33347 }
33348 {
33349 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33350 }
33351 {
33352 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33353 }
33354 {
33355 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33356 }
33357 {
33358 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33359 }
33360 {
33361 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33362 }
33363 {
33364 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33365 }
33366 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33367 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33368 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33369 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33370 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33371 {
33372 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33373 }
33374 {
33375 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33376 }
33377 {
33378 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33379 }
33380 {
33381 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33382 }
33383 {
33384 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33385 }
33386 {
33387 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33388 }
33389 {
33390 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33391 }
33392 {
33393 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33394 }
33395 {
33396 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33397 }
33398 {
33399 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33400 }
33401 {
33402 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33403 }
33404 {
33405 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33406 }
33407 {
33408 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33409 }
33410 {
33411 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33412 }
33413 {
33414 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33415 }
33416 {
33417 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33418 }
33419 {
33420 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33421 }
33422 {
33423 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33424 }
33425 {
33426 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33427 }
33428 {
33429 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33430 }
33431 {
33432 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33433 }
33434 {
33435 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33436 }
33437 {
33438 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33439 }
33440 {
33441 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33442 }
33443 {
33444 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33445 }
33446 {
33447 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33448 }
33449 {
33450 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33463 }
33464 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33465 {
33466 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33467 }
33468 {
33469 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33470 }
33471 {
33472 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33473 }
33474 {
33475 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33476 }
33477 {
33478 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33479 }
33480
33481 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33482
33483 {
33484 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33485 }
33486 {
33487 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33488 }
33489 {
33490 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33491 }
33492 {
33493 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33494 }
33495 {
33496 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33497 }
33498 {
33499 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33500 }
33501 {
33502 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33503 }
33504 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33505 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33506 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33507 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33508 {
33509 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33510 }
33511 {
33512 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33513 }
33514 {
33515 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33516 }
33517 {
33518 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33519 }
33520 {
33521 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33522 }
33523 {
33524 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33525 }
33526 {
33527 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33528 }
33529 {
33530 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33531 }
33532 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33533 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33534 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33535 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33536 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33537 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33538 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33539 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33540 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33541 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33542 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33543 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33544 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33545 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33546 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33547 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33548 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33549 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33550 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33551 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33552 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33553 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33554 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33555 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33556 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33557 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33558 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33559 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33560 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33561 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33562 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33563 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33564 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33565 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33566 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33567 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33568 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33569 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33570 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33571 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33572 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33573 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33574 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33575 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33576 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33577
33578 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33579
33580 {
33581 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33582 }
33583 {
33584 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33585 }
33586 {
33587 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33588 }
33589 {
33590 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33591 }
33592 {
33593 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33594 }
33595 {
33596 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33597 }
33598 {
33599 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33600 }
33601 {
33602 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33603 }
33604 {
33605 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33606 }
33607 SWIG_addvarlink(SWIG_globals,(char*)"DateFormatStr",_wrap_DateFormatStr_get, _wrap_DateFormatStr_set);
33608 SWIG_addvarlink(SWIG_globals,(char*)"TimeSpanFormatStr",_wrap_TimeSpanFormatStr_get, _wrap_TimeSpanFormatStr_set);
33609 {
33610 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33611 }
33612 {
33613 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33614 }
33615 {
33616 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33617 }
33618 {
33619 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33620 }
33621 {
33622 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33623 }
33624 {
33625 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33626 }
33627 {
33628 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33629 }
33630 {
33631 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33632 }
33633 {
33634 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33635 }
33636 {
33637 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33638 }
33639 {
33640 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33641 }
33642 {
33643 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33644 }
33645 {
33646 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33647 }
33648 {
33649 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33650 }
33651 {
33652 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33653 }
33654 {
33655 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33656 }
33657 {
33658 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33659 }
33660 {
33661 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33662 }
33663 {
33664 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33665 }
33666 {
33667 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33668 }
33669 {
33670 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33671 }
33672 {
33673 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33674 }
33675 {
33676 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33677 }
33678 {
33679 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33680 }
33681 {
33682 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33683 }
33684 {
33685 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33686 }
33687 {
33688 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33689 }
33690 {
33691 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33692 }
33693 {
33694 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33695 }
33696 {
33697 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33698 }
33699 {
33700 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33701 }
33702 {
33703 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33704 }
33705 {
33706 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33707 }
33708 {
33709 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33710 }
33711 {
33712 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33713 }
33714 {
33715 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33716 }
33717 {
33718 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33719 }
33720 {
33721 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33722 }
33723 {
33724 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33725 }
33726 {
33727 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33728 }
33729 {
33730 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33731 }
33732 {
33733 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33734 }
33735 {
33736 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33737 }
33738 {
33739 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33740 }
33741 {
33742 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33743 }
33744 {
33745 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33746 }
33747 {
33748 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33749 }
33750 {
33751 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33752 }
33753 {
33754 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33755 }
33756 {
33757 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33758 }
33759 {
33760 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33761 }
33762 {
33763 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33764 }
33765 {
33766 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33767 }
33768 {
33769 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33770 }
33771 {
33772 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33773 }
33774 {
33775 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33776 }
33777 {
33778 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33779 }
33780 {
33781 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33782 }
33783 {
33784 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33785 }
33786 {
33787 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33788 }
33789 {
33790 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33791 }
33792 {
33793 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33794 }
33795 {
33796 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33797 }
33798 {
33799 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33800 }
33801 {
33802 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33803 }
33804 {
33805 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33812 }
33813 {
33814 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33815 }
33816 {
33817 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33818 }
33819 {
33820 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33821 }
33822 {
33823 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33824 }
33825 {
33826 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33827 }
33828 {
33829 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
33830 }
33831 {
33832 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
33833 }
33834 {
33835 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
33836 }
33837 {
33838 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
33839 }
33840 {
33841 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
33842 }
33843 {
33844 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
33845 }
33846 {
33847 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
33851 }
33852 {
33853 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
33854 }
33855 {
33856 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
33857 }
33858 {
33859 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
33860 }
33861 {
33862 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
33863 }
33864 {
33865 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
33866 }
33867 {
33868 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
33869 }
33870 {
33871 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
33872 }
33873 {
33874 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
33875 }
33876 {
33877 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
33878 }
33879 {
33880 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
33881 }
33882 {
33883 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
33884 }
33885 {
33886 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
33887 }
33888 {
33889 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
33890 }
33891 {
33892 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
33893 }
33894 {
33895 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
33896 }
33897 {
33898 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
33899 }
33900 {
33901 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
33902 }
33903 {
33904 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
33905 }
33906 {
33907 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
33908 }
33909 {
33910 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
33911 }
33912 {
33913 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
33914 }
33915 {
33916 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
33917 }
33918 {
33919 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
33920 }
33921 {
33922 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
33923 }
33924 {
33925 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
33926 }
33927 {
33928 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
33929 }
33930 {
33931 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
33932 }
33933 {
33934 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
33935 }
33936 {
33937 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
33938 }
33939 {
33940 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
33941 }
33942 {
33943 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
33944 }
33945 {
33946 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
33947 }
33948 {
33949 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
33950 }
33951 {
33952 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
33953 }
33954 {
33955 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
33956 }
33957 {
33958 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
33959 }
33960 {
33961 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
33962 }
33963 {
33964 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
33965 }
33966 {
33967 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
33968 }
33969 {
33970 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
33971 }
33972 {
33973 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
33974 }
33975 {
33976 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
33977 }
33978 {
33979 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
33980 }
33981 {
33982 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
33983 }
33984 {
33985 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
33986 }
33987 {
33988 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
33989 }
33990 {
33991 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
33992 }
33993 {
33994 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
33995 }
33996 {
33997 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
33998 }
33999 {
34000 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34001 }
34002 {
34003 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34004 }
34005 {
34006 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34007 }
34008 {
34009 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34010 }
34011 {
34012 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34013 }
34014 {
34015 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34016 }
34017 {
34018 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34019 }
34020 {
34021 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34022 }
34023 {
34024 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34025 }
34026 {
34027 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34028 }
34029 {
34030 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34031 }
34032 {
34033 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34034 }
34035 {
34036 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34037 }
34038 {
34039 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34040 }
34041 {
34042 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34043 }
34044 {
34045 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34046 }
34047 {
34048 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34049 }
34050 {
34051 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34052 }
34053 {
34054 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34055 }
34056 {
34057 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34058 }
34059 {
34060 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34061 }
34062 {
34063 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34064 }
34065 {
34066 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34067 }
34068 {
34069 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34070 }
34071 {
34072 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34073 }
34074 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34075 {
34076 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34077 }
34078 {
34079 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34080 }
34081 {
34082 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34083 }
34084 {
34085 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34086 }
34087 {
34088 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34089 }
34090 {
34091 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34092 }
34093 {
34094 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34095 }
34096 {
34097 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34098 }
34099 {
34100 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34101 }
34102 {
34103 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34104 }
34105 {
34106 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34107 }
34108 {
34109 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34110 }
34111 {
34112 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34113 }
34114 {
34115 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34116 }
34117 {
34118 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34119 }
34120 {
34121 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34122 }
34123 {
34124 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34125 }
34126 {
34127 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34128 }
34129 {
34130 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34131 }
34132 {
34133 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34134 }
34135 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34136 {
34137 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34138 }
34139 {
34140 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34141 }
34142 {
34143 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34144 }
34145 {
34146 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34147 }
34148 {
34149 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34150 }
34151 {
34152 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34153 }
34154 {
34155 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34156 }
34157 {
34158 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34159 }
34160 {
34161 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34162 }
34163 {
34164 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34165 }
34166 {
34167 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34168 }
34169 {
34170 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34171 }
34172
34173 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34174 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34175 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34176 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34177
34178 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34179 }
34180
wxWidgets (Impactor)