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


17ee753f42f88e38c92e93c67cae3bf21b3311f8
[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 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLogChain swig_types[0]
1343 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1344 #define SWIGTYPE_p_wxFileHistory swig_types[2]
1345 #define SWIGTYPE_p_wxLog swig_types[3]
1346 #define SWIGTYPE_p_wxMenu swig_types[4]
1347 #define SWIGTYPE_p_wxEvent swig_types[5]
1348 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[6]
1349 #define SWIGTYPE_p_wxConfigBase swig_types[7]
1350 #define SWIGTYPE_p_wxDisplay swig_types[8]
1351 #define SWIGTYPE_p_wxFileType swig_types[9]
1352 #define SWIGTYPE_p_wxLogGui swig_types[10]
1353 #define SWIGTYPE_p_wxFont swig_types[11]
1354 #define SWIGTYPE_p_wxDataFormat swig_types[12]
1355 #define SWIGTYPE_p_wxTimerEvent swig_types[13]
1356 #define SWIGTYPE_p_wxCaret swig_types[14]
1357 #define SWIGTYPE_ptrdiff_t swig_types[15]
1358 #define SWIGTYPE_std__ptrdiff_t swig_types[16]
1359 #define SWIGTYPE_p_void swig_types[17]
1360 #define SWIGTYPE_p_int swig_types[18]
1361 #define SWIGTYPE_p_wxSize swig_types[19]
1362 #define SWIGTYPE_p_wxClipboard swig_types[20]
1363 #define SWIGTYPE_p_wxStopWatch swig_types[21]
1364 #define SWIGTYPE_p_wxDC swig_types[22]
1365 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
1366 #define SWIGTYPE_p_wxIcon swig_types[24]
1367 #define SWIGTYPE_p_wxLogStderr swig_types[25]
1368 #define SWIGTYPE_p_wxLogTextCtrl swig_types[26]
1369 #define SWIGTYPE_p_wxTextCtrl swig_types[27]
1370 #define SWIGTYPE_p_wxBusyCursor swig_types[28]
1371 #define SWIGTYPE_p_wxBitmapDataObject swig_types[29]
1372 #define SWIGTYPE_p_wxTextDataObject swig_types[30]
1373 #define SWIGTYPE_p_wxDataObject swig_types[31]
1374 #define SWIGTYPE_p_wxPyTextDataObject swig_types[32]
1375 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[33]
1376 #define SWIGTYPE_p_wxFileDataObject swig_types[34]
1377 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
1378 #define SWIGTYPE_p_wxURLDataObject swig_types[36]
1379 #define SWIGTYPE_p_wxMetafileDataObject swig_types[37]
1380 #define SWIGTYPE_p_wxSound swig_types[38]
1381 #define SWIGTYPE_p_wxTimerRunner swig_types[39]
1382 #define SWIGTYPE_p_wxLogWindow swig_types[40]
1383 #define SWIGTYPE_p_wxTimeSpan swig_types[41]
1384 #define SWIGTYPE_p_wxArrayString swig_types[42]
1385 #define SWIGTYPE_p_wxWindowDisabler swig_types[43]
1386 #define SWIGTYPE_p_form_ops_t swig_types[44]
1387 #define SWIGTYPE_p_wxToolTip swig_types[45]
1388 #define SWIGTYPE_p_wxDataObjectComposite swig_types[46]
1389 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1390 #define SWIGTYPE_p_wxFileConfig swig_types[48]
1391 #define SWIGTYPE_p_wxVideoMode swig_types[49]
1392 #define SWIGTYPE_p_wxDataObjectSimple swig_types[50]
1393 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[51]
1394 #define SWIGTYPE_p_wxDuplexMode swig_types[52]
1395 #define SWIGTYPE_p_wxEvtHandler swig_types[53]
1396 #define SWIGTYPE_p_wxRect swig_types[54]
1397 #define SWIGTYPE_p_char swig_types[55]
1398 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[56]
1399 #define SWIGTYPE_p_wxStandardPaths swig_types[57]
1400 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
1401 #define SWIGTYPE_p_wxFrame swig_types[59]
1402 #define SWIGTYPE_p_wxTimer swig_types[60]
1403 #define SWIGTYPE_p_wxPaperSize swig_types[61]
1404 #define SWIGTYPE_p_wxMimeTypesManager swig_types[62]
1405 #define SWIGTYPE_p_wxPyArtProvider swig_types[63]
1406 #define SWIGTYPE_p_wxPyTipProvider swig_types[64]
1407 #define SWIGTYPE_p_wxTipProvider swig_types[65]
1408 #define SWIGTYPE_p_wxJoystick swig_types[66]
1409 #define SWIGTYPE_p_wxSystemOptions swig_types[67]
1410 #define SWIGTYPE_p_wxPoint swig_types[68]
1411 #define SWIGTYPE_p_wxJoystickEvent swig_types[69]
1412 #define SWIGTYPE_p_wxCursor swig_types[70]
1413 #define SWIGTYPE_p_wxObject swig_types[71]
1414 #define SWIGTYPE_p_wxOutputStream swig_types[72]
1415 #define SWIGTYPE_p_wxDateTime swig_types[73]
1416 #define SWIGTYPE_p_wxPyDropSource swig_types[74]
1417 #define SWIGTYPE_p_unsigned_long swig_types[75]
1418 #define SWIGTYPE_p_wxLogBuffer swig_types[76]
1419 #define SWIGTYPE_p_wxKillError swig_types[77]
1420 #define SWIGTYPE_p_wxWindow swig_types[78]
1421 #define SWIGTYPE_p_wxString swig_types[79]
1422 #define SWIGTYPE_p_wxPyProcess swig_types[80]
1423 #define SWIGTYPE_p_wxBitmap swig_types[81]
1424 #define SWIGTYPE_unsigned_int swig_types[82]
1425 #define SWIGTYPE_p_unsigned_int swig_types[83]
1426 #define SWIGTYPE_p_wxConfig swig_types[84]
1427 #define SWIGTYPE_p_unsigned_char swig_types[85]
1428 #define SWIGTYPE_p_wxChar swig_types[86]
1429 #define SWIGTYPE_p_wxBusyInfo swig_types[87]
1430 #define SWIGTYPE_p_wxPyDropTarget swig_types[88]
1431 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[89]
1432 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[90]
1433 #define SWIGTYPE_p_wxProcessEvent swig_types[91]
1434 #define SWIGTYPE_p_wxPyLog swig_types[92]
1435 #define SWIGTYPE_p_wxLogNull swig_types[93]
1436 #define SWIGTYPE_p_wxColour swig_types[94]
1437 #define SWIGTYPE_p_wxPyTimer swig_types[95]
1438 #define SWIGTYPE_p_wxConfigPathChanger swig_types[96]
1439 #define SWIGTYPE_p_wxDateSpan swig_types[97]
1440 static swig_type_info *swig_types[99];
1441
1442 /* -------- TYPES TABLE (END) -------- */
1443
1444
1445 /*-----------------------------------------------
1446 @(target):= _misc_.so
1447 ------------------------------------------------*/
1448 #define SWIG_init init_misc_
1449
1450 #define SWIG_name "_misc_"
1451
1452 #include "wx/wxPython/wxPython.h"
1453 #include "wx/wxPython/pyclasses.h"
1454 #include "wx/wxPython/pyistream.h"
1455
1456 static const wxString wxPyEmptyString(wxEmptyString);
1457
1458
1459
1460 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1461 #define SWIG_From_int PyInt_FromLong
1462 /*@@*/
1463
1464
1465 #include <limits.h>
1466
1467
1468 SWIGINTERN int
1469 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1470 const char *errmsg)
1471 {
1472 if (value < min_value) {
1473 if (errmsg) {
1474 PyErr_Format(PyExc_OverflowError,
1475 "value %ld is less than '%s' minimum %ld",
1476 value, errmsg, min_value);
1477 }
1478 return 0;
1479 } else if (value > max_value) {
1480 if (errmsg) {
1481 PyErr_Format(PyExc_OverflowError,
1482 "value %ld is greater than '%s' maximum %ld",
1483 value, errmsg, max_value);
1484 }
1485 return 0;
1486 }
1487 return 1;
1488 }
1489
1490
1491 SWIGINTERN int
1492 SWIG_AsVal_long(PyObject* obj, long* val)
1493 {
1494 if (PyNumber_Check(obj)) {
1495 if (val) *val = PyInt_AsLong(obj);
1496 return 1;
1497 }
1498 else {
1499 SWIG_type_error("number", obj);
1500 }
1501 return 0;
1502 }
1503
1504
1505 #if INT_MAX != LONG_MAX
1506 SWIGINTERN int
1507 SWIG_AsVal_int(PyObject *obj, int *val)
1508 {
1509 const char* errmsg = val ? "int" : (char*)0;
1510 long v;
1511 if (SWIG_AsVal_long(obj, &v)) {
1512 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1513 if (val) *val = (int)(v);
1514 return 1;
1515 } else {
1516 return 0;
1517 }
1518 } else {
1519 PyErr_Clear();
1520 }
1521 if (val) {
1522 SWIG_type_error(errmsg, obj);
1523 }
1524 return 0;
1525 }
1526 #else
1527 SWIGINTERNSHORT int
1528 SWIG_AsVal_int(PyObject *obj, int *val)
1529 {
1530 return SWIG_AsVal_long(obj,(long*)val);
1531 }
1532 #endif
1533
1534
1535 SWIGINTERNSHORT int
1536 SWIG_As_int(PyObject* obj)
1537 {
1538 int v;
1539 if (!SWIG_AsVal_int(obj, &v)) {
1540 /*
1541 this is needed to make valgrind/purify happier.
1542 */
1543 memset((void*)&v, 0, sizeof(int));
1544 }
1545 return v;
1546 }
1547
1548
1549 SWIGINTERNSHORT int
1550 SWIG_Check_int(PyObject* obj)
1551 {
1552 return SWIG_AsVal_int(obj, (int*)0);
1553 }
1554
1555 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1556
1557 #include <wx/stockitem.h>
1558
1559 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1560 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1561 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1562
1563 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1564 #define SWIG_From_long PyInt_FromLong
1565 /*@@*/
1566
1567
1568 SWIGINTERNSHORT long
1569 SWIG_As_long(PyObject* obj)
1570 {
1571 long v;
1572 if (!SWIG_AsVal_long(obj, &v)) {
1573 /*
1574 this is needed to make valgrind/purify happier.
1575 */
1576 memset((void*)&v, 0, sizeof(long));
1577 }
1578 return v;
1579 }
1580
1581
1582 SWIGINTERNSHORT int
1583 SWIG_Check_long(PyObject* obj)
1584 {
1585 return SWIG_AsVal_long(obj, (long*)0);
1586 }
1587
1588
1589 SWIGINTERN int
1590 SWIG_AsVal_bool(PyObject *obj, bool *val)
1591 {
1592 if (obj == Py_True) {
1593 if (val) *val = true;
1594 return 1;
1595 }
1596 if (obj == Py_False) {
1597 if (val) *val = false;
1598 return 1;
1599 }
1600 int res = 0;
1601 if (SWIG_AsVal_int(obj, &res)) {
1602 if (val) *val = res ? true : false;
1603 return 1;
1604 } else {
1605 PyErr_Clear();
1606 }
1607 if (val) {
1608 SWIG_type_error("bool", obj);
1609 }
1610 return 0;
1611 }
1612
1613
1614 SWIGINTERNSHORT bool
1615 SWIG_As_bool(PyObject* obj)
1616 {
1617 bool v;
1618 if (!SWIG_AsVal_bool(obj, &v)) {
1619 /*
1620 this is needed to make valgrind/purify happier.
1621 */
1622 memset((void*)&v, 0, sizeof(bool));
1623 }
1624 return v;
1625 }
1626
1627
1628 SWIGINTERNSHORT int
1629 SWIG_Check_bool(PyObject* obj)
1630 {
1631 return SWIG_AsVal_bool(obj, (bool*)0);
1632 }
1633
1634
1635 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1636 PyObject* o2;
1637 PyObject* o3;
1638
1639 if (!target) {
1640 target = o;
1641 } else if (target == Py_None) {
1642 Py_DECREF(Py_None);
1643 target = o;
1644 } else {
1645 if (!PyTuple_Check(target)) {
1646 o2 = target;
1647 target = PyTuple_New(1);
1648 PyTuple_SetItem(target, 0, o2);
1649 }
1650 o3 = PyTuple_New(1);
1651 PyTuple_SetItem(o3, 0, o);
1652
1653 o2 = target;
1654 target = PySequence_Concat(o2, o3);
1655 Py_DECREF(o2);
1656 Py_DECREF(o3);
1657 }
1658 return target;
1659 }
1660
1661
1662
1663 long wxGetFreeMemory()
1664 { wxPyRaiseNotImplemented(); return 0; }
1665
1666
1667 SWIGINTERN int
1668 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1669 {
1670 long v = 0;
1671 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1672 SWIG_type_error("unsigned number", obj);
1673 }
1674 else if (val)
1675 *val = (unsigned long)v;
1676 return 1;
1677 }
1678
1679
1680 SWIGINTERNSHORT unsigned long
1681 SWIG_As_unsigned_SS_long(PyObject* obj)
1682 {
1683 unsigned long v;
1684 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1685 /*
1686 this is needed to make valgrind/purify happier.
1687 */
1688 memset((void*)&v, 0, sizeof(unsigned long));
1689 }
1690 return v;
1691 }
1692
1693
1694 SWIGINTERNSHORT int
1695 SWIG_Check_unsigned_SS_long(PyObject* obj)
1696 {
1697 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1698 }
1699
1700
1701 SWIGINTERNSHORT PyObject*
1702 SWIG_From_unsigned_SS_long(unsigned long value)
1703 {
1704 return (value > LONG_MAX) ?
1705 PyLong_FromUnsignedLong(value)
1706 : PyInt_FromLong((long)(value));
1707 }
1708
1709
1710 void* wxGetXDisplay()
1711 {
1712 #ifdef __WXGTK__
1713 return wxGetDisplay();
1714 #else
1715 return NULL;
1716 #endif
1717 }
1718
1719
1720 void wxWakeUpMainThread() {}
1721
1722
1723 bool wxThread_IsMain() {
1724 #ifdef WXP_WITH_THREAD
1725 return wxThread::IsMain();
1726 #else
1727 return true;
1728 #endif
1729 }
1730
1731 static void wxCaret_Destroy(wxCaret *self){
1732 delete self;
1733 }
1734
1735 #include <wx/snglinst.h>
1736
1737
1738 #ifdef __WXMSW__
1739 #include <wx/msw/private.h>
1740 #include <wx/dynload.h>
1741 #endif
1742
1743
1744
1745 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1746 #if 0
1747 , int method
1748 #endif
1749 )
1750 {
1751 #ifdef __WXMSW__
1752 #if 0
1753 switch (method)
1754 {
1755 case 1:
1756 // This one only partially works. Appears to be an undocumented
1757 // "standard" convention that not all widgets adhear to. For
1758 // example, for some widgets backgrounds or non-client areas may
1759 // not be painted.
1760 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1761 break;
1762
1763 case 2:
1764 #endif
1765 // This one works much better, nearly all widgets and their
1766 // children are captured correctly[**]. Prior to the big
1767 // background erase changes that Vadim did in 2004-2005 this
1768 // method failed badly on XP with Themes activated, most native
1769 // widgets draw only partially, if at all. Without themes it
1770 // worked just like on Win2k. After those changes this method
1771 // works very well.
1772 //
1773 // ** For example the radio buttons in a wxRadioBox are not its
1774 // children by default, but you can capture it via the panel
1775 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1776 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1777 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1778 PRF_ERASEBKGND | PRF_OWNED );
1779 return true;
1780 #if 0
1781 break;
1782
1783 case 3:
1784 // This one is only defined in the latest SDK and is only
1785 // available on XP. MSDN says it is similar to sending WM_PRINT
1786 // so I expect that it will work similar to the above. Since it
1787 // is avaialble only on XP, it can't be compiled like this and
1788 // will have to be loaded dynamically.
1789 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1790
1791 // fall through
1792
1793 case 4:
1794 // Use PrintWindow if available, or fallback to WM_PRINT
1795 // otherwise. Unfortunately using PrintWindow is even worse than
1796 // WM_PRINT. For most native widgets nothing is drawn to the dc
1797 // at all, with or without Themes.
1798 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1799 static bool s_triedToLoad = false;
1800 static PrintWindow_t pfnPrintWindow = NULL;
1801 if ( !s_triedToLoad )
1802 {
1803
1804 s_triedToLoad = true;
1805 wxDynamicLibrary dllUser32(_T("user32.dll"));
1806 if ( dllUser32.IsLoaded() )
1807 {
1808 wxLogNull nolog; // Don't report errors here
1809 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1810 }
1811 }
1812 if (pfnPrintWindow)
1813 {
1814 //printf("Using PrintWindow\n");
1815 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1816 }
1817 else
1818 {
1819 //printf("Using WM_PRINT\n");
1820 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1821 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1822 PRF_ERASEBKGND | PRF_OWNED );
1823 }
1824 }
1825 #endif // 0
1826 #else
1827 return false;
1828 #endif // __WXMSW__
1829 }
1830
1831
1832
1833 #include <wx/tipdlg.h>
1834
1835
1836 class wxPyTipProvider : public wxTipProvider {
1837 public:
1838 wxPyTipProvider(size_t currentTip)
1839 : wxTipProvider(currentTip) {}
1840
1841 DEC_PYCALLBACK_STRING__pure(GetTip);
1842 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1843 PYPRIVATE;
1844 };
1845
1846 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1847 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1848
1849
1850 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1851
1852 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1853
1854 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1855 : wxTimer(owner, id)
1856 {
1857 if (owner == NULL) SetOwner(this);
1858 }
1859
1860
1861 void wxPyTimer::Notify() {
1862 bool found;
1863 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1864 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1865 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1866 wxPyEndBlockThreads(blocked);
1867 if (! found)
1868 wxTimer::Notify();
1869 }
1870 void wxPyTimer::base_Notify() {
1871 wxTimer::Notify();
1872 }
1873
1874
1875
1876 SWIGINTERN PyObject *
1877 SWIG_FromCharPtr(const char* cptr)
1878 {
1879 if (cptr) {
1880 size_t size = strlen(cptr);
1881 if (size > INT_MAX) {
1882 return SWIG_NewPointerObj((char*)(cptr),
1883 SWIG_TypeQuery("char *"), 0);
1884 } else {
1885 if (size != 0) {
1886 return PyString_FromStringAndSize(cptr, size);
1887 } else {
1888 return PyString_FromString(cptr);
1889 }
1890 }
1891 }
1892 Py_INCREF(Py_None);
1893 return Py_None;
1894 }
1895
1896
1897 SWIGINTERNSHORT int
1898 SWIG_CheckUnsignedLongInRange(unsigned long value,
1899 unsigned long max_value,
1900 const char *errmsg)
1901 {
1902 if (value > max_value) {
1903 if (errmsg) {
1904 PyErr_Format(PyExc_OverflowError,
1905 "value %lu is greater than '%s' minimum %lu",
1906 value, errmsg, max_value);
1907 }
1908 return 0;
1909 }
1910 return 1;
1911 }
1912
1913
1914 #if UINT_MAX != ULONG_MAX
1915 SWIGINTERN int
1916 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1917 {
1918 const char* errmsg = val ? "unsigned int" : (char*)0;
1919 unsigned long v;
1920 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1921 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1922 if (val) *val = (unsigned int)(v);
1923 return 1;
1924 }
1925 } else {
1926 PyErr_Clear();
1927 }
1928 if (val) {
1929 SWIG_type_error(errmsg, obj);
1930 }
1931 return 0;
1932 }
1933 #else
1934 SWIGINTERNSHORT unsigned int
1935 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1936 {
1937 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1938 }
1939 #endif
1940
1941
1942 SWIGINTERNSHORT unsigned int
1943 SWIG_As_unsigned_SS_int(PyObject* obj)
1944 {
1945 unsigned int v;
1946 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1947 /*
1948 this is needed to make valgrind/purify happier.
1949 */
1950 memset((void*)&v, 0, sizeof(unsigned int));
1951 }
1952 return v;
1953 }
1954
1955
1956 SWIGINTERNSHORT int
1957 SWIG_Check_unsigned_SS_int(PyObject* obj)
1958 {
1959 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1960 }
1961
1962 static wxString Log_TimeStamp(){
1963 wxString msg;
1964 wxLog::TimeStamp(&msg);
1965 return msg;
1966 }
1967 static void wxLog_Destroy(wxLog *self){ delete self; }
1968 // Make somce wrappers that double any % signs so they are 'escaped'
1969 void wxPyLogFatalError(const wxString& msg)
1970 {
1971 wxString m(msg);
1972 m.Replace(wxT("%"), wxT("%%"));
1973 wxLogFatalError(m);
1974 }
1975
1976 void wxPyLogError(const wxString& msg)
1977 {
1978 wxString m(msg);
1979 m.Replace(wxT("%"), wxT("%%"));
1980 wxLogError(m);
1981 }
1982
1983 void wxPyLogWarning(const wxString& msg)
1984 {
1985 wxString m(msg);
1986 m.Replace(wxT("%"), wxT("%%"));
1987 wxLogWarning(m);
1988 }
1989
1990 void wxPyLogMessage(const wxString& msg)
1991 {
1992 wxString m(msg);
1993 m.Replace(wxT("%"), wxT("%%"));
1994 wxLogMessage(m);
1995 }
1996
1997 void wxPyLogInfo(const wxString& msg)
1998 {
1999 wxString m(msg);
2000 m.Replace(wxT("%"), wxT("%%"));
2001 wxLogInfo(m);
2002 }
2003
2004 void wxPyLogDebug(const wxString& msg)
2005 {
2006 wxString m(msg);
2007 m.Replace(wxT("%"), wxT("%%"));
2008 wxLogDebug(m);
2009 }
2010
2011 void wxPyLogVerbose(const wxString& msg)
2012 {
2013 wxString m(msg);
2014 m.Replace(wxT("%"), wxT("%%"));
2015 wxLogVerbose(m);
2016 }
2017
2018 void wxPyLogStatus(const wxString& msg)
2019 {
2020 wxString m(msg);
2021 m.Replace(wxT("%"), wxT("%%"));
2022 wxLogStatus(m);
2023 }
2024
2025 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2026 {
2027 wxString m(msg);
2028 m.Replace(wxT("%"), wxT("%%"));
2029 wxLogStatus(pFrame, m);
2030 }
2031
2032 void wxPyLogSysError(const wxString& msg)
2033 {
2034 wxString m(msg);
2035 m.Replace(wxT("%"), wxT("%%"));
2036 wxLogSysError(m);
2037 }
2038
2039 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2040 {
2041 wxString m(msg);
2042 m.Replace(wxT("%"), wxT("%%"));
2043 wxLogGeneric(level, m);
2044 }
2045
2046 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2047 {
2048 wxString m(msg);
2049 m.Replace(wxT("%"), wxT("%%"));
2050 wxLogTrace(mask, m);
2051 }
2052
2053 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2054 {
2055 wxString m(msg);
2056 m.Replace(wxT("%"), wxT("%%"));
2057 wxLogTrace(mask, m);
2058 }
2059
2060
2061
2062 // A wxLog class that can be derived from in wxPython
2063 class wxPyLog : public wxLog {
2064 public:
2065 wxPyLog() : wxLog() {}
2066
2067 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2068 bool found;
2069 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2070 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2071 PyObject* s = wx2PyString(szString);
2072 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2073 Py_DECREF(s);
2074 }
2075 wxPyEndBlockThreads(blocked);
2076 if (! found)
2077 wxLog::DoLog(level, szString, t);
2078 }
2079
2080 virtual void DoLogString(const wxChar *szString, time_t t) {
2081 bool found;
2082 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2083 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2084 PyObject* s = wx2PyString(szString);
2085 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2086 Py_DECREF(s);
2087 }
2088 wxPyEndBlockThreads(blocked);
2089 if (! found)
2090 wxLog::DoLogString(szString, t);
2091 }
2092
2093 PYPRIVATE;
2094 };
2095
2096
2097
2098
2099 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2100
2101
2102 #include <wx/joystick.h>
2103
2104
2105 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2106 // A C++ stub class for wxJoystick for platforms that don't have it.
2107 class wxJoystick : public wxObject {
2108 public:
2109 wxJoystick(int joystick = wxJOYSTICK1) {
2110 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2111 PyErr_SetString(PyExc_NotImplementedError,
2112 "wxJoystick is not available on this platform.");
2113 wxPyEndBlockThreads(blocked);
2114 }
2115 wxPoint GetPosition() { return wxPoint(-1,-1); }
2116 int GetZPosition() { return -1; }
2117 int GetButtonState() { return -1; }
2118 int GetPOVPosition() { return -1; }
2119 int GetPOVCTSPosition() { return -1; }
2120 int GetRudderPosition() { return -1; }
2121 int GetUPosition() { return -1; }
2122 int GetVPosition() { return -1; }
2123 int GetMovementThreshold() { return -1; }
2124 void SetMovementThreshold(int threshold) {}
2125
2126 bool IsOk(void) { return false; }
2127 int GetNumberJoysticks() { return -1; }
2128 int GetManufacturerId() { return -1; }
2129 int GetProductId() { return -1; }
2130 wxString GetProductName() { return wxEmptyString; }
2131 int GetXMin() { return -1; }
2132 int GetYMin() { return -1; }
2133 int GetZMin() { return -1; }
2134 int GetXMax() { return -1; }
2135 int GetYMax() { return -1; }
2136 int GetZMax() { return -1; }
2137 int GetNumberButtons() { return -1; }
2138 int GetNumberAxes() { return -1; }
2139 int GetMaxButtons() { return -1; }
2140 int GetMaxAxes() { return -1; }
2141 int GetPollingMin() { return -1; }
2142 int GetPollingMax() { return -1; }
2143 int GetRudderMin() { return -1; }
2144 int GetRudderMax() { return -1; }
2145 int GetUMin() { return -1; }
2146 int GetUMax() { return -1; }
2147 int GetVMin() { return -1; }
2148 int GetVMax() { return -1; }
2149
2150 bool HasRudder() { return false; }
2151 bool HasZ() { return false; }
2152 bool HasU() { return false; }
2153 bool HasV() { return false; }
2154 bool HasPOV() { return false; }
2155 bool HasPOV4Dir() { return false; }
2156 bool HasPOVCTS() { return false; }
2157
2158 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2159 bool ReleaseCapture() { return false; }
2160 };
2161 #endif
2162
2163
2164 #include <wx/sound.h>
2165
2166
2167 #if !wxUSE_SOUND
2168 // A C++ stub class for wxWave for platforms that don't have it.
2169 class wxSound : public wxObject
2170 {
2171 public:
2172 wxSound() {
2173 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2174 PyErr_SetString(PyExc_NotImplementedError,
2175 "wxSound is not available on this platform.");
2176 wxPyEndBlockThreads(blocked);
2177 }
2178 wxSound(const wxString&/*, bool*/) {
2179 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2180 PyErr_SetString(PyExc_NotImplementedError,
2181 "wxSound is not available on this platform.");
2182 wxPyEndBlockThreads(blocked);
2183 }
2184 wxSound(int, const wxByte*) {
2185 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2186 PyErr_SetString(PyExc_NotImplementedError,
2187 "wxSound is not available on this platform.");
2188 wxPyEndBlockThreads(blocked);
2189 }
2190
2191 ~wxSound() {};
2192
2193 bool Create(const wxString&/*, bool*/) { return false; }
2194 bool Create(int, const wxByte*) { return false; };
2195 bool IsOk() { return false; };
2196 bool Play(unsigned) const { return false; }
2197 static bool Play(const wxString&, unsigned) { return false; }
2198 static void Stop() {}
2199 };
2200
2201 #endif
2202
2203 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2204 if (fileName.Length() == 0)
2205 return new wxSound;
2206 else
2207 return new wxSound(fileName);
2208 }
2209 static wxSound *new_wxSound(PyObject *data){
2210 unsigned char* buffer; int size;
2211 wxSound *sound = NULL;
2212
2213 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2214 if (!PyArg_Parse(data, "t#", &buffer, &size))
2215 goto done;
2216 sound = new wxSound(size, buffer);
2217 done:
2218 wxPyEndBlockThreads(blocked);
2219 return sound;
2220 }
2221 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2222 #ifndef __WXMAC__
2223 unsigned char* buffer;
2224 int size;
2225 bool rv = false;
2226
2227 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2228 if (!PyArg_Parse(data, "t#", &buffer, &size))
2229 goto done;
2230 rv = self->Create(size, buffer);
2231 done:
2232 wxPyEndBlockThreads(blocked);
2233 return rv;
2234 #else
2235 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2236 PyErr_SetString(PyExc_NotImplementedError,
2237 "Create from data is not available on this platform.");
2238 wxPyEndBlockThreads(blocked);
2239 return false;
2240 #endif
2241 }
2242
2243 #include <wx/mimetype.h>
2244
2245 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2246 wxString str;
2247 if (self->GetMimeType(&str))
2248 return wx2PyString(str);
2249 else
2250 RETURN_NONE();
2251 }
2252 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2253 wxArrayString arr;
2254 if (self->GetMimeTypes(arr))
2255 return wxArrayString2PyList_helper(arr);
2256 else
2257 RETURN_NONE();
2258 }
2259 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2260 wxArrayString arr;
2261 if (self->GetExtensions(arr))
2262 return wxArrayString2PyList_helper(arr);
2263 else
2264 RETURN_NONE();
2265 }
2266 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2267 wxIconLocation loc;
2268 if (self->GetIcon(&loc))
2269 return new wxIcon(loc);
2270 else
2271 return NULL;
2272 }
2273 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2274 wxIconLocation loc;
2275 if (self->GetIcon(&loc)) {
2276 wxString iconFile = loc.GetFileName();
2277 int iconIndex = -1;
2278
2279
2280
2281 // Make a tuple and put the values in it
2282 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2283 PyObject* tuple = PyTuple_New(3);
2284 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2285 wxT("wxIcon"), true));
2286 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2287 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2288 wxPyEndBlockThreads(blocked);
2289 return tuple;
2290 }
2291 else
2292 RETURN_NONE();
2293 }
2294 static PyObject *wxFileType_GetDescription(wxFileType *self){
2295 wxString str;
2296 if (self->GetDescription(&str))
2297 return wx2PyString(str);
2298 else
2299 RETURN_NONE();
2300 }
2301 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2302 wxString str;
2303 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2304 return wx2PyString(str);
2305 else
2306 RETURN_NONE();
2307 }
2308 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2309 wxString str;
2310 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2311 return wx2PyString(str);
2312 else
2313 RETURN_NONE();
2314 }
2315 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2316 wxArrayString verbs;
2317 wxArrayString commands;
2318 if (self->GetAllCommands(&verbs, &commands,
2319 wxFileType::MessageParameters(filename, mimetype))) {
2320 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2321 PyObject* tuple = PyTuple_New(2);
2322 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2323 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2324 wxPyEndBlockThreads(blocked);
2325 return tuple;
2326 }
2327 else
2328 RETURN_NONE();
2329 }
2330 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2331 return wxFileType::ExpandCommand(command,
2332 wxFileType::MessageParameters(filename, mimetype));
2333 }
2334 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2335 wxArrayString arr;
2336 self->EnumAllFileTypes(arr);
2337 return wxArrayString2PyList_helper(arr);
2338 }
2339
2340 #include <wx/artprov.h>
2341
2342 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2343 static const wxString wxPyART_MENU(wxART_MENU);
2344 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2345 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2346 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2347 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2348 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2349 static const wxString wxPyART_OTHER(wxART_OTHER);
2350 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2351 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2352 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2353 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2354 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2355 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2356 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2357 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2358 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2359 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2360 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2361 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2362 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2363 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2364 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2365 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2366 static const wxString wxPyART_PRINT(wxART_PRINT);
2367 static const wxString wxPyART_HELP(wxART_HELP);
2368 static const wxString wxPyART_TIP(wxART_TIP);
2369 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2370 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2371 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2372 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2373 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2374 static const wxString wxPyART_CDROM(wxART_CDROM);
2375 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2376 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2377 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2378 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2379 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2380 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2381 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2382 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2383 static const wxString wxPyART_ERROR(wxART_ERROR);
2384 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2385 static const wxString wxPyART_WARNING(wxART_WARNING);
2386 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2387 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2388 static const wxString wxPyART_COPY(wxART_COPY);
2389 static const wxString wxPyART_CUT(wxART_CUT);
2390 static const wxString wxPyART_PASTE(wxART_PASTE);
2391 static const wxString wxPyART_DELETE(wxART_DELETE);
2392 static const wxString wxPyART_NEW(wxART_NEW);
2393 static const wxString wxPyART_UNDO(wxART_UNDO);
2394 static const wxString wxPyART_REDO(wxART_REDO);
2395 static const wxString wxPyART_QUIT(wxART_QUIT);
2396 static const wxString wxPyART_FIND(wxART_FIND);
2397 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2398 // Python aware wxArtProvider
2399 class wxPyArtProvider : public wxArtProvider {
2400 public:
2401
2402 virtual wxBitmap CreateBitmap(const wxArtID& id,
2403 const wxArtClient& client,
2404 const wxSize& size) {
2405 wxBitmap rval = wxNullBitmap;
2406 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2407 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2408 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2409 PyObject* ro;
2410 wxBitmap* ptr;
2411 PyObject* s1, *s2;
2412 s1 = wx2PyString(id);
2413 s2 = wx2PyString(client);
2414 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2415 Py_DECREF(so);
2416 Py_DECREF(s1);
2417 Py_DECREF(s2);
2418 if (ro) {
2419 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2420 rval = *ptr;
2421 Py_DECREF(ro);
2422 }
2423 }
2424 wxPyEndBlockThreads(blocked);
2425 return rval;
2426 }
2427
2428 PYPRIVATE;
2429 };
2430
2431 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2432
2433
2434
2435 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2436 PyObject* ret = PyTuple_New(3);
2437 if (ret) {
2438 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2439 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2440 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2441 }
2442 return ret;
2443 }
2444
2445 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2446 bool cont;
2447 long index = 0;
2448 wxString value;
2449
2450 cont = self->GetFirstGroup(value, index);
2451 return __EnumerationHelper(cont, value, index);
2452 }
2453 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2454 bool cont;
2455 wxString value;
2456
2457 cont = self->GetNextGroup(value, index);
2458 return __EnumerationHelper(cont, value, index);
2459 }
2460 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2461 bool cont;
2462 long index = 0;
2463 wxString value;
2464
2465 cont = self->GetFirstEntry(value, index);
2466 return __EnumerationHelper(cont, value, index);
2467 }
2468 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2469 bool cont;
2470 wxString value;
2471
2472 cont = self->GetNextEntry(value, index);
2473 return __EnumerationHelper(cont, value, index);
2474 }
2475 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2476 long rv;
2477 self->Read(key, &rv, defaultVal);
2478 return rv;
2479 }
2480
2481 SWIGINTERN int
2482 SWIG_AsVal_double(PyObject *obj, double* val)
2483 {
2484 if (PyNumber_Check(obj)) {
2485 if (val) *val = PyFloat_AsDouble(obj);
2486 return 1;
2487 }
2488 else {
2489 SWIG_type_error("number", obj);
2490 }
2491 return 0;
2492 }
2493
2494
2495 SWIGINTERNSHORT double
2496 SWIG_As_double(PyObject* obj)
2497 {
2498 double v;
2499 if (!SWIG_AsVal_double(obj, &v)) {
2500 /*
2501 this is needed to make valgrind/purify happier.
2502 */
2503 memset((void*)&v, 0, sizeof(double));
2504 }
2505 return v;
2506 }
2507
2508
2509 SWIGINTERNSHORT int
2510 SWIG_Check_double(PyObject* obj)
2511 {
2512 return SWIG_AsVal_double(obj, (double*)0);
2513 }
2514
2515 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2516 double rv;
2517 self->Read(key, &rv, defaultVal);
2518 return rv;
2519 }
2520
2521 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2522 #define SWIG_From_double PyFloat_FromDouble
2523 /*@@*/
2524
2525 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2526 bool rv;
2527 self->Read(key, &rv, defaultVal);
2528 return rv;
2529 }
2530
2531 #include <wx/datetime.h>
2532
2533 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2534 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2535
2536 #define LOCAL_TZ wxDateTime::Local
2537
2538 static PyObject *DateTime_GetAmPmStrings(){
2539 wxString am;
2540 wxString pm;
2541 wxDateTime::GetAmPmStrings(&am, &pm);
2542 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2543 PyObject* tup = PyTuple_New(2);
2544 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2545 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2546 wxPyEndBlockThreads(blocked);
2547 return tup;
2548 }
2549
2550 #if UINT_MAX < LONG_MAX
2551 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2552 #define SWIG_From_unsigned_SS_int SWIG_From_long
2553 /*@@*/
2554 #else
2555 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2556 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2557 /*@@*/
2558 #endif
2559
2560 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2561 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2562 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2563 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2564 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2565 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2566 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2567 return (*self < *other);
2568 }
2569 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2570 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2571 return (*self <= *other);
2572 }
2573 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2574 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2575 return (*self > *other);
2576 }
2577 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2578 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2579 return (*self >= *other);
2580 }
2581 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2582 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2583 return (*self == *other);
2584 }
2585 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2586 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2587 return (*self != *other);
2588 }
2589 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2590 const wxChar* rv;
2591 const wxChar* _date = date;
2592 rv = self->ParseRfc822Date(_date);
2593 if (rv == NULL) return -1;
2594 return rv - _date;
2595 }
2596 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2597 const wxChar* rv;
2598 const wxChar* _date = date;
2599 rv = self->ParseFormat(_date, format, dateDef);
2600 if (rv == NULL) return -1;
2601 return rv - _date;
2602 }
2603 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2604 const wxChar* rv;
2605 const wxChar* _datetime = datetime;
2606 rv = self->ParseDateTime(_datetime);
2607 if (rv == NULL) return -1;
2608 return rv - _datetime;
2609 }
2610 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2611 const wxChar* rv;
2612 const wxChar* _date = date;
2613 rv = self->ParseDate(_date);
2614 if (rv == NULL) return -1;
2615 return rv - _date;
2616 }
2617 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2618 const wxChar* rv;
2619 const wxChar* _time = time;
2620 rv = self->ParseTime(_time);
2621 if (rv == NULL) return -1;
2622 return rv - _time;
2623 }
2624 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2625 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2626 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2627 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2628 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2629 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2630 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2631 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2632 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2633 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2634 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2635 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2636 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2637 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2638 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2639 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2640
2641 #include <wx/dataobj.h>
2642
2643 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2644 size_t count = self->GetFormatCount(dir);
2645 wxDataFormat* formats = new wxDataFormat[count];
2646 self->GetAllFormats(formats, dir);
2647
2648 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2649 PyObject* list = PyList_New(count);
2650 for (size_t i=0; i<count; i++) {
2651 wxDataFormat* format = new wxDataFormat(formats[i]);
2652 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2653 PyList_Append(list, obj);
2654 Py_DECREF(obj);
2655 }
2656 wxPyEndBlockThreads(blocked);
2657 delete [] formats;
2658 return list;
2659 }
2660 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2661 PyObject* rval = NULL;
2662 size_t size = self->GetDataSize(format);
2663 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2664 if (size) {
2665 char* buf = new char[size];
2666 if (self->GetDataHere(format, buf))
2667 rval = PyString_FromStringAndSize(buf, size);
2668 delete [] buf;
2669 }
2670 if (! rval) {
2671 rval = Py_None;
2672 Py_INCREF(rval);
2673 }
2674 wxPyEndBlockThreads(blocked);
2675 return rval;
2676 }
2677 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2678 bool rval;
2679 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2680 if (PyString_Check(data)) {
2681 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2682 }
2683 else {
2684 // raise a TypeError if not a string
2685 PyErr_SetString(PyExc_TypeError, "String expected.");
2686 rval = false;
2687 }
2688 wxPyEndBlockThreads(blocked);
2689 return rval;
2690 }
2691 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2692 PyObject* rval = NULL;
2693 size_t size = self->GetDataSize();
2694 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2695 if (size) {
2696 char* buf = new char[size];
2697 if (self->GetDataHere(buf))
2698 rval = PyString_FromStringAndSize(buf, size);
2699 delete [] buf;
2700 }
2701 if (! rval) {
2702 rval = Py_None;
2703 Py_INCREF(rval);
2704 }
2705 wxPyEndBlockThreads(blocked);
2706 return rval;
2707 }
2708 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2709 bool rval;
2710 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2711 if (PyString_Check(data)) {
2712 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2713 }
2714 else {
2715 // raise a TypeError if not a string
2716 PyErr_SetString(PyExc_TypeError, "String expected.");
2717 rval = false;
2718 }
2719 wxPyEndBlockThreads(blocked);
2720 return rval;
2721 }
2722 // Create a new class for wxPython to use
2723 class wxPyDataObjectSimple : public wxDataObjectSimple {
2724 public:
2725 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2726 : wxDataObjectSimple(format) {}
2727
2728 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2729 bool GetDataHere(void *buf) const;
2730 bool SetData(size_t len, const void *buf) const;
2731 PYPRIVATE;
2732 };
2733
2734 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2735
2736 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2737 // We need to get the data for this object and write it to buf. I think
2738 // the best way to do this for wxPython is to have the Python method
2739 // return either a string or None and then act appropriately with the
2740 // C++ version.
2741
2742 bool rval = false;
2743 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2744 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2745 PyObject* ro;
2746 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2747 if (ro) {
2748 rval = (ro != Py_None && PyString_Check(ro));
2749 if (rval)
2750 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2751 Py_DECREF(ro);
2752 }
2753 }
2754 wxPyEndBlockThreads(blocked);
2755 return rval;
2756 }
2757
2758 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2759 // For this one we simply need to make a string from buf and len
2760 // and send it to the Python method.
2761 bool rval = false;
2762 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2763 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2764 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2765 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2766 Py_DECREF(data);
2767 }
2768 wxPyEndBlockThreads(blocked);
2769 return rval;
2770 }
2771
2772 // Create a new class for wxPython to use
2773 class wxPyTextDataObject : public wxTextDataObject {
2774 public:
2775 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2776 : wxTextDataObject(text) {}
2777
2778 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2779 DEC_PYCALLBACK_STRING__const(GetText);
2780 DEC_PYCALLBACK__STRING(SetText);
2781 PYPRIVATE;
2782 };
2783
2784 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2785 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2786 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2787
2788
2789 // Create a new class for wxPython to use
2790 class wxPyBitmapDataObject : public wxBitmapDataObject {
2791 public:
2792 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2793 : wxBitmapDataObject(bitmap) {}
2794
2795 wxBitmap GetBitmap() const;
2796 void SetBitmap(const wxBitmap& bitmap);
2797 PYPRIVATE;
2798 };
2799
2800 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2801 wxBitmap* rval = &wxNullBitmap;
2802 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2803 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2804 PyObject* ro;
2805 wxBitmap* ptr;
2806 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2807 if (ro) {
2808 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2809 rval = ptr;
2810 Py_DECREF(ro);
2811 }
2812 }
2813 wxPyEndBlockThreads(blocked);
2814 return *rval;
2815 }
2816
2817 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2818 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2819 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2820 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2821 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2822 Py_DECREF(bo);
2823 }
2824 wxPyEndBlockThreads(blocked);
2825 }
2826
2827 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2828 return new wxCustomDataObject(wxDataFormat(formatName));
2829 }
2830 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2831 bool rval;
2832 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2833 if (PyString_Check(data)) {
2834 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2835 }
2836 else {
2837 // raise a TypeError if not a string
2838 PyErr_SetString(PyExc_TypeError, "String expected.");
2839 rval = false;
2840 }
2841 wxPyEndBlockThreads(blocked);
2842 return rval;
2843 }
2844 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2845 PyObject* obj;
2846 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2847 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2848 wxPyEndBlockThreads(blocked);
2849 return obj;
2850 }
2851
2852 class wxMetafileDataObject : public wxDataObjectSimple
2853 {
2854 public:
2855 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
2856 };
2857
2858
2859 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2860
2861
2862 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2863 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2864 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2865 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2866 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2867
2868
2869 class wxPyTextDropTarget : public wxTextDropTarget {
2870 public:
2871 wxPyTextDropTarget() {}
2872
2873 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2874
2875 DEC_PYCALLBACK__(OnLeave);
2876 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2877 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2878 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2879 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2880
2881 PYPRIVATE;
2882 };
2883
2884 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2885 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2886 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2887 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2888 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2889 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2890
2891
2892
2893 class wxPyFileDropTarget : public wxFileDropTarget {
2894 public:
2895 wxPyFileDropTarget() {}
2896
2897 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2898
2899 DEC_PYCALLBACK__(OnLeave);
2900 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2901 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2902 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2903 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2904
2905 PYPRIVATE;
2906 };
2907
2908 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2909 const wxArrayString& filenames) {
2910 bool rval = false;
2911 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2912 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2913 PyObject* list = wxArrayString2PyList_helper(filenames);
2914 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2915 Py_DECREF(list);
2916 }
2917 wxPyEndBlockThreads(blocked);
2918 return rval;
2919 }
2920
2921
2922
2923 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2924 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2925 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2926 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2927 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2928
2929
2930
2931
2932 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2933
2934 #include <wx/display.h>
2935
2936 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2937 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2938
2939 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2940 #if !wxUSE_DISPLAY
2941 #include <wx/dynarray.h>
2942 #include <wx/vidmode.h>
2943
2944 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2945 #include "wx/arrimpl.cpp"
2946 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2947 const wxVideoMode wxDefaultVideoMode;
2948
2949 class wxDisplay
2950 {
2951 public:
2952 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2953 ~wxDisplay() {}
2954
2955 static size_t GetCount()
2956 { wxPyRaiseNotImplemented(); return 0; }
2957
2958 static int GetFromPoint(const wxPoint& pt)
2959 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2960 static int GetFromWindow(wxWindow *window)
2961 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2962
2963 virtual bool IsOk() const { return false; }
2964 virtual wxRect GetGeometry() const { wxRect r; return r; }
2965 virtual wxString GetName() const { return wxEmptyString; }
2966 bool IsPrimary() const { return false; }
2967
2968 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2969 { wxArrayVideoModes a; return a; }
2970
2971 virtual wxVideoMode GetCurrentMode() const
2972 { return wxDefaultVideoMode; }
2973
2974 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2975 { return false; }
2976
2977 void ResetMode() {}
2978 };
2979 #endif
2980
2981 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2982 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2983 PyObject* pyList = NULL;
2984 wxArrayVideoModes arr = self->GetModes(mode);
2985 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2986 pyList = PyList_New(0);
2987 for (int i=0; i < arr.GetCount(); i++) {
2988 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2989 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2990 PyList_Append(pyList, pyObj);
2991 Py_DECREF(pyObj);
2992 }
2993 wxPyEndBlockThreads(blocked);
2994 return pyList;
2995 }
2996
2997 #include <wx/stdpaths.h>
2998
2999 static wxStandardPaths *StandardPaths_Get(){
3000 return (wxStandardPaths*) &wxStandardPaths::Get();
3001 }
3002 #ifdef __cplusplus
3003 extern "C" {
3004 #endif
3005 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3006 PyObject *resultobj;
3007 wxSystemColour arg1 ;
3008 wxColour result;
3009 PyObject * obj0 = 0 ;
3010 char *kwnames[] = {
3011 (char *) "index", NULL
3012 };
3013
3014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3015 {
3016 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
3017 if (SWIG_arg_fail(1)) SWIG_fail;
3018 }
3019 {
3020 if (!wxPyCheckForApp()) SWIG_fail;
3021 PyThreadState* __tstate = wxPyBeginAllowThreads();
3022 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3023
3024 wxPyEndAllowThreads(__tstate);
3025 if (PyErr_Occurred()) SWIG_fail;
3026 }
3027 {
3028 wxColour * resultptr;
3029 resultptr = new wxColour((wxColour &)(result));
3030 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3031 }
3032 return resultobj;
3033 fail:
3034 return NULL;
3035 }
3036
3037
3038 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3039 PyObject *resultobj;
3040 wxSystemFont arg1 ;
3041 wxFont result;
3042 PyObject * obj0 = 0 ;
3043 char *kwnames[] = {
3044 (char *) "index", NULL
3045 };
3046
3047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3048 {
3049 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3050 if (SWIG_arg_fail(1)) SWIG_fail;
3051 }
3052 {
3053 if (!wxPyCheckForApp()) SWIG_fail;
3054 PyThreadState* __tstate = wxPyBeginAllowThreads();
3055 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3056
3057 wxPyEndAllowThreads(__tstate);
3058 if (PyErr_Occurred()) SWIG_fail;
3059 }
3060 {
3061 wxFont * resultptr;
3062 resultptr = new wxFont((wxFont &)(result));
3063 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3064 }
3065 return resultobj;
3066 fail:
3067 return NULL;
3068 }
3069
3070
3071 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3072 PyObject *resultobj;
3073 wxSystemMetric arg1 ;
3074 wxWindow *arg2 = (wxWindow *) NULL ;
3075 int result;
3076 PyObject * obj0 = 0 ;
3077 PyObject * obj1 = 0 ;
3078 char *kwnames[] = {
3079 (char *) "index",(char *) "win", NULL
3080 };
3081
3082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3083 {
3084 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3085 if (SWIG_arg_fail(1)) SWIG_fail;
3086 }
3087 if (obj1) {
3088 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3089 if (SWIG_arg_fail(2)) SWIG_fail;
3090 }
3091 {
3092 if (!wxPyCheckForApp()) SWIG_fail;
3093 PyThreadState* __tstate = wxPyBeginAllowThreads();
3094 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3095
3096 wxPyEndAllowThreads(__tstate);
3097 if (PyErr_Occurred()) SWIG_fail;
3098 }
3099 {
3100 resultobj = SWIG_From_int((int)(result));
3101 }
3102 return resultobj;
3103 fail:
3104 return NULL;
3105 }
3106
3107
3108 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3109 PyObject *resultobj;
3110 wxSystemFeature arg1 ;
3111 bool result;
3112 PyObject * obj0 = 0 ;
3113 char *kwnames[] = {
3114 (char *) "index", NULL
3115 };
3116
3117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3118 {
3119 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3120 if (SWIG_arg_fail(1)) SWIG_fail;
3121 }
3122 {
3123 if (!wxPyCheckForApp()) SWIG_fail;
3124 PyThreadState* __tstate = wxPyBeginAllowThreads();
3125 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3126
3127 wxPyEndAllowThreads(__tstate);
3128 if (PyErr_Occurred()) SWIG_fail;
3129 }
3130 {
3131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3132 }
3133 return resultobj;
3134 fail:
3135 return NULL;
3136 }
3137
3138
3139 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3140 PyObject *resultobj;
3141 wxSystemScreenType result;
3142 char *kwnames[] = {
3143 NULL
3144 };
3145
3146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3147 {
3148 if (!wxPyCheckForApp()) SWIG_fail;
3149 PyThreadState* __tstate = wxPyBeginAllowThreads();
3150 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3151
3152 wxPyEndAllowThreads(__tstate);
3153 if (PyErr_Occurred()) SWIG_fail;
3154 }
3155 resultobj = SWIG_From_int((result));
3156 return resultobj;
3157 fail:
3158 return NULL;
3159 }
3160
3161
3162 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3163 PyObject *resultobj;
3164 wxSystemScreenType arg1 ;
3165 PyObject * obj0 = 0 ;
3166 char *kwnames[] = {
3167 (char *) "screen", NULL
3168 };
3169
3170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3171 {
3172 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3173 if (SWIG_arg_fail(1)) SWIG_fail;
3174 }
3175 {
3176 if (!wxPyCheckForApp()) SWIG_fail;
3177 PyThreadState* __tstate = wxPyBeginAllowThreads();
3178 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3179
3180 wxPyEndAllowThreads(__tstate);
3181 if (PyErr_Occurred()) SWIG_fail;
3182 }
3183 Py_INCREF(Py_None); resultobj = Py_None;
3184 return resultobj;
3185 fail:
3186 return NULL;
3187 }
3188
3189
3190 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3191 PyObject *obj;
3192 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3193 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3194 Py_INCREF(obj);
3195 return Py_BuildValue((char *)"");
3196 }
3197 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3198 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3199 return 1;
3200 }
3201
3202
3203 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3204 PyObject *pyobj;
3205
3206 {
3207 #if wxUSE_UNICODE
3208 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3209 #else
3210 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3211 #endif
3212 }
3213 return pyobj;
3214 }
3215
3216
3217 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3218 PyObject *resultobj;
3219 wxSystemOptions *result;
3220 char *kwnames[] = {
3221 NULL
3222 };
3223
3224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3225 {
3226 PyThreadState* __tstate = wxPyBeginAllowThreads();
3227 result = (wxSystemOptions *)new wxSystemOptions();
3228
3229 wxPyEndAllowThreads(__tstate);
3230 if (PyErr_Occurred()) SWIG_fail;
3231 }
3232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3233 return resultobj;
3234 fail:
3235 return NULL;
3236 }
3237
3238
3239 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3240 PyObject *resultobj;
3241 wxString *arg1 = 0 ;
3242 wxString *arg2 = 0 ;
3243 bool temp1 = false ;
3244 bool temp2 = false ;
3245 PyObject * obj0 = 0 ;
3246 PyObject * obj1 = 0 ;
3247 char *kwnames[] = {
3248 (char *) "name",(char *) "value", NULL
3249 };
3250
3251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3252 {
3253 arg1 = wxString_in_helper(obj0);
3254 if (arg1 == NULL) SWIG_fail;
3255 temp1 = true;
3256 }
3257 {
3258 arg2 = wxString_in_helper(obj1);
3259 if (arg2 == NULL) SWIG_fail;
3260 temp2 = true;
3261 }
3262 {
3263 PyThreadState* __tstate = wxPyBeginAllowThreads();
3264 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*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 {
3275 if (temp2)
3276 delete arg2;
3277 }
3278 return resultobj;
3279 fail:
3280 {
3281 if (temp1)
3282 delete arg1;
3283 }
3284 {
3285 if (temp2)
3286 delete arg2;
3287 }
3288 return NULL;
3289 }
3290
3291
3292 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3293 PyObject *resultobj;
3294 wxString *arg1 = 0 ;
3295 int arg2 ;
3296 bool temp1 = false ;
3297 PyObject * obj0 = 0 ;
3298 PyObject * obj1 = 0 ;
3299 char *kwnames[] = {
3300 (char *) "name",(char *) "value", NULL
3301 };
3302
3303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3304 {
3305 arg1 = wxString_in_helper(obj0);
3306 if (arg1 == NULL) SWIG_fail;
3307 temp1 = true;
3308 }
3309 {
3310 arg2 = (int)(SWIG_As_int(obj1));
3311 if (SWIG_arg_fail(2)) SWIG_fail;
3312 }
3313 {
3314 PyThreadState* __tstate = wxPyBeginAllowThreads();
3315 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3316
3317 wxPyEndAllowThreads(__tstate);
3318 if (PyErr_Occurred()) SWIG_fail;
3319 }
3320 Py_INCREF(Py_None); resultobj = Py_None;
3321 {
3322 if (temp1)
3323 delete arg1;
3324 }
3325 return resultobj;
3326 fail:
3327 {
3328 if (temp1)
3329 delete arg1;
3330 }
3331 return NULL;
3332 }
3333
3334
3335 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3336 PyObject *resultobj;
3337 wxString *arg1 = 0 ;
3338 wxString result;
3339 bool temp1 = false ;
3340 PyObject * obj0 = 0 ;
3341 char *kwnames[] = {
3342 (char *) "name", NULL
3343 };
3344
3345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3346 {
3347 arg1 = wxString_in_helper(obj0);
3348 if (arg1 == NULL) SWIG_fail;
3349 temp1 = true;
3350 }
3351 {
3352 PyThreadState* __tstate = wxPyBeginAllowThreads();
3353 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3354
3355 wxPyEndAllowThreads(__tstate);
3356 if (PyErr_Occurred()) SWIG_fail;
3357 }
3358 {
3359 #if wxUSE_UNICODE
3360 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3361 #else
3362 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3363 #endif
3364 }
3365 {
3366 if (temp1)
3367 delete arg1;
3368 }
3369 return resultobj;
3370 fail:
3371 {
3372 if (temp1)
3373 delete arg1;
3374 }
3375 return NULL;
3376 }
3377
3378
3379 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3380 PyObject *resultobj;
3381 wxString *arg1 = 0 ;
3382 int result;
3383 bool temp1 = false ;
3384 PyObject * obj0 = 0 ;
3385 char *kwnames[] = {
3386 (char *) "name", NULL
3387 };
3388
3389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3390 {
3391 arg1 = wxString_in_helper(obj0);
3392 if (arg1 == NULL) SWIG_fail;
3393 temp1 = true;
3394 }
3395 {
3396 PyThreadState* __tstate = wxPyBeginAllowThreads();
3397 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3398
3399 wxPyEndAllowThreads(__tstate);
3400 if (PyErr_Occurred()) SWIG_fail;
3401 }
3402 {
3403 resultobj = SWIG_From_int((int)(result));
3404 }
3405 {
3406 if (temp1)
3407 delete arg1;
3408 }
3409 return resultobj;
3410 fail:
3411 {
3412 if (temp1)
3413 delete arg1;
3414 }
3415 return NULL;
3416 }
3417
3418
3419 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3420 PyObject *resultobj;
3421 wxString *arg1 = 0 ;
3422 bool result;
3423 bool temp1 = false ;
3424 PyObject * obj0 = 0 ;
3425 char *kwnames[] = {
3426 (char *) "name", NULL
3427 };
3428
3429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3430 {
3431 arg1 = wxString_in_helper(obj0);
3432 if (arg1 == NULL) SWIG_fail;
3433 temp1 = true;
3434 }
3435 {
3436 PyThreadState* __tstate = wxPyBeginAllowThreads();
3437 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3438
3439 wxPyEndAllowThreads(__tstate);
3440 if (PyErr_Occurred()) SWIG_fail;
3441 }
3442 {
3443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3444 }
3445 {
3446 if (temp1)
3447 delete arg1;
3448 }
3449 return resultobj;
3450 fail:
3451 {
3452 if (temp1)
3453 delete arg1;
3454 }
3455 return NULL;
3456 }
3457
3458
3459 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3460 PyObject *resultobj;
3461 wxString *arg1 = 0 ;
3462 bool result;
3463 bool temp1 = false ;
3464 PyObject * obj0 = 0 ;
3465 char *kwnames[] = {
3466 (char *) "name", NULL
3467 };
3468
3469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3470 {
3471 arg1 = wxString_in_helper(obj0);
3472 if (arg1 == NULL) SWIG_fail;
3473 temp1 = true;
3474 }
3475 {
3476 PyThreadState* __tstate = wxPyBeginAllowThreads();
3477 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3478
3479 wxPyEndAllowThreads(__tstate);
3480 if (PyErr_Occurred()) SWIG_fail;
3481 }
3482 {
3483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3484 }
3485 {
3486 if (temp1)
3487 delete arg1;
3488 }
3489 return resultobj;
3490 fail:
3491 {
3492 if (temp1)
3493 delete arg1;
3494 }
3495 return NULL;
3496 }
3497
3498
3499 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3500 PyObject *obj;
3501 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3502 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3503 Py_INCREF(obj);
3504 return Py_BuildValue((char *)"");
3505 }
3506 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3507 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3508 return 1;
3509 }
3510
3511
3512 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3513 PyObject *pyobj;
3514
3515 {
3516 #if wxUSE_UNICODE
3517 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3518 #else
3519 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3520 #endif
3521 }
3522 return pyobj;
3523 }
3524
3525
3526 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3527 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3528 return 1;
3529 }
3530
3531
3532 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3533 PyObject *pyobj;
3534
3535 {
3536 #if wxUSE_UNICODE
3537 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3538 #else
3539 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3540 #endif
3541 }
3542 return pyobj;
3543 }
3544
3545
3546 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3547 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3548 return 1;
3549 }
3550
3551
3552 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3553 PyObject *pyobj;
3554
3555 {
3556 #if wxUSE_UNICODE
3557 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3558 #else
3559 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3560 #endif
3561 }
3562 return pyobj;
3563 }
3564
3565
3566 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3567 PyObject *resultobj;
3568 long result;
3569 char *kwnames[] = {
3570 NULL
3571 };
3572
3573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3574 {
3575 PyThreadState* __tstate = wxPyBeginAllowThreads();
3576 result = (long)wxNewId();
3577
3578 wxPyEndAllowThreads(__tstate);
3579 if (PyErr_Occurred()) SWIG_fail;
3580 }
3581 {
3582 resultobj = SWIG_From_long((long)(result));
3583 }
3584 return resultobj;
3585 fail:
3586 return NULL;
3587 }
3588
3589
3590 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3591 PyObject *resultobj;
3592 long arg1 ;
3593 PyObject * obj0 = 0 ;
3594 char *kwnames[] = {
3595 (char *) "id", NULL
3596 };
3597
3598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3599 {
3600 arg1 = (long)(SWIG_As_long(obj0));
3601 if (SWIG_arg_fail(1)) SWIG_fail;
3602 }
3603 {
3604 PyThreadState* __tstate = wxPyBeginAllowThreads();
3605 wxRegisterId(arg1);
3606
3607 wxPyEndAllowThreads(__tstate);
3608 if (PyErr_Occurred()) SWIG_fail;
3609 }
3610 Py_INCREF(Py_None); resultobj = Py_None;
3611 return resultobj;
3612 fail:
3613 return NULL;
3614 }
3615
3616
3617 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3618 PyObject *resultobj;
3619 long result;
3620 char *kwnames[] = {
3621 NULL
3622 };
3623
3624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3625 {
3626 PyThreadState* __tstate = wxPyBeginAllowThreads();
3627 result = (long)wxGetCurrentId();
3628
3629 wxPyEndAllowThreads(__tstate);
3630 if (PyErr_Occurred()) SWIG_fail;
3631 }
3632 {
3633 resultobj = SWIG_From_long((long)(result));
3634 }
3635 return resultobj;
3636 fail:
3637 return NULL;
3638 }
3639
3640
3641 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3642 PyObject *resultobj;
3643 int arg1 ;
3644 bool result;
3645 PyObject * obj0 = 0 ;
3646 char *kwnames[] = {
3647 (char *) "id", NULL
3648 };
3649
3650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3651 {
3652 arg1 = (int)(SWIG_As_int(obj0));
3653 if (SWIG_arg_fail(1)) SWIG_fail;
3654 }
3655 {
3656 PyThreadState* __tstate = wxPyBeginAllowThreads();
3657 result = (bool)wxIsStockID(arg1);
3658
3659 wxPyEndAllowThreads(__tstate);
3660 if (PyErr_Occurred()) SWIG_fail;
3661 }
3662 {
3663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3664 }
3665 return resultobj;
3666 fail:
3667 return NULL;
3668 }
3669
3670
3671 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3672 PyObject *resultobj;
3673 int arg1 ;
3674 wxString *arg2 = 0 ;
3675 bool result;
3676 bool temp2 = false ;
3677 PyObject * obj0 = 0 ;
3678 PyObject * obj1 = 0 ;
3679 char *kwnames[] = {
3680 (char *) "id",(char *) "label", NULL
3681 };
3682
3683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3684 {
3685 arg1 = (int)(SWIG_As_int(obj0));
3686 if (SWIG_arg_fail(1)) SWIG_fail;
3687 }
3688 {
3689 arg2 = wxString_in_helper(obj1);
3690 if (arg2 == NULL) SWIG_fail;
3691 temp2 = true;
3692 }
3693 {
3694 PyThreadState* __tstate = wxPyBeginAllowThreads();
3695 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3696
3697 wxPyEndAllowThreads(__tstate);
3698 if (PyErr_Occurred()) SWIG_fail;
3699 }
3700 {
3701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3702 }
3703 {
3704 if (temp2)
3705 delete arg2;
3706 }
3707 return resultobj;
3708 fail:
3709 {
3710 if (temp2)
3711 delete arg2;
3712 }
3713 return NULL;
3714 }
3715
3716
3717 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3718 PyObject *resultobj;
3719 int arg1 ;
3720 bool arg2 = (bool) true ;
3721 wxString arg3 = (wxString) wxPyEmptyString ;
3722 wxString result;
3723 PyObject * obj0 = 0 ;
3724 PyObject * obj1 = 0 ;
3725 PyObject * obj2 = 0 ;
3726 char *kwnames[] = {
3727 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3728 };
3729
3730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3731 {
3732 arg1 = (int)(SWIG_As_int(obj0));
3733 if (SWIG_arg_fail(1)) SWIG_fail;
3734 }
3735 if (obj1) {
3736 {
3737 arg2 = (bool)(SWIG_As_bool(obj1));
3738 if (SWIG_arg_fail(2)) SWIG_fail;
3739 }
3740 }
3741 if (obj2) {
3742 {
3743 wxString* sptr = wxString_in_helper(obj2);
3744 if (sptr == NULL) SWIG_fail;
3745 arg3 = *sptr;
3746 delete sptr;
3747 }
3748 }
3749 {
3750 PyThreadState* __tstate = wxPyBeginAllowThreads();
3751 result = wxGetStockLabel(arg1,arg2,arg3);
3752
3753 wxPyEndAllowThreads(__tstate);
3754 if (PyErr_Occurred()) SWIG_fail;
3755 }
3756 {
3757 #if wxUSE_UNICODE
3758 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3759 #else
3760 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3761 #endif
3762 }
3763 return resultobj;
3764 fail:
3765 return NULL;
3766 }
3767
3768
3769 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3770 PyObject *resultobj;
3771 char *kwnames[] = {
3772 NULL
3773 };
3774
3775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3776 {
3777 if (!wxPyCheckForApp()) SWIG_fail;
3778 PyThreadState* __tstate = wxPyBeginAllowThreads();
3779 wxBell();
3780
3781 wxPyEndAllowThreads(__tstate);
3782 if (PyErr_Occurred()) SWIG_fail;
3783 }
3784 Py_INCREF(Py_None); resultobj = Py_None;
3785 return resultobj;
3786 fail:
3787 return NULL;
3788 }
3789
3790
3791 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3792 PyObject *resultobj;
3793 char *kwnames[] = {
3794 NULL
3795 };
3796
3797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3798 {
3799 if (!wxPyCheckForApp()) SWIG_fail;
3800 PyThreadState* __tstate = wxPyBeginAllowThreads();
3801 wxEndBusyCursor();
3802
3803 wxPyEndAllowThreads(__tstate);
3804 if (PyErr_Occurred()) SWIG_fail;
3805 }
3806 Py_INCREF(Py_None); resultobj = Py_None;
3807 return resultobj;
3808 fail:
3809 return NULL;
3810 }
3811
3812
3813 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3814 PyObject *resultobj;
3815 bool arg1 = (bool) true ;
3816 long result;
3817 PyObject * obj0 = 0 ;
3818 char *kwnames[] = {
3819 (char *) "resetTimer", NULL
3820 };
3821
3822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3823 if (obj0) {
3824 {
3825 arg1 = (bool)(SWIG_As_bool(obj0));
3826 if (SWIG_arg_fail(1)) SWIG_fail;
3827 }
3828 }
3829 {
3830 PyThreadState* __tstate = wxPyBeginAllowThreads();
3831 result = (long)wxGetElapsedTime(arg1);
3832
3833 wxPyEndAllowThreads(__tstate);
3834 if (PyErr_Occurred()) SWIG_fail;
3835 }
3836 {
3837 resultobj = SWIG_From_long((long)(result));
3838 }
3839 return resultobj;
3840 fail:
3841 return NULL;
3842 }
3843
3844
3845 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3846 PyObject *resultobj;
3847 int *arg1 = (int *) 0 ;
3848 int *arg2 = (int *) 0 ;
3849 int temp1 ;
3850 int res1 = 0 ;
3851 int temp2 ;
3852 int res2 = 0 ;
3853 char *kwnames[] = {
3854 NULL
3855 };
3856
3857 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3858 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3860 {
3861 if (!wxPyCheckForApp()) SWIG_fail;
3862 PyThreadState* __tstate = wxPyBeginAllowThreads();
3863 wxGetMousePosition(arg1,arg2);
3864
3865 wxPyEndAllowThreads(__tstate);
3866 if (PyErr_Occurred()) SWIG_fail;
3867 }
3868 Py_INCREF(Py_None); resultobj = Py_None;
3869 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3870 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3871 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3872 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3873 return resultobj;
3874 fail:
3875 return NULL;
3876 }
3877
3878
3879 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3880 PyObject *resultobj;
3881 bool result;
3882 char *kwnames[] = {
3883 NULL
3884 };
3885
3886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3887 {
3888 PyThreadState* __tstate = wxPyBeginAllowThreads();
3889 result = (bool)wxIsBusy();
3890
3891 wxPyEndAllowThreads(__tstate);
3892 if (PyErr_Occurred()) SWIG_fail;
3893 }
3894 {
3895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3896 }
3897 return resultobj;
3898 fail:
3899 return NULL;
3900 }
3901
3902
3903 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3904 PyObject *resultobj;
3905 wxString result;
3906 char *kwnames[] = {
3907 NULL
3908 };
3909
3910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3911 {
3912 PyThreadState* __tstate = wxPyBeginAllowThreads();
3913 result = wxNow();
3914
3915 wxPyEndAllowThreads(__tstate);
3916 if (PyErr_Occurred()) SWIG_fail;
3917 }
3918 {
3919 #if wxUSE_UNICODE
3920 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3921 #else
3922 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3923 #endif
3924 }
3925 return resultobj;
3926 fail:
3927 return NULL;
3928 }
3929
3930
3931 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3932 PyObject *resultobj;
3933 wxString const &arg1_defvalue = wxPyEmptyString ;
3934 wxString *arg1 = (wxString *) &arg1_defvalue ;
3935 bool result;
3936 bool temp1 = false ;
3937 PyObject * obj0 = 0 ;
3938 char *kwnames[] = {
3939 (char *) "command", NULL
3940 };
3941
3942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3943 if (obj0) {
3944 {
3945 arg1 = wxString_in_helper(obj0);
3946 if (arg1 == NULL) SWIG_fail;
3947 temp1 = true;
3948 }
3949 }
3950 {
3951 PyThreadState* __tstate = wxPyBeginAllowThreads();
3952 result = (bool)wxShell((wxString const &)*arg1);
3953
3954 wxPyEndAllowThreads(__tstate);
3955 if (PyErr_Occurred()) SWIG_fail;
3956 }
3957 {
3958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3959 }
3960 {
3961 if (temp1)
3962 delete arg1;
3963 }
3964 return resultobj;
3965 fail:
3966 {
3967 if (temp1)
3968 delete arg1;
3969 }
3970 return NULL;
3971 }
3972
3973
3974 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3975 PyObject *resultobj;
3976 char *kwnames[] = {
3977 NULL
3978 };
3979
3980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3981 {
3982 PyThreadState* __tstate = wxPyBeginAllowThreads();
3983 wxStartTimer();
3984
3985 wxPyEndAllowThreads(__tstate);
3986 if (PyErr_Occurred()) SWIG_fail;
3987 }
3988 Py_INCREF(Py_None); resultobj = Py_None;
3989 return resultobj;
3990 fail:
3991 return NULL;
3992 }
3993
3994
3995 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3996 PyObject *resultobj;
3997 int *arg1 = (int *) 0 ;
3998 int *arg2 = (int *) 0 ;
3999 int result;
4000 int temp1 ;
4001 int res1 = 0 ;
4002 int temp2 ;
4003 int res2 = 0 ;
4004 char *kwnames[] = {
4005 NULL
4006 };
4007
4008 arg1 = &temp1; res1 = SWIG_NEWOBJ;
4009 arg2 = &temp2; res2 = SWIG_NEWOBJ;
4010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
4011 {
4012 PyThreadState* __tstate = wxPyBeginAllowThreads();
4013 result = (int)wxGetOsVersion(arg1,arg2);
4014
4015 wxPyEndAllowThreads(__tstate);
4016 if (PyErr_Occurred()) SWIG_fail;
4017 }
4018 {
4019 resultobj = SWIG_From_int((int)(result));
4020 }
4021 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4022 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4023 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4024 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4025 return resultobj;
4026 fail:
4027 return NULL;
4028 }
4029
4030
4031 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4032 PyObject *resultobj;
4033 wxString result;
4034 char *kwnames[] = {
4035 NULL
4036 };
4037
4038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4039 {
4040 PyThreadState* __tstate = wxPyBeginAllowThreads();
4041 result = wxGetOsDescription();
4042
4043 wxPyEndAllowThreads(__tstate);
4044 if (PyErr_Occurred()) SWIG_fail;
4045 }
4046 {
4047 #if wxUSE_UNICODE
4048 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4049 #else
4050 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4051 #endif
4052 }
4053 return resultobj;
4054 fail:
4055 return NULL;
4056 }
4057
4058
4059 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4060 PyObject *resultobj;
4061 long result;
4062 char *kwnames[] = {
4063 NULL
4064 };
4065
4066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4067 {
4068 PyThreadState* __tstate = wxPyBeginAllowThreads();
4069 result = (long)wxGetFreeMemory();
4070
4071 wxPyEndAllowThreads(__tstate);
4072 if (PyErr_Occurred()) SWIG_fail;
4073 }
4074 {
4075 resultobj = SWIG_From_long((long)(result));
4076 }
4077 return resultobj;
4078 fail:
4079 return NULL;
4080 }
4081
4082
4083 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4084 PyObject *resultobj;
4085 wxShutdownFlags arg1 ;
4086 bool result;
4087 PyObject * obj0 = 0 ;
4088 char *kwnames[] = {
4089 (char *) "wFlags", NULL
4090 };
4091
4092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4093 {
4094 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4095 if (SWIG_arg_fail(1)) SWIG_fail;
4096 }
4097 {
4098 if (!wxPyCheckForApp()) SWIG_fail;
4099 PyThreadState* __tstate = wxPyBeginAllowThreads();
4100 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4101
4102 wxPyEndAllowThreads(__tstate);
4103 if (PyErr_Occurred()) SWIG_fail;
4104 }
4105 {
4106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4107 }
4108 return resultobj;
4109 fail:
4110 return NULL;
4111 }
4112
4113
4114 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4115 PyObject *resultobj;
4116 int arg1 ;
4117 PyObject * obj0 = 0 ;
4118 char *kwnames[] = {
4119 (char *) "secs", NULL
4120 };
4121
4122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4123 {
4124 arg1 = (int)(SWIG_As_int(obj0));
4125 if (SWIG_arg_fail(1)) SWIG_fail;
4126 }
4127 {
4128 PyThreadState* __tstate = wxPyBeginAllowThreads();
4129 wxSleep(arg1);
4130
4131 wxPyEndAllowThreads(__tstate);
4132 if (PyErr_Occurred()) SWIG_fail;
4133 }
4134 Py_INCREF(Py_None); resultobj = Py_None;
4135 return resultobj;
4136 fail:
4137 return NULL;
4138 }
4139
4140
4141 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4142 PyObject *resultobj;
4143 unsigned long arg1 ;
4144 PyObject * obj0 = 0 ;
4145 char *kwnames[] = {
4146 (char *) "milliseconds", NULL
4147 };
4148
4149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4150 {
4151 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4152 if (SWIG_arg_fail(1)) SWIG_fail;
4153 }
4154 {
4155 PyThreadState* __tstate = wxPyBeginAllowThreads();
4156 wxMilliSleep(arg1);
4157
4158 wxPyEndAllowThreads(__tstate);
4159 if (PyErr_Occurred()) SWIG_fail;
4160 }
4161 Py_INCREF(Py_None); resultobj = Py_None;
4162 return resultobj;
4163 fail:
4164 return NULL;
4165 }
4166
4167
4168 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4169 PyObject *resultobj;
4170 unsigned long arg1 ;
4171 PyObject * obj0 = 0 ;
4172 char *kwnames[] = {
4173 (char *) "microseconds", NULL
4174 };
4175
4176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4177 {
4178 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4179 if (SWIG_arg_fail(1)) SWIG_fail;
4180 }
4181 {
4182 PyThreadState* __tstate = wxPyBeginAllowThreads();
4183 wxMicroSleep(arg1);
4184
4185 wxPyEndAllowThreads(__tstate);
4186 if (PyErr_Occurred()) SWIG_fail;
4187 }
4188 Py_INCREF(Py_None); resultobj = Py_None;
4189 return resultobj;
4190 fail:
4191 return NULL;
4192 }
4193
4194
4195 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4196 PyObject *resultobj;
4197 bool arg1 ;
4198 PyObject * obj0 = 0 ;
4199 char *kwnames[] = {
4200 (char *) "enable", NULL
4201 };
4202
4203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4204 {
4205 arg1 = (bool)(SWIG_As_bool(obj0));
4206 if (SWIG_arg_fail(1)) SWIG_fail;
4207 }
4208 {
4209 PyThreadState* __tstate = wxPyBeginAllowThreads();
4210 wxEnableTopLevelWindows(arg1);
4211
4212 wxPyEndAllowThreads(__tstate);
4213 if (PyErr_Occurred()) SWIG_fail;
4214 }
4215 Py_INCREF(Py_None); resultobj = Py_None;
4216 return resultobj;
4217 fail:
4218 return NULL;
4219 }
4220
4221
4222 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4223 PyObject *resultobj;
4224 wxString *arg1 = 0 ;
4225 wxString result;
4226 bool temp1 = false ;
4227 PyObject * obj0 = 0 ;
4228 char *kwnames[] = {
4229 (char *) "in", NULL
4230 };
4231
4232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4233 {
4234 arg1 = wxString_in_helper(obj0);
4235 if (arg1 == NULL) SWIG_fail;
4236 temp1 = true;
4237 }
4238 {
4239 PyThreadState* __tstate = wxPyBeginAllowThreads();
4240 result = wxStripMenuCodes((wxString const &)*arg1);
4241
4242 wxPyEndAllowThreads(__tstate);
4243 if (PyErr_Occurred()) SWIG_fail;
4244 }
4245 {
4246 #if wxUSE_UNICODE
4247 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4248 #else
4249 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4250 #endif
4251 }
4252 {
4253 if (temp1)
4254 delete arg1;
4255 }
4256 return resultobj;
4257 fail:
4258 {
4259 if (temp1)
4260 delete arg1;
4261 }
4262 return NULL;
4263 }
4264
4265
4266 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4267 PyObject *resultobj;
4268 wxString result;
4269 char *kwnames[] = {
4270 NULL
4271 };
4272
4273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4274 {
4275 PyThreadState* __tstate = wxPyBeginAllowThreads();
4276 result = wxGetEmailAddress();
4277
4278 wxPyEndAllowThreads(__tstate);
4279 if (PyErr_Occurred()) SWIG_fail;
4280 }
4281 {
4282 #if wxUSE_UNICODE
4283 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4284 #else
4285 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4286 #endif
4287 }
4288 return resultobj;
4289 fail:
4290 return NULL;
4291 }
4292
4293
4294 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4295 PyObject *resultobj;
4296 wxString result;
4297 char *kwnames[] = {
4298 NULL
4299 };
4300
4301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4302 {
4303 PyThreadState* __tstate = wxPyBeginAllowThreads();
4304 result = wxGetHostName();
4305
4306 wxPyEndAllowThreads(__tstate);
4307 if (PyErr_Occurred()) SWIG_fail;
4308 }
4309 {
4310 #if wxUSE_UNICODE
4311 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4312 #else
4313 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4314 #endif
4315 }
4316 return resultobj;
4317 fail:
4318 return NULL;
4319 }
4320
4321
4322 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4323 PyObject *resultobj;
4324 wxString result;
4325 char *kwnames[] = {
4326 NULL
4327 };
4328
4329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4330 {
4331 PyThreadState* __tstate = wxPyBeginAllowThreads();
4332 result = wxGetFullHostName();
4333
4334 wxPyEndAllowThreads(__tstate);
4335 if (PyErr_Occurred()) SWIG_fail;
4336 }
4337 {
4338 #if wxUSE_UNICODE
4339 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4340 #else
4341 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4342 #endif
4343 }
4344 return resultobj;
4345 fail:
4346 return NULL;
4347 }
4348
4349
4350 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4351 PyObject *resultobj;
4352 wxString result;
4353 char *kwnames[] = {
4354 NULL
4355 };
4356
4357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4358 {
4359 PyThreadState* __tstate = wxPyBeginAllowThreads();
4360 result = wxGetUserId();
4361
4362 wxPyEndAllowThreads(__tstate);
4363 if (PyErr_Occurred()) SWIG_fail;
4364 }
4365 {
4366 #if wxUSE_UNICODE
4367 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4368 #else
4369 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4370 #endif
4371 }
4372 return resultobj;
4373 fail:
4374 return NULL;
4375 }
4376
4377
4378 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4379 PyObject *resultobj;
4380 wxString result;
4381 char *kwnames[] = {
4382 NULL
4383 };
4384
4385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4386 {
4387 PyThreadState* __tstate = wxPyBeginAllowThreads();
4388 result = wxGetUserName();
4389
4390 wxPyEndAllowThreads(__tstate);
4391 if (PyErr_Occurred()) SWIG_fail;
4392 }
4393 {
4394 #if wxUSE_UNICODE
4395 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4396 #else
4397 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4398 #endif
4399 }
4400 return resultobj;
4401 fail:
4402 return NULL;
4403 }
4404
4405
4406 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4407 PyObject *resultobj;
4408 wxString result;
4409 char *kwnames[] = {
4410 NULL
4411 };
4412
4413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4414 {
4415 PyThreadState* __tstate = wxPyBeginAllowThreads();
4416 result = wxGetHomeDir();
4417
4418 wxPyEndAllowThreads(__tstate);
4419 if (PyErr_Occurred()) SWIG_fail;
4420 }
4421 {
4422 #if wxUSE_UNICODE
4423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4424 #else
4425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4426 #endif
4427 }
4428 return resultobj;
4429 fail:
4430 return NULL;
4431 }
4432
4433
4434 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4435 PyObject *resultobj;
4436 wxString const &arg1_defvalue = wxPyEmptyString ;
4437 wxString *arg1 = (wxString *) &arg1_defvalue ;
4438 wxString result;
4439 bool temp1 = false ;
4440 PyObject * obj0 = 0 ;
4441 char *kwnames[] = {
4442 (char *) "user", NULL
4443 };
4444
4445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4446 if (obj0) {
4447 {
4448 arg1 = wxString_in_helper(obj0);
4449 if (arg1 == NULL) SWIG_fail;
4450 temp1 = true;
4451 }
4452 }
4453 {
4454 PyThreadState* __tstate = wxPyBeginAllowThreads();
4455 result = wxGetUserHome((wxString const &)*arg1);
4456
4457 wxPyEndAllowThreads(__tstate);
4458 if (PyErr_Occurred()) SWIG_fail;
4459 }
4460 {
4461 #if wxUSE_UNICODE
4462 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4463 #else
4464 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4465 #endif
4466 }
4467 {
4468 if (temp1)
4469 delete arg1;
4470 }
4471 return resultobj;
4472 fail:
4473 {
4474 if (temp1)
4475 delete arg1;
4476 }
4477 return NULL;
4478 }
4479
4480
4481 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4482 PyObject *resultobj;
4483 unsigned long result;
4484 char *kwnames[] = {
4485 NULL
4486 };
4487
4488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4489 {
4490 PyThreadState* __tstate = wxPyBeginAllowThreads();
4491 result = (unsigned long)wxGetProcessId();
4492
4493 wxPyEndAllowThreads(__tstate);
4494 if (PyErr_Occurred()) SWIG_fail;
4495 }
4496 {
4497 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4498 }
4499 return resultobj;
4500 fail:
4501 return NULL;
4502 }
4503
4504
4505 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4506 PyObject *resultobj;
4507 char *kwnames[] = {
4508 NULL
4509 };
4510
4511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4512 {
4513 PyThreadState* __tstate = wxPyBeginAllowThreads();
4514 wxTrap();
4515
4516 wxPyEndAllowThreads(__tstate);
4517 if (PyErr_Occurred()) SWIG_fail;
4518 }
4519 Py_INCREF(Py_None); resultobj = Py_None;
4520 return resultobj;
4521 fail:
4522 return NULL;
4523 }
4524
4525
4526 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4527 PyObject *resultobj;
4528 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4529 wxString *arg1 = (wxString *) &arg1_defvalue ;
4530 wxString const &arg2_defvalue = wxPyEmptyString ;
4531 wxString *arg2 = (wxString *) &arg2_defvalue ;
4532 wxString const &arg3_defvalue = wxPyEmptyString ;
4533 wxString *arg3 = (wxString *) &arg3_defvalue ;
4534 wxString const &arg4_defvalue = wxPyEmptyString ;
4535 wxString *arg4 = (wxString *) &arg4_defvalue ;
4536 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4537 wxString *arg5 = (wxString *) &arg5_defvalue ;
4538 int arg6 = (int) 0 ;
4539 wxWindow *arg7 = (wxWindow *) NULL ;
4540 int arg8 = (int) -1 ;
4541 int arg9 = (int) -1 ;
4542 wxString result;
4543 bool temp1 = false ;
4544 bool temp2 = false ;
4545 bool temp3 = false ;
4546 bool temp4 = false ;
4547 bool temp5 = false ;
4548 PyObject * obj0 = 0 ;
4549 PyObject * obj1 = 0 ;
4550 PyObject * obj2 = 0 ;
4551 PyObject * obj3 = 0 ;
4552 PyObject * obj4 = 0 ;
4553 PyObject * obj5 = 0 ;
4554 PyObject * obj6 = 0 ;
4555 PyObject * obj7 = 0 ;
4556 PyObject * obj8 = 0 ;
4557 char *kwnames[] = {
4558 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4559 };
4560
4561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4562 if (obj0) {
4563 {
4564 arg1 = wxString_in_helper(obj0);
4565 if (arg1 == NULL) SWIG_fail;
4566 temp1 = true;
4567 }
4568 }
4569 if (obj1) {
4570 {
4571 arg2 = wxString_in_helper(obj1);
4572 if (arg2 == NULL) SWIG_fail;
4573 temp2 = true;
4574 }
4575 }
4576 if (obj2) {
4577 {
4578 arg3 = wxString_in_helper(obj2);
4579 if (arg3 == NULL) SWIG_fail;
4580 temp3 = true;
4581 }
4582 }
4583 if (obj3) {
4584 {
4585 arg4 = wxString_in_helper(obj3);
4586 if (arg4 == NULL) SWIG_fail;
4587 temp4 = true;
4588 }
4589 }
4590 if (obj4) {
4591 {
4592 arg5 = wxString_in_helper(obj4);
4593 if (arg5 == NULL) SWIG_fail;
4594 temp5 = true;
4595 }
4596 }
4597 if (obj5) {
4598 {
4599 arg6 = (int)(SWIG_As_int(obj5));
4600 if (SWIG_arg_fail(6)) SWIG_fail;
4601 }
4602 }
4603 if (obj6) {
4604 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4605 if (SWIG_arg_fail(7)) SWIG_fail;
4606 }
4607 if (obj7) {
4608 {
4609 arg8 = (int)(SWIG_As_int(obj7));
4610 if (SWIG_arg_fail(8)) SWIG_fail;
4611 }
4612 }
4613 if (obj8) {
4614 {
4615 arg9 = (int)(SWIG_As_int(obj8));
4616 if (SWIG_arg_fail(9)) SWIG_fail;
4617 }
4618 }
4619 {
4620 if (!wxPyCheckForApp()) SWIG_fail;
4621 PyThreadState* __tstate = wxPyBeginAllowThreads();
4622 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4623
4624 wxPyEndAllowThreads(__tstate);
4625 if (PyErr_Occurred()) SWIG_fail;
4626 }
4627 {
4628 #if wxUSE_UNICODE
4629 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4630 #else
4631 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4632 #endif
4633 }
4634 {
4635 if (temp1)
4636 delete arg1;
4637 }
4638 {
4639 if (temp2)
4640 delete arg2;
4641 }
4642 {
4643 if (temp3)
4644 delete arg3;
4645 }
4646 {
4647 if (temp4)
4648 delete arg4;
4649 }
4650 {
4651 if (temp5)
4652 delete arg5;
4653 }
4654 return resultobj;
4655 fail:
4656 {
4657 if (temp1)
4658 delete arg1;
4659 }
4660 {
4661 if (temp2)
4662 delete arg2;
4663 }
4664 {
4665 if (temp3)
4666 delete arg3;
4667 }
4668 {
4669 if (temp4)
4670 delete arg4;
4671 }
4672 {
4673 if (temp5)
4674 delete arg5;
4675 }
4676 return NULL;
4677 }
4678
4679
4680 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4681 PyObject *resultobj;
4682 wxString *arg1 = 0 ;
4683 wxString *arg2 = 0 ;
4684 wxString const &arg3_defvalue = wxPyEmptyString ;
4685 wxString *arg3 = (wxString *) &arg3_defvalue ;
4686 wxWindow *arg4 = (wxWindow *) NULL ;
4687 wxString result;
4688 bool temp1 = false ;
4689 bool temp2 = false ;
4690 bool temp3 = false ;
4691 PyObject * obj0 = 0 ;
4692 PyObject * obj1 = 0 ;
4693 PyObject * obj2 = 0 ;
4694 PyObject * obj3 = 0 ;
4695 char *kwnames[] = {
4696 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4697 };
4698
4699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4700 {
4701 arg1 = wxString_in_helper(obj0);
4702 if (arg1 == NULL) SWIG_fail;
4703 temp1 = true;
4704 }
4705 {
4706 arg2 = wxString_in_helper(obj1);
4707 if (arg2 == NULL) SWIG_fail;
4708 temp2 = true;
4709 }
4710 if (obj2) {
4711 {
4712 arg3 = wxString_in_helper(obj2);
4713 if (arg3 == NULL) SWIG_fail;
4714 temp3 = true;
4715 }
4716 }
4717 if (obj3) {
4718 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4719 if (SWIG_arg_fail(4)) SWIG_fail;
4720 }
4721 {
4722 if (!wxPyCheckForApp()) SWIG_fail;
4723 PyThreadState* __tstate = wxPyBeginAllowThreads();
4724 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4725
4726 wxPyEndAllowThreads(__tstate);
4727 if (PyErr_Occurred()) SWIG_fail;
4728 }
4729 {
4730 #if wxUSE_UNICODE
4731 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4732 #else
4733 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4734 #endif
4735 }
4736 {
4737 if (temp1)
4738 delete arg1;
4739 }
4740 {
4741 if (temp2)
4742 delete arg2;
4743 }
4744 {
4745 if (temp3)
4746 delete arg3;
4747 }
4748 return resultobj;
4749 fail:
4750 {
4751 if (temp1)
4752 delete arg1;
4753 }
4754 {
4755 if (temp2)
4756 delete arg2;
4757 }
4758 {
4759 if (temp3)
4760 delete arg3;
4761 }
4762 return NULL;
4763 }
4764
4765
4766 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4767 PyObject *resultobj;
4768 wxString *arg1 = 0 ;
4769 wxString *arg2 = 0 ;
4770 wxString const &arg3_defvalue = wxPyEmptyString ;
4771 wxString *arg3 = (wxString *) &arg3_defvalue ;
4772 wxWindow *arg4 = (wxWindow *) NULL ;
4773 wxString result;
4774 bool temp1 = false ;
4775 bool temp2 = false ;
4776 bool temp3 = false ;
4777 PyObject * obj0 = 0 ;
4778 PyObject * obj1 = 0 ;
4779 PyObject * obj2 = 0 ;
4780 PyObject * obj3 = 0 ;
4781 char *kwnames[] = {
4782 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4783 };
4784
4785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4786 {
4787 arg1 = wxString_in_helper(obj0);
4788 if (arg1 == NULL) SWIG_fail;
4789 temp1 = true;
4790 }
4791 {
4792 arg2 = wxString_in_helper(obj1);
4793 if (arg2 == NULL) SWIG_fail;
4794 temp2 = true;
4795 }
4796 if (obj2) {
4797 {
4798 arg3 = wxString_in_helper(obj2);
4799 if (arg3 == NULL) SWIG_fail;
4800 temp3 = true;
4801 }
4802 }
4803 if (obj3) {
4804 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4805 if (SWIG_arg_fail(4)) SWIG_fail;
4806 }
4807 {
4808 if (!wxPyCheckForApp()) SWIG_fail;
4809 PyThreadState* __tstate = wxPyBeginAllowThreads();
4810 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4811
4812 wxPyEndAllowThreads(__tstate);
4813 if (PyErr_Occurred()) SWIG_fail;
4814 }
4815 {
4816 #if wxUSE_UNICODE
4817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4818 #else
4819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4820 #endif
4821 }
4822 {
4823 if (temp1)
4824 delete arg1;
4825 }
4826 {
4827 if (temp2)
4828 delete arg2;
4829 }
4830 {
4831 if (temp3)
4832 delete arg3;
4833 }
4834 return resultobj;
4835 fail:
4836 {
4837 if (temp1)
4838 delete arg1;
4839 }
4840 {
4841 if (temp2)
4842 delete arg2;
4843 }
4844 {
4845 if (temp3)
4846 delete arg3;
4847 }
4848 return NULL;
4849 }
4850
4851
4852 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4853 PyObject *resultobj;
4854 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4855 wxString *arg1 = (wxString *) &arg1_defvalue ;
4856 wxString const &arg2_defvalue = wxPyEmptyString ;
4857 wxString *arg2 = (wxString *) &arg2_defvalue ;
4858 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4859 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4860 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4861 wxWindow *arg5 = (wxWindow *) NULL ;
4862 wxString result;
4863 bool temp1 = false ;
4864 bool temp2 = false ;
4865 wxPoint temp4 ;
4866 PyObject * obj0 = 0 ;
4867 PyObject * obj1 = 0 ;
4868 PyObject * obj2 = 0 ;
4869 PyObject * obj3 = 0 ;
4870 PyObject * obj4 = 0 ;
4871 char *kwnames[] = {
4872 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4873 };
4874
4875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4876 if (obj0) {
4877 {
4878 arg1 = wxString_in_helper(obj0);
4879 if (arg1 == NULL) SWIG_fail;
4880 temp1 = true;
4881 }
4882 }
4883 if (obj1) {
4884 {
4885 arg2 = wxString_in_helper(obj1);
4886 if (arg2 == NULL) SWIG_fail;
4887 temp2 = true;
4888 }
4889 }
4890 if (obj2) {
4891 {
4892 arg3 = (long)(SWIG_As_long(obj2));
4893 if (SWIG_arg_fail(3)) SWIG_fail;
4894 }
4895 }
4896 if (obj3) {
4897 {
4898 arg4 = &temp4;
4899 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4900 }
4901 }
4902 if (obj4) {
4903 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4904 if (SWIG_arg_fail(5)) SWIG_fail;
4905 }
4906 {
4907 if (!wxPyCheckForApp()) SWIG_fail;
4908 PyThreadState* __tstate = wxPyBeginAllowThreads();
4909 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4910
4911 wxPyEndAllowThreads(__tstate);
4912 if (PyErr_Occurred()) SWIG_fail;
4913 }
4914 {
4915 #if wxUSE_UNICODE
4916 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4917 #else
4918 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4919 #endif
4920 }
4921 {
4922 if (temp1)
4923 delete arg1;
4924 }
4925 {
4926 if (temp2)
4927 delete arg2;
4928 }
4929 return resultobj;
4930 fail:
4931 {
4932 if (temp1)
4933 delete arg1;
4934 }
4935 {
4936 if (temp2)
4937 delete arg2;
4938 }
4939 return NULL;
4940 }
4941
4942
4943 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4944 PyObject *resultobj;
4945 wxString *arg1 = 0 ;
4946 wxString const &arg2_defvalue = wxPyEmptyString ;
4947 wxString *arg2 = (wxString *) &arg2_defvalue ;
4948 wxString const &arg3_defvalue = wxPyEmptyString ;
4949 wxString *arg3 = (wxString *) &arg3_defvalue ;
4950 wxWindow *arg4 = (wxWindow *) NULL ;
4951 int arg5 = (int) -1 ;
4952 int arg6 = (int) -1 ;
4953 bool arg7 = (bool) true ;
4954 wxString result;
4955 bool temp1 = false ;
4956 bool temp2 = false ;
4957 bool temp3 = false ;
4958 PyObject * obj0 = 0 ;
4959 PyObject * obj1 = 0 ;
4960 PyObject * obj2 = 0 ;
4961 PyObject * obj3 = 0 ;
4962 PyObject * obj4 = 0 ;
4963 PyObject * obj5 = 0 ;
4964 PyObject * obj6 = 0 ;
4965 char *kwnames[] = {
4966 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4967 };
4968
4969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4970 {
4971 arg1 = wxString_in_helper(obj0);
4972 if (arg1 == NULL) SWIG_fail;
4973 temp1 = true;
4974 }
4975 if (obj1) {
4976 {
4977 arg2 = wxString_in_helper(obj1);
4978 if (arg2 == NULL) SWIG_fail;
4979 temp2 = true;
4980 }
4981 }
4982 if (obj2) {
4983 {
4984 arg3 = wxString_in_helper(obj2);
4985 if (arg3 == NULL) SWIG_fail;
4986 temp3 = true;
4987 }
4988 }
4989 if (obj3) {
4990 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4991 if (SWIG_arg_fail(4)) SWIG_fail;
4992 }
4993 if (obj4) {
4994 {
4995 arg5 = (int)(SWIG_As_int(obj4));
4996 if (SWIG_arg_fail(5)) SWIG_fail;
4997 }
4998 }
4999 if (obj5) {
5000 {
5001 arg6 = (int)(SWIG_As_int(obj5));
5002 if (SWIG_arg_fail(6)) SWIG_fail;
5003 }
5004 }
5005 if (obj6) {
5006 {
5007 arg7 = (bool)(SWIG_As_bool(obj6));
5008 if (SWIG_arg_fail(7)) SWIG_fail;
5009 }
5010 }
5011 {
5012 if (!wxPyCheckForApp()) SWIG_fail;
5013 PyThreadState* __tstate = wxPyBeginAllowThreads();
5014 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
5015
5016 wxPyEndAllowThreads(__tstate);
5017 if (PyErr_Occurred()) SWIG_fail;
5018 }
5019 {
5020 #if wxUSE_UNICODE
5021 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5022 #else
5023 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5024 #endif
5025 }
5026 {
5027 if (temp1)
5028 delete arg1;
5029 }
5030 {
5031 if (temp2)
5032 delete arg2;
5033 }
5034 {
5035 if (temp3)
5036 delete arg3;
5037 }
5038 return resultobj;
5039 fail:
5040 {
5041 if (temp1)
5042 delete arg1;
5043 }
5044 {
5045 if (temp2)
5046 delete arg2;
5047 }
5048 {
5049 if (temp3)
5050 delete arg3;
5051 }
5052 return NULL;
5053 }
5054
5055
5056 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5057 PyObject *resultobj;
5058 wxString *arg1 = 0 ;
5059 wxString const &arg2_defvalue = wxPyEmptyString ;
5060 wxString *arg2 = (wxString *) &arg2_defvalue ;
5061 wxString const &arg3_defvalue = wxPyEmptyString ;
5062 wxString *arg3 = (wxString *) &arg3_defvalue ;
5063 wxWindow *arg4 = (wxWindow *) NULL ;
5064 wxString result;
5065 bool temp1 = false ;
5066 bool temp2 = false ;
5067 bool temp3 = false ;
5068 PyObject * obj0 = 0 ;
5069 PyObject * obj1 = 0 ;
5070 PyObject * obj2 = 0 ;
5071 PyObject * obj3 = 0 ;
5072 char *kwnames[] = {
5073 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5074 };
5075
5076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5077 {
5078 arg1 = wxString_in_helper(obj0);
5079 if (arg1 == NULL) SWIG_fail;
5080 temp1 = true;
5081 }
5082 if (obj1) {
5083 {
5084 arg2 = wxString_in_helper(obj1);
5085 if (arg2 == NULL) SWIG_fail;
5086 temp2 = true;
5087 }
5088 }
5089 if (obj2) {
5090 {
5091 arg3 = wxString_in_helper(obj2);
5092 if (arg3 == NULL) SWIG_fail;
5093 temp3 = true;
5094 }
5095 }
5096 if (obj3) {
5097 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5098 if (SWIG_arg_fail(4)) SWIG_fail;
5099 }
5100 {
5101 if (!wxPyCheckForApp()) SWIG_fail;
5102 PyThreadState* __tstate = wxPyBeginAllowThreads();
5103 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5104
5105 wxPyEndAllowThreads(__tstate);
5106 if (PyErr_Occurred()) SWIG_fail;
5107 }
5108 {
5109 #if wxUSE_UNICODE
5110 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5111 #else
5112 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5113 #endif
5114 }
5115 {
5116 if (temp1)
5117 delete arg1;
5118 }
5119 {
5120 if (temp2)
5121 delete arg2;
5122 }
5123 {
5124 if (temp3)
5125 delete arg3;
5126 }
5127 return resultobj;
5128 fail:
5129 {
5130 if (temp1)
5131 delete arg1;
5132 }
5133 {
5134 if (temp2)
5135 delete arg2;
5136 }
5137 {
5138 if (temp3)
5139 delete arg3;
5140 }
5141 return NULL;
5142 }
5143
5144
5145 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5146 PyObject *resultobj;
5147 wxString *arg1 = 0 ;
5148 wxString *arg2 = 0 ;
5149 int arg3 ;
5150 wxString *arg4 = (wxString *) 0 ;
5151 wxWindow *arg5 = (wxWindow *) NULL ;
5152 int arg6 = (int) -1 ;
5153 int arg7 = (int) -1 ;
5154 bool arg8 = (bool) true ;
5155 int arg9 = (int) 150 ;
5156 int arg10 = (int) 200 ;
5157 wxString result;
5158 bool temp1 = false ;
5159 bool temp2 = false ;
5160 PyObject * obj0 = 0 ;
5161 PyObject * obj1 = 0 ;
5162 PyObject * obj2 = 0 ;
5163 PyObject * obj3 = 0 ;
5164 PyObject * obj4 = 0 ;
5165 PyObject * obj5 = 0 ;
5166 PyObject * obj6 = 0 ;
5167 PyObject * obj7 = 0 ;
5168 PyObject * obj8 = 0 ;
5169 char *kwnames[] = {
5170 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5171 };
5172
5173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5174 {
5175 arg1 = wxString_in_helper(obj0);
5176 if (arg1 == NULL) SWIG_fail;
5177 temp1 = true;
5178 }
5179 {
5180 arg2 = wxString_in_helper(obj1);
5181 if (arg2 == NULL) SWIG_fail;
5182 temp2 = true;
5183 }
5184 {
5185 arg3 = PyList_Size(obj2);
5186 arg4 = wxString_LIST_helper(obj2);
5187 if (arg4 == NULL) SWIG_fail;
5188 }
5189 if (obj3) {
5190 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5191 if (SWIG_arg_fail(5)) SWIG_fail;
5192 }
5193 if (obj4) {
5194 {
5195 arg6 = (int)(SWIG_As_int(obj4));
5196 if (SWIG_arg_fail(6)) SWIG_fail;
5197 }
5198 }
5199 if (obj5) {
5200 {
5201 arg7 = (int)(SWIG_As_int(obj5));
5202 if (SWIG_arg_fail(7)) SWIG_fail;
5203 }
5204 }
5205 if (obj6) {
5206 {
5207 arg8 = (bool)(SWIG_As_bool(obj6));
5208 if (SWIG_arg_fail(8)) SWIG_fail;
5209 }
5210 }
5211 if (obj7) {
5212 {
5213 arg9 = (int)(SWIG_As_int(obj7));
5214 if (SWIG_arg_fail(9)) SWIG_fail;
5215 }
5216 }
5217 if (obj8) {
5218 {
5219 arg10 = (int)(SWIG_As_int(obj8));
5220 if (SWIG_arg_fail(10)) SWIG_fail;
5221 }
5222 }
5223 {
5224 if (!wxPyCheckForApp()) SWIG_fail;
5225 PyThreadState* __tstate = wxPyBeginAllowThreads();
5226 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5227
5228 wxPyEndAllowThreads(__tstate);
5229 if (PyErr_Occurred()) SWIG_fail;
5230 }
5231 {
5232 #if wxUSE_UNICODE
5233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5234 #else
5235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5236 #endif
5237 }
5238 {
5239 if (temp1)
5240 delete arg1;
5241 }
5242 {
5243 if (temp2)
5244 delete arg2;
5245 }
5246 {
5247 if (arg4) delete [] arg4;
5248 }
5249 return resultobj;
5250 fail:
5251 {
5252 if (temp1)
5253 delete arg1;
5254 }
5255 {
5256 if (temp2)
5257 delete arg2;
5258 }
5259 {
5260 if (arg4) delete [] arg4;
5261 }
5262 return NULL;
5263 }
5264
5265
5266 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5267 PyObject *resultobj;
5268 wxString *arg1 = 0 ;
5269 wxString *arg2 = 0 ;
5270 int arg3 ;
5271 wxString *arg4 = (wxString *) 0 ;
5272 wxWindow *arg5 = (wxWindow *) NULL ;
5273 int arg6 = (int) -1 ;
5274 int arg7 = (int) -1 ;
5275 bool arg8 = (bool) true ;
5276 int arg9 = (int) 150 ;
5277 int arg10 = (int) 200 ;
5278 int result;
5279 bool temp1 = false ;
5280 bool temp2 = false ;
5281 PyObject * obj0 = 0 ;
5282 PyObject * obj1 = 0 ;
5283 PyObject * obj2 = 0 ;
5284 PyObject * obj3 = 0 ;
5285 PyObject * obj4 = 0 ;
5286 PyObject * obj5 = 0 ;
5287 PyObject * obj6 = 0 ;
5288 PyObject * obj7 = 0 ;
5289 PyObject * obj8 = 0 ;
5290 char *kwnames[] = {
5291 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5292 };
5293
5294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5295 {
5296 arg1 = wxString_in_helper(obj0);
5297 if (arg1 == NULL) SWIG_fail;
5298 temp1 = true;
5299 }
5300 {
5301 arg2 = wxString_in_helper(obj1);
5302 if (arg2 == NULL) SWIG_fail;
5303 temp2 = true;
5304 }
5305 {
5306 arg3 = PyList_Size(obj2);
5307 arg4 = wxString_LIST_helper(obj2);
5308 if (arg4 == NULL) SWIG_fail;
5309 }
5310 if (obj3) {
5311 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5312 if (SWIG_arg_fail(5)) SWIG_fail;
5313 }
5314 if (obj4) {
5315 {
5316 arg6 = (int)(SWIG_As_int(obj4));
5317 if (SWIG_arg_fail(6)) SWIG_fail;
5318 }
5319 }
5320 if (obj5) {
5321 {
5322 arg7 = (int)(SWIG_As_int(obj5));
5323 if (SWIG_arg_fail(7)) SWIG_fail;
5324 }
5325 }
5326 if (obj6) {
5327 {
5328 arg8 = (bool)(SWIG_As_bool(obj6));
5329 if (SWIG_arg_fail(8)) SWIG_fail;
5330 }
5331 }
5332 if (obj7) {
5333 {
5334 arg9 = (int)(SWIG_As_int(obj7));
5335 if (SWIG_arg_fail(9)) SWIG_fail;
5336 }
5337 }
5338 if (obj8) {
5339 {
5340 arg10 = (int)(SWIG_As_int(obj8));
5341 if (SWIG_arg_fail(10)) SWIG_fail;
5342 }
5343 }
5344 {
5345 if (!wxPyCheckForApp()) SWIG_fail;
5346 PyThreadState* __tstate = wxPyBeginAllowThreads();
5347 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5348
5349 wxPyEndAllowThreads(__tstate);
5350 if (PyErr_Occurred()) SWIG_fail;
5351 }
5352 {
5353 resultobj = SWIG_From_int((int)(result));
5354 }
5355 {
5356 if (temp1)
5357 delete arg1;
5358 }
5359 {
5360 if (temp2)
5361 delete arg2;
5362 }
5363 {
5364 if (arg4) delete [] arg4;
5365 }
5366 return resultobj;
5367 fail:
5368 {
5369 if (temp1)
5370 delete arg1;
5371 }
5372 {
5373 if (temp2)
5374 delete arg2;
5375 }
5376 {
5377 if (arg4) delete [] arg4;
5378 }
5379 return NULL;
5380 }
5381
5382
5383 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5384 PyObject *resultobj;
5385 wxString *arg1 = 0 ;
5386 wxString const &arg2_defvalue = wxPyEmptyString ;
5387 wxString *arg2 = (wxString *) &arg2_defvalue ;
5388 int arg3 = (int) wxOK|wxCENTRE ;
5389 wxWindow *arg4 = (wxWindow *) NULL ;
5390 int arg5 = (int) -1 ;
5391 int arg6 = (int) -1 ;
5392 int result;
5393 bool temp1 = false ;
5394 bool temp2 = false ;
5395 PyObject * obj0 = 0 ;
5396 PyObject * obj1 = 0 ;
5397 PyObject * obj2 = 0 ;
5398 PyObject * obj3 = 0 ;
5399 PyObject * obj4 = 0 ;
5400 PyObject * obj5 = 0 ;
5401 char *kwnames[] = {
5402 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5403 };
5404
5405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5406 {
5407 arg1 = wxString_in_helper(obj0);
5408 if (arg1 == NULL) SWIG_fail;
5409 temp1 = true;
5410 }
5411 if (obj1) {
5412 {
5413 arg2 = wxString_in_helper(obj1);
5414 if (arg2 == NULL) SWIG_fail;
5415 temp2 = true;
5416 }
5417 }
5418 if (obj2) {
5419 {
5420 arg3 = (int)(SWIG_As_int(obj2));
5421 if (SWIG_arg_fail(3)) SWIG_fail;
5422 }
5423 }
5424 if (obj3) {
5425 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5426 if (SWIG_arg_fail(4)) SWIG_fail;
5427 }
5428 if (obj4) {
5429 {
5430 arg5 = (int)(SWIG_As_int(obj4));
5431 if (SWIG_arg_fail(5)) SWIG_fail;
5432 }
5433 }
5434 if (obj5) {
5435 {
5436 arg6 = (int)(SWIG_As_int(obj5));
5437 if (SWIG_arg_fail(6)) SWIG_fail;
5438 }
5439 }
5440 {
5441 if (!wxPyCheckForApp()) SWIG_fail;
5442 PyThreadState* __tstate = wxPyBeginAllowThreads();
5443 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5444
5445 wxPyEndAllowThreads(__tstate);
5446 if (PyErr_Occurred()) SWIG_fail;
5447 }
5448 {
5449 resultobj = SWIG_From_int((int)(result));
5450 }
5451 {
5452 if (temp1)
5453 delete arg1;
5454 }
5455 {
5456 if (temp2)
5457 delete arg2;
5458 }
5459 return resultobj;
5460 fail:
5461 {
5462 if (temp1)
5463 delete arg1;
5464 }
5465 {
5466 if (temp2)
5467 delete arg2;
5468 }
5469 return NULL;
5470 }
5471
5472
5473 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5474 PyObject *resultobj;
5475 wxString *arg1 = 0 ;
5476 wxString *arg2 = 0 ;
5477 wxString *arg3 = 0 ;
5478 long arg4 ;
5479 long arg5 = (long) 0 ;
5480 long arg6 = (long) 100 ;
5481 wxWindow *arg7 = (wxWindow *) NULL ;
5482 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5483 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5484 long result;
5485 bool temp1 = false ;
5486 bool temp2 = false ;
5487 bool temp3 = false ;
5488 wxPoint temp8 ;
5489 PyObject * obj0 = 0 ;
5490 PyObject * obj1 = 0 ;
5491 PyObject * obj2 = 0 ;
5492 PyObject * obj3 = 0 ;
5493 PyObject * obj4 = 0 ;
5494 PyObject * obj5 = 0 ;
5495 PyObject * obj6 = 0 ;
5496 PyObject * obj7 = 0 ;
5497 char *kwnames[] = {
5498 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5499 };
5500
5501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5502 {
5503 arg1 = wxString_in_helper(obj0);
5504 if (arg1 == NULL) SWIG_fail;
5505 temp1 = true;
5506 }
5507 {
5508 arg2 = wxString_in_helper(obj1);
5509 if (arg2 == NULL) SWIG_fail;
5510 temp2 = true;
5511 }
5512 {
5513 arg3 = wxString_in_helper(obj2);
5514 if (arg3 == NULL) SWIG_fail;
5515 temp3 = true;
5516 }
5517 {
5518 arg4 = (long)(SWIG_As_long(obj3));
5519 if (SWIG_arg_fail(4)) SWIG_fail;
5520 }
5521 if (obj4) {
5522 {
5523 arg5 = (long)(SWIG_As_long(obj4));
5524 if (SWIG_arg_fail(5)) SWIG_fail;
5525 }
5526 }
5527 if (obj5) {
5528 {
5529 arg6 = (long)(SWIG_As_long(obj5));
5530 if (SWIG_arg_fail(6)) SWIG_fail;
5531 }
5532 }
5533 if (obj6) {
5534 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5535 if (SWIG_arg_fail(7)) SWIG_fail;
5536 }
5537 if (obj7) {
5538 {
5539 arg8 = &temp8;
5540 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5541 }
5542 }
5543 {
5544 if (!wxPyCheckForApp()) SWIG_fail;
5545 PyThreadState* __tstate = wxPyBeginAllowThreads();
5546 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5547
5548 wxPyEndAllowThreads(__tstate);
5549 if (PyErr_Occurred()) SWIG_fail;
5550 }
5551 {
5552 resultobj = SWIG_From_long((long)(result));
5553 }
5554 {
5555 if (temp1)
5556 delete arg1;
5557 }
5558 {
5559 if (temp2)
5560 delete arg2;
5561 }
5562 {
5563 if (temp3)
5564 delete arg3;
5565 }
5566 return resultobj;
5567 fail:
5568 {
5569 if (temp1)
5570 delete arg1;
5571 }
5572 {
5573 if (temp2)
5574 delete arg2;
5575 }
5576 {
5577 if (temp3)
5578 delete arg3;
5579 }
5580 return NULL;
5581 }
5582
5583
5584 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5585 PyObject *resultobj;
5586 bool result;
5587 char *kwnames[] = {
5588 NULL
5589 };
5590
5591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5592 {
5593 if (!wxPyCheckForApp()) SWIG_fail;
5594 PyThreadState* __tstate = wxPyBeginAllowThreads();
5595 result = (bool)wxColourDisplay();
5596
5597 wxPyEndAllowThreads(__tstate);
5598 if (PyErr_Occurred()) SWIG_fail;
5599 }
5600 {
5601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5602 }
5603 return resultobj;
5604 fail:
5605 return NULL;
5606 }
5607
5608
5609 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5610 PyObject *resultobj;
5611 int result;
5612 char *kwnames[] = {
5613 NULL
5614 };
5615
5616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5617 {
5618 if (!wxPyCheckForApp()) SWIG_fail;
5619 PyThreadState* __tstate = wxPyBeginAllowThreads();
5620 result = (int)wxDisplayDepth();
5621
5622 wxPyEndAllowThreads(__tstate);
5623 if (PyErr_Occurred()) SWIG_fail;
5624 }
5625 {
5626 resultobj = SWIG_From_int((int)(result));
5627 }
5628 return resultobj;
5629 fail:
5630 return NULL;
5631 }
5632
5633
5634 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5635 PyObject *resultobj;
5636 int result;
5637 char *kwnames[] = {
5638 NULL
5639 };
5640
5641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5642 {
5643 if (!wxPyCheckForApp()) SWIG_fail;
5644 PyThreadState* __tstate = wxPyBeginAllowThreads();
5645 result = (int)wxGetDisplayDepth();
5646
5647 wxPyEndAllowThreads(__tstate);
5648 if (PyErr_Occurred()) SWIG_fail;
5649 }
5650 {
5651 resultobj = SWIG_From_int((int)(result));
5652 }
5653 return resultobj;
5654 fail:
5655 return NULL;
5656 }
5657
5658
5659 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5660 PyObject *resultobj;
5661 int *arg1 = (int *) 0 ;
5662 int *arg2 = (int *) 0 ;
5663 int temp1 ;
5664 int res1 = 0 ;
5665 int temp2 ;
5666 int res2 = 0 ;
5667 char *kwnames[] = {
5668 NULL
5669 };
5670
5671 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5672 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5674 {
5675 if (!wxPyCheckForApp()) SWIG_fail;
5676 PyThreadState* __tstate = wxPyBeginAllowThreads();
5677 wxDisplaySize(arg1,arg2);
5678
5679 wxPyEndAllowThreads(__tstate);
5680 if (PyErr_Occurred()) SWIG_fail;
5681 }
5682 Py_INCREF(Py_None); resultobj = Py_None;
5683 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5684 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5685 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5686 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5687 return resultobj;
5688 fail:
5689 return NULL;
5690 }
5691
5692
5693 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5694 PyObject *resultobj;
5695 wxSize result;
5696 char *kwnames[] = {
5697 NULL
5698 };
5699
5700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5701 {
5702 if (!wxPyCheckForApp()) SWIG_fail;
5703 PyThreadState* __tstate = wxPyBeginAllowThreads();
5704 result = wxGetDisplaySize();
5705
5706 wxPyEndAllowThreads(__tstate);
5707 if (PyErr_Occurred()) SWIG_fail;
5708 }
5709 {
5710 wxSize * resultptr;
5711 resultptr = new wxSize((wxSize &)(result));
5712 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5713 }
5714 return resultobj;
5715 fail:
5716 return NULL;
5717 }
5718
5719
5720 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5721 PyObject *resultobj;
5722 int *arg1 = (int *) 0 ;
5723 int *arg2 = (int *) 0 ;
5724 int temp1 ;
5725 int res1 = 0 ;
5726 int temp2 ;
5727 int res2 = 0 ;
5728 char *kwnames[] = {
5729 NULL
5730 };
5731
5732 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5733 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5735 {
5736 if (!wxPyCheckForApp()) SWIG_fail;
5737 PyThreadState* __tstate = wxPyBeginAllowThreads();
5738 wxDisplaySizeMM(arg1,arg2);
5739
5740 wxPyEndAllowThreads(__tstate);
5741 if (PyErr_Occurred()) SWIG_fail;
5742 }
5743 Py_INCREF(Py_None); resultobj = Py_None;
5744 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5745 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5746 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5747 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5748 return resultobj;
5749 fail:
5750 return NULL;
5751 }
5752
5753
5754 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5755 PyObject *resultobj;
5756 wxSize result;
5757 char *kwnames[] = {
5758 NULL
5759 };
5760
5761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5762 {
5763 if (!wxPyCheckForApp()) SWIG_fail;
5764 PyThreadState* __tstate = wxPyBeginAllowThreads();
5765 result = wxGetDisplaySizeMM();
5766
5767 wxPyEndAllowThreads(__tstate);
5768 if (PyErr_Occurred()) SWIG_fail;
5769 }
5770 {
5771 wxSize * resultptr;
5772 resultptr = new wxSize((wxSize &)(result));
5773 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5774 }
5775 return resultobj;
5776 fail:
5777 return NULL;
5778 }
5779
5780
5781 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5782 PyObject *resultobj;
5783 int *arg1 = (int *) 0 ;
5784 int *arg2 = (int *) 0 ;
5785 int *arg3 = (int *) 0 ;
5786 int *arg4 = (int *) 0 ;
5787 int temp1 ;
5788 int res1 = 0 ;
5789 int temp2 ;
5790 int res2 = 0 ;
5791 int temp3 ;
5792 int res3 = 0 ;
5793 int temp4 ;
5794 int res4 = 0 ;
5795 char *kwnames[] = {
5796 NULL
5797 };
5798
5799 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5800 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5801 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5802 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5804 {
5805 if (!wxPyCheckForApp()) SWIG_fail;
5806 PyThreadState* __tstate = wxPyBeginAllowThreads();
5807 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5808
5809 wxPyEndAllowThreads(__tstate);
5810 if (PyErr_Occurred()) SWIG_fail;
5811 }
5812 Py_INCREF(Py_None); resultobj = Py_None;
5813 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5814 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5815 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5816 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5817 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5818 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5819 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5820 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5821 return resultobj;
5822 fail:
5823 return NULL;
5824 }
5825
5826
5827 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5828 PyObject *resultobj;
5829 wxRect result;
5830 char *kwnames[] = {
5831 NULL
5832 };
5833
5834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5835 {
5836 if (!wxPyCheckForApp()) SWIG_fail;
5837 PyThreadState* __tstate = wxPyBeginAllowThreads();
5838 result = wxGetClientDisplayRect();
5839
5840 wxPyEndAllowThreads(__tstate);
5841 if (PyErr_Occurred()) SWIG_fail;
5842 }
5843 {
5844 wxRect * resultptr;
5845 resultptr = new wxRect((wxRect &)(result));
5846 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5847 }
5848 return resultobj;
5849 fail:
5850 return NULL;
5851 }
5852
5853
5854 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5855 PyObject *resultobj;
5856 wxCursor *arg1 = 0 ;
5857 PyObject * obj0 = 0 ;
5858 char *kwnames[] = {
5859 (char *) "cursor", NULL
5860 };
5861
5862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5863 {
5864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5865 if (SWIG_arg_fail(1)) SWIG_fail;
5866 if (arg1 == NULL) {
5867 SWIG_null_ref("wxCursor");
5868 }
5869 if (SWIG_arg_fail(1)) SWIG_fail;
5870 }
5871 {
5872 if (!wxPyCheckForApp()) SWIG_fail;
5873 PyThreadState* __tstate = wxPyBeginAllowThreads();
5874 wxSetCursor(*arg1);
5875
5876 wxPyEndAllowThreads(__tstate);
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 Py_INCREF(Py_None); resultobj = Py_None;
5880 return resultobj;
5881 fail:
5882 return NULL;
5883 }
5884
5885
5886 static PyObject *_wrap_GetXDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5887 PyObject *resultobj;
5888 void *result;
5889 char *kwnames[] = {
5890 NULL
5891 };
5892
5893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetXDisplay",kwnames)) goto fail;
5894 {
5895 if (!wxPyCheckForApp()) SWIG_fail;
5896 PyThreadState* __tstate = wxPyBeginAllowThreads();
5897 result = (void *)wxGetXDisplay();
5898
5899 wxPyEndAllowThreads(__tstate);
5900 if (PyErr_Occurred()) SWIG_fail;
5901 }
5902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
5903 return resultobj;
5904 fail:
5905 return NULL;
5906 }
5907
5908
5909 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5910 PyObject *resultobj;
5911 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5912 PyObject * obj0 = 0 ;
5913 char *kwnames[] = {
5914 (char *) "cursor", NULL
5915 };
5916
5917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5918 if (obj0) {
5919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5920 if (SWIG_arg_fail(1)) SWIG_fail;
5921 }
5922 {
5923 if (!wxPyCheckForApp()) SWIG_fail;
5924 PyThreadState* __tstate = wxPyBeginAllowThreads();
5925 wxBeginBusyCursor(arg1);
5926
5927 wxPyEndAllowThreads(__tstate);
5928 if (PyErr_Occurred()) SWIG_fail;
5929 }
5930 Py_INCREF(Py_None); resultobj = Py_None;
5931 return resultobj;
5932 fail:
5933 return NULL;
5934 }
5935
5936
5937 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5938 PyObject *resultobj;
5939 wxWindow *result;
5940 char *kwnames[] = {
5941 NULL
5942 };
5943
5944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5945 {
5946 if (!wxPyCheckForApp()) SWIG_fail;
5947 PyThreadState* __tstate = wxPyBeginAllowThreads();
5948 result = (wxWindow *)wxGetActiveWindow();
5949
5950 wxPyEndAllowThreads(__tstate);
5951 if (PyErr_Occurred()) SWIG_fail;
5952 }
5953 {
5954 resultobj = wxPyMake_wxObject(result, 0);
5955 }
5956 return resultobj;
5957 fail:
5958 return NULL;
5959 }
5960
5961
5962 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5963 PyObject *resultobj;
5964 wxPoint *arg1 = 0 ;
5965 wxWindow *result;
5966 wxPoint temp1 ;
5967 PyObject * obj0 = 0 ;
5968 char *kwnames[] = {
5969 (char *) "pt", NULL
5970 };
5971
5972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5973 {
5974 arg1 = &temp1;
5975 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5976 }
5977 {
5978 if (!wxPyCheckForApp()) SWIG_fail;
5979 PyThreadState* __tstate = wxPyBeginAllowThreads();
5980 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5981
5982 wxPyEndAllowThreads(__tstate);
5983 if (PyErr_Occurred()) SWIG_fail;
5984 }
5985 {
5986 resultobj = wxPyMake_wxObject(result, 0);
5987 }
5988 return resultobj;
5989 fail:
5990 return NULL;
5991 }
5992
5993
5994 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5995 PyObject *resultobj;
5996 wxPoint *arg1 = 0 ;
5997 wxWindow *result;
5998 wxPoint temp1 ;
5999 PyObject * obj0 = 0 ;
6000 char *kwnames[] = {
6001 (char *) "pt", NULL
6002 };
6003
6004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
6005 {
6006 arg1 = &temp1;
6007 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6008 }
6009 {
6010 if (!wxPyCheckForApp()) SWIG_fail;
6011 PyThreadState* __tstate = wxPyBeginAllowThreads();
6012 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6013
6014 wxPyEndAllowThreads(__tstate);
6015 if (PyErr_Occurred()) SWIG_fail;
6016 }
6017 {
6018 resultobj = wxPyMake_wxObject(result, 0);
6019 }
6020 return resultobj;
6021 fail:
6022 return NULL;
6023 }
6024
6025
6026 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
6027 PyObject *resultobj;
6028 wxWindow *arg1 = (wxWindow *) 0 ;
6029 wxWindow *result;
6030 PyObject * obj0 = 0 ;
6031 char *kwnames[] = {
6032 (char *) "win", NULL
6033 };
6034
6035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
6036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6037 if (SWIG_arg_fail(1)) SWIG_fail;
6038 {
6039 if (!wxPyCheckForApp()) SWIG_fail;
6040 PyThreadState* __tstate = wxPyBeginAllowThreads();
6041 result = (wxWindow *)wxGetTopLevelParent(arg1);
6042
6043 wxPyEndAllowThreads(__tstate);
6044 if (PyErr_Occurred()) SWIG_fail;
6045 }
6046 {
6047 resultobj = wxPyMake_wxObject(result, 0);
6048 }
6049 return resultobj;
6050 fail:
6051 return NULL;
6052 }
6053
6054
6055 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
6056 PyObject *resultobj;
6057 wxString *arg1 = 0 ;
6058 bool result;
6059 bool temp1 = false ;
6060 PyObject * obj0 = 0 ;
6061 char *kwnames[] = {
6062 (char *) "url", NULL
6063 };
6064
6065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
6066 {
6067 arg1 = wxString_in_helper(obj0);
6068 if (arg1 == NULL) SWIG_fail;
6069 temp1 = true;
6070 }
6071 {
6072 PyThreadState* __tstate = wxPyBeginAllowThreads();
6073 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
6074
6075 wxPyEndAllowThreads(__tstate);
6076 if (PyErr_Occurred()) SWIG_fail;
6077 }
6078 {
6079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6080 }
6081 {
6082 if (temp1)
6083 delete arg1;
6084 }
6085 return resultobj;
6086 fail:
6087 {
6088 if (temp1)
6089 delete arg1;
6090 }
6091 return NULL;
6092 }
6093
6094
6095 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6096 PyObject *resultobj;
6097 wxKeyCode arg1 ;
6098 bool result;
6099 PyObject * obj0 = 0 ;
6100 char *kwnames[] = {
6101 (char *) "key", NULL
6102 };
6103
6104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6105 {
6106 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6107 if (SWIG_arg_fail(1)) SWIG_fail;
6108 }
6109 {
6110 if (!wxPyCheckForApp()) SWIG_fail;
6111 PyThreadState* __tstate = wxPyBeginAllowThreads();
6112 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6113
6114 wxPyEndAllowThreads(__tstate);
6115 if (PyErr_Occurred()) SWIG_fail;
6116 }
6117 {
6118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6119 }
6120 return resultobj;
6121 fail:
6122 return NULL;
6123 }
6124
6125
6126 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6127 PyObject *resultobj;
6128 char *kwnames[] = {
6129 NULL
6130 };
6131
6132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6133 {
6134 if (!wxPyCheckForApp()) SWIG_fail;
6135 PyThreadState* __tstate = wxPyBeginAllowThreads();
6136 wxWakeUpMainThread();
6137
6138 wxPyEndAllowThreads(__tstate);
6139 if (PyErr_Occurred()) SWIG_fail;
6140 }
6141 Py_INCREF(Py_None); resultobj = Py_None;
6142 return resultobj;
6143 fail:
6144 return NULL;
6145 }
6146
6147
6148 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6149 PyObject *resultobj;
6150 char *kwnames[] = {
6151 NULL
6152 };
6153
6154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6155 {
6156 if (!wxPyCheckForApp()) SWIG_fail;
6157 PyThreadState* __tstate = wxPyBeginAllowThreads();
6158 wxMutexGuiEnter();
6159
6160 wxPyEndAllowThreads(__tstate);
6161 if (PyErr_Occurred()) SWIG_fail;
6162 }
6163 Py_INCREF(Py_None); resultobj = Py_None;
6164 return resultobj;
6165 fail:
6166 return NULL;
6167 }
6168
6169
6170 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6171 PyObject *resultobj;
6172 char *kwnames[] = {
6173 NULL
6174 };
6175
6176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6177 {
6178 if (!wxPyCheckForApp()) SWIG_fail;
6179 PyThreadState* __tstate = wxPyBeginAllowThreads();
6180 wxMutexGuiLeave();
6181
6182 wxPyEndAllowThreads(__tstate);
6183 if (PyErr_Occurred()) SWIG_fail;
6184 }
6185 Py_INCREF(Py_None); resultobj = Py_None;
6186 return resultobj;
6187 fail:
6188 return NULL;
6189 }
6190
6191
6192 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6193 PyObject *resultobj;
6194 wxMutexGuiLocker *result;
6195 char *kwnames[] = {
6196 NULL
6197 };
6198
6199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6200 {
6201 if (!wxPyCheckForApp()) SWIG_fail;
6202 PyThreadState* __tstate = wxPyBeginAllowThreads();
6203 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6204
6205 wxPyEndAllowThreads(__tstate);
6206 if (PyErr_Occurred()) SWIG_fail;
6207 }
6208 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6209 return resultobj;
6210 fail:
6211 return NULL;
6212 }
6213
6214
6215 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6216 PyObject *resultobj;
6217 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6218 PyObject * obj0 = 0 ;
6219 char *kwnames[] = {
6220 (char *) "self", NULL
6221 };
6222
6223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6225 if (SWIG_arg_fail(1)) SWIG_fail;
6226 {
6227 PyThreadState* __tstate = wxPyBeginAllowThreads();
6228 delete arg1;
6229
6230 wxPyEndAllowThreads(__tstate);
6231 if (PyErr_Occurred()) SWIG_fail;
6232 }
6233 Py_INCREF(Py_None); resultobj = Py_None;
6234 return resultobj;
6235 fail:
6236 return NULL;
6237 }
6238
6239
6240 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6241 PyObject *obj;
6242 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6243 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6244 Py_INCREF(obj);
6245 return Py_BuildValue((char *)"");
6246 }
6247 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6248 PyObject *resultobj;
6249 bool result;
6250 char *kwnames[] = {
6251 NULL
6252 };
6253
6254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6255 {
6256 PyThreadState* __tstate = wxPyBeginAllowThreads();
6257 result = (bool)wxThread_IsMain();
6258
6259 wxPyEndAllowThreads(__tstate);
6260 if (PyErr_Occurred()) SWIG_fail;
6261 }
6262 {
6263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6264 }
6265 return resultobj;
6266 fail:
6267 return NULL;
6268 }
6269
6270
6271 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6272 PyObject *resultobj;
6273 wxString *arg1 = 0 ;
6274 wxToolTip *result;
6275 bool temp1 = false ;
6276 PyObject * obj0 = 0 ;
6277 char *kwnames[] = {
6278 (char *) "tip", NULL
6279 };
6280
6281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6282 {
6283 arg1 = wxString_in_helper(obj0);
6284 if (arg1 == NULL) SWIG_fail;
6285 temp1 = true;
6286 }
6287 {
6288 if (!wxPyCheckForApp()) SWIG_fail;
6289 PyThreadState* __tstate = wxPyBeginAllowThreads();
6290 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6291
6292 wxPyEndAllowThreads(__tstate);
6293 if (PyErr_Occurred()) SWIG_fail;
6294 }
6295 {
6296 resultobj = wxPyMake_wxObject(result, 1);
6297 }
6298 {
6299 if (temp1)
6300 delete arg1;
6301 }
6302 return resultobj;
6303 fail:
6304 {
6305 if (temp1)
6306 delete arg1;
6307 }
6308 return NULL;
6309 }
6310
6311
6312 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6313 PyObject *resultobj;
6314 wxToolTip *arg1 = (wxToolTip *) 0 ;
6315 wxString *arg2 = 0 ;
6316 bool temp2 = false ;
6317 PyObject * obj0 = 0 ;
6318 PyObject * obj1 = 0 ;
6319 char *kwnames[] = {
6320 (char *) "self",(char *) "tip", NULL
6321 };
6322
6323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6325 if (SWIG_arg_fail(1)) SWIG_fail;
6326 {
6327 arg2 = wxString_in_helper(obj1);
6328 if (arg2 == NULL) SWIG_fail;
6329 temp2 = true;
6330 }
6331 {
6332 PyThreadState* __tstate = wxPyBeginAllowThreads();
6333 (arg1)->SetTip((wxString const &)*arg2);
6334
6335 wxPyEndAllowThreads(__tstate);
6336 if (PyErr_Occurred()) SWIG_fail;
6337 }
6338 Py_INCREF(Py_None); resultobj = Py_None;
6339 {
6340 if (temp2)
6341 delete arg2;
6342 }
6343 return resultobj;
6344 fail:
6345 {
6346 if (temp2)
6347 delete arg2;
6348 }
6349 return NULL;
6350 }
6351
6352
6353 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6354 PyObject *resultobj;
6355 wxToolTip *arg1 = (wxToolTip *) 0 ;
6356 wxString result;
6357 PyObject * obj0 = 0 ;
6358 char *kwnames[] = {
6359 (char *) "self", NULL
6360 };
6361
6362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6364 if (SWIG_arg_fail(1)) SWIG_fail;
6365 {
6366 PyThreadState* __tstate = wxPyBeginAllowThreads();
6367 result = (arg1)->GetTip();
6368
6369 wxPyEndAllowThreads(__tstate);
6370 if (PyErr_Occurred()) SWIG_fail;
6371 }
6372 {
6373 #if wxUSE_UNICODE
6374 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6375 #else
6376 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6377 #endif
6378 }
6379 return resultobj;
6380 fail:
6381 return NULL;
6382 }
6383
6384
6385 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6386 PyObject *resultobj;
6387 wxToolTip *arg1 = (wxToolTip *) 0 ;
6388 wxWindow *result;
6389 PyObject * obj0 = 0 ;
6390 char *kwnames[] = {
6391 (char *) "self", NULL
6392 };
6393
6394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6396 if (SWIG_arg_fail(1)) SWIG_fail;
6397 {
6398 PyThreadState* __tstate = wxPyBeginAllowThreads();
6399 result = (wxWindow *)(arg1)->GetWindow();
6400
6401 wxPyEndAllowThreads(__tstate);
6402 if (PyErr_Occurred()) SWIG_fail;
6403 }
6404 {
6405 resultobj = wxPyMake_wxObject(result, 0);
6406 }
6407 return resultobj;
6408 fail:
6409 return NULL;
6410 }
6411
6412
6413 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6414 PyObject *resultobj;
6415 bool arg1 ;
6416 PyObject * obj0 = 0 ;
6417 char *kwnames[] = {
6418 (char *) "flag", NULL
6419 };
6420
6421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6422 {
6423 arg1 = (bool)(SWIG_As_bool(obj0));
6424 if (SWIG_arg_fail(1)) SWIG_fail;
6425 }
6426 {
6427 PyThreadState* __tstate = wxPyBeginAllowThreads();
6428 wxToolTip::Enable(arg1);
6429
6430 wxPyEndAllowThreads(__tstate);
6431 if (PyErr_Occurred()) SWIG_fail;
6432 }
6433 Py_INCREF(Py_None); resultobj = Py_None;
6434 return resultobj;
6435 fail:
6436 return NULL;
6437 }
6438
6439
6440 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6441 PyObject *resultobj;
6442 long arg1 ;
6443 PyObject * obj0 = 0 ;
6444 char *kwnames[] = {
6445 (char *) "milliseconds", NULL
6446 };
6447
6448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6449 {
6450 arg1 = (long)(SWIG_As_long(obj0));
6451 if (SWIG_arg_fail(1)) SWIG_fail;
6452 }
6453 {
6454 PyThreadState* __tstate = wxPyBeginAllowThreads();
6455 wxToolTip::SetDelay(arg1);
6456
6457 wxPyEndAllowThreads(__tstate);
6458 if (PyErr_Occurred()) SWIG_fail;
6459 }
6460 Py_INCREF(Py_None); resultobj = Py_None;
6461 return resultobj;
6462 fail:
6463 return NULL;
6464 }
6465
6466
6467 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6468 PyObject *obj;
6469 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6470 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6471 Py_INCREF(obj);
6472 return Py_BuildValue((char *)"");
6473 }
6474 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6475 PyObject *resultobj;
6476 wxWindow *arg1 = (wxWindow *) 0 ;
6477 wxSize *arg2 = 0 ;
6478 wxCaret *result;
6479 wxSize temp2 ;
6480 PyObject * obj0 = 0 ;
6481 PyObject * obj1 = 0 ;
6482 char *kwnames[] = {
6483 (char *) "window",(char *) "size", NULL
6484 };
6485
6486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6488 if (SWIG_arg_fail(1)) SWIG_fail;
6489 {
6490 arg2 = &temp2;
6491 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6492 }
6493 {
6494 if (!wxPyCheckForApp()) SWIG_fail;
6495 PyThreadState* __tstate = wxPyBeginAllowThreads();
6496 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6497
6498 wxPyEndAllowThreads(__tstate);
6499 if (PyErr_Occurred()) SWIG_fail;
6500 }
6501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6502 return resultobj;
6503 fail:
6504 return NULL;
6505 }
6506
6507
6508 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6509 PyObject *resultobj;
6510 wxCaret *arg1 = (wxCaret *) 0 ;
6511 PyObject * obj0 = 0 ;
6512 char *kwnames[] = {
6513 (char *) "self", NULL
6514 };
6515
6516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6518 if (SWIG_arg_fail(1)) SWIG_fail;
6519 {
6520 PyThreadState* __tstate = wxPyBeginAllowThreads();
6521 wxCaret_Destroy(arg1);
6522
6523 wxPyEndAllowThreads(__tstate);
6524 if (PyErr_Occurred()) SWIG_fail;
6525 }
6526 Py_INCREF(Py_None); resultobj = Py_None;
6527 return resultobj;
6528 fail:
6529 return NULL;
6530 }
6531
6532
6533 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6534 PyObject *resultobj;
6535 wxCaret *arg1 = (wxCaret *) 0 ;
6536 bool result;
6537 PyObject * obj0 = 0 ;
6538 char *kwnames[] = {
6539 (char *) "self", NULL
6540 };
6541
6542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6544 if (SWIG_arg_fail(1)) SWIG_fail;
6545 {
6546 PyThreadState* __tstate = wxPyBeginAllowThreads();
6547 result = (bool)(arg1)->IsOk();
6548
6549 wxPyEndAllowThreads(__tstate);
6550 if (PyErr_Occurred()) SWIG_fail;
6551 }
6552 {
6553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6554 }
6555 return resultobj;
6556 fail:
6557 return NULL;
6558 }
6559
6560
6561 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6562 PyObject *resultobj;
6563 wxCaret *arg1 = (wxCaret *) 0 ;
6564 bool result;
6565 PyObject * obj0 = 0 ;
6566 char *kwnames[] = {
6567 (char *) "self", NULL
6568 };
6569
6570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6572 if (SWIG_arg_fail(1)) SWIG_fail;
6573 {
6574 PyThreadState* __tstate = wxPyBeginAllowThreads();
6575 result = (bool)(arg1)->IsVisible();
6576
6577 wxPyEndAllowThreads(__tstate);
6578 if (PyErr_Occurred()) SWIG_fail;
6579 }
6580 {
6581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6582 }
6583 return resultobj;
6584 fail:
6585 return NULL;
6586 }
6587
6588
6589 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6590 PyObject *resultobj;
6591 wxCaret *arg1 = (wxCaret *) 0 ;
6592 wxPoint result;
6593 PyObject * obj0 = 0 ;
6594 char *kwnames[] = {
6595 (char *) "self", NULL
6596 };
6597
6598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6600 if (SWIG_arg_fail(1)) SWIG_fail;
6601 {
6602 PyThreadState* __tstate = wxPyBeginAllowThreads();
6603 result = (arg1)->GetPosition();
6604
6605 wxPyEndAllowThreads(__tstate);
6606 if (PyErr_Occurred()) SWIG_fail;
6607 }
6608 {
6609 wxPoint * resultptr;
6610 resultptr = new wxPoint((wxPoint &)(result));
6611 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6612 }
6613 return resultobj;
6614 fail:
6615 return NULL;
6616 }
6617
6618
6619 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6620 PyObject *resultobj;
6621 wxCaret *arg1 = (wxCaret *) 0 ;
6622 int *arg2 = (int *) 0 ;
6623 int *arg3 = (int *) 0 ;
6624 int temp2 ;
6625 int res2 = 0 ;
6626 int temp3 ;
6627 int res3 = 0 ;
6628 PyObject * obj0 = 0 ;
6629 char *kwnames[] = {
6630 (char *) "self", NULL
6631 };
6632
6633 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6634 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6637 if (SWIG_arg_fail(1)) SWIG_fail;
6638 {
6639 PyThreadState* __tstate = wxPyBeginAllowThreads();
6640 (arg1)->GetPosition(arg2,arg3);
6641
6642 wxPyEndAllowThreads(__tstate);
6643 if (PyErr_Occurred()) SWIG_fail;
6644 }
6645 Py_INCREF(Py_None); resultobj = Py_None;
6646 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6647 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6648 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6649 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6650 return resultobj;
6651 fail:
6652 return NULL;
6653 }
6654
6655
6656 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6657 PyObject *resultobj;
6658 wxCaret *arg1 = (wxCaret *) 0 ;
6659 wxSize result;
6660 PyObject * obj0 = 0 ;
6661 char *kwnames[] = {
6662 (char *) "self", NULL
6663 };
6664
6665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6667 if (SWIG_arg_fail(1)) SWIG_fail;
6668 {
6669 PyThreadState* __tstate = wxPyBeginAllowThreads();
6670 result = (arg1)->GetSize();
6671
6672 wxPyEndAllowThreads(__tstate);
6673 if (PyErr_Occurred()) SWIG_fail;
6674 }
6675 {
6676 wxSize * resultptr;
6677 resultptr = new wxSize((wxSize &)(result));
6678 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6679 }
6680 return resultobj;
6681 fail:
6682 return NULL;
6683 }
6684
6685
6686 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6687 PyObject *resultobj;
6688 wxCaret *arg1 = (wxCaret *) 0 ;
6689 int *arg2 = (int *) 0 ;
6690 int *arg3 = (int *) 0 ;
6691 int temp2 ;
6692 int res2 = 0 ;
6693 int temp3 ;
6694 int res3 = 0 ;
6695 PyObject * obj0 = 0 ;
6696 char *kwnames[] = {
6697 (char *) "self", NULL
6698 };
6699
6700 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6701 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6704 if (SWIG_arg_fail(1)) SWIG_fail;
6705 {
6706 PyThreadState* __tstate = wxPyBeginAllowThreads();
6707 (arg1)->GetSize(arg2,arg3);
6708
6709 wxPyEndAllowThreads(__tstate);
6710 if (PyErr_Occurred()) SWIG_fail;
6711 }
6712 Py_INCREF(Py_None); resultobj = Py_None;
6713 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6714 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6715 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6716 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6717 return resultobj;
6718 fail:
6719 return NULL;
6720 }
6721
6722
6723 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6724 PyObject *resultobj;
6725 wxCaret *arg1 = (wxCaret *) 0 ;
6726 wxWindow *result;
6727 PyObject * obj0 = 0 ;
6728 char *kwnames[] = {
6729 (char *) "self", NULL
6730 };
6731
6732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6734 if (SWIG_arg_fail(1)) SWIG_fail;
6735 {
6736 PyThreadState* __tstate = wxPyBeginAllowThreads();
6737 result = (wxWindow *)(arg1)->GetWindow();
6738
6739 wxPyEndAllowThreads(__tstate);
6740 if (PyErr_Occurred()) SWIG_fail;
6741 }
6742 {
6743 resultobj = wxPyMake_wxObject(result, 0);
6744 }
6745 return resultobj;
6746 fail:
6747 return NULL;
6748 }
6749
6750
6751 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6752 PyObject *resultobj;
6753 wxCaret *arg1 = (wxCaret *) 0 ;
6754 int arg2 ;
6755 int arg3 ;
6756 PyObject * obj0 = 0 ;
6757 PyObject * obj1 = 0 ;
6758 PyObject * obj2 = 0 ;
6759 char *kwnames[] = {
6760 (char *) "self",(char *) "x",(char *) "y", NULL
6761 };
6762
6763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6765 if (SWIG_arg_fail(1)) SWIG_fail;
6766 {
6767 arg2 = (int)(SWIG_As_int(obj1));
6768 if (SWIG_arg_fail(2)) SWIG_fail;
6769 }
6770 {
6771 arg3 = (int)(SWIG_As_int(obj2));
6772 if (SWIG_arg_fail(3)) SWIG_fail;
6773 }
6774 {
6775 PyThreadState* __tstate = wxPyBeginAllowThreads();
6776 (arg1)->Move(arg2,arg3);
6777
6778 wxPyEndAllowThreads(__tstate);
6779 if (PyErr_Occurred()) SWIG_fail;
6780 }
6781 Py_INCREF(Py_None); resultobj = Py_None;
6782 return resultobj;
6783 fail:
6784 return NULL;
6785 }
6786
6787
6788 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6789 PyObject *resultobj;
6790 wxCaret *arg1 = (wxCaret *) 0 ;
6791 wxPoint *arg2 = 0 ;
6792 wxPoint temp2 ;
6793 PyObject * obj0 = 0 ;
6794 PyObject * obj1 = 0 ;
6795 char *kwnames[] = {
6796 (char *) "self",(char *) "pt", NULL
6797 };
6798
6799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6801 if (SWIG_arg_fail(1)) SWIG_fail;
6802 {
6803 arg2 = &temp2;
6804 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6805 }
6806 {
6807 PyThreadState* __tstate = wxPyBeginAllowThreads();
6808 (arg1)->Move((wxPoint const &)*arg2);
6809
6810 wxPyEndAllowThreads(__tstate);
6811 if (PyErr_Occurred()) SWIG_fail;
6812 }
6813 Py_INCREF(Py_None); resultobj = Py_None;
6814 return resultobj;
6815 fail:
6816 return NULL;
6817 }
6818
6819
6820 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6821 PyObject *resultobj;
6822 wxCaret *arg1 = (wxCaret *) 0 ;
6823 int arg2 ;
6824 int arg3 ;
6825 PyObject * obj0 = 0 ;
6826 PyObject * obj1 = 0 ;
6827 PyObject * obj2 = 0 ;
6828 char *kwnames[] = {
6829 (char *) "self",(char *) "width",(char *) "height", NULL
6830 };
6831
6832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6834 if (SWIG_arg_fail(1)) SWIG_fail;
6835 {
6836 arg2 = (int)(SWIG_As_int(obj1));
6837 if (SWIG_arg_fail(2)) SWIG_fail;
6838 }
6839 {
6840 arg3 = (int)(SWIG_As_int(obj2));
6841 if (SWIG_arg_fail(3)) SWIG_fail;
6842 }
6843 {
6844 PyThreadState* __tstate = wxPyBeginAllowThreads();
6845 (arg1)->SetSize(arg2,arg3);
6846
6847 wxPyEndAllowThreads(__tstate);
6848 if (PyErr_Occurred()) SWIG_fail;
6849 }
6850 Py_INCREF(Py_None); resultobj = Py_None;
6851 return resultobj;
6852 fail:
6853 return NULL;
6854 }
6855
6856
6857 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6858 PyObject *resultobj;
6859 wxCaret *arg1 = (wxCaret *) 0 ;
6860 wxSize *arg2 = 0 ;
6861 wxSize temp2 ;
6862 PyObject * obj0 = 0 ;
6863 PyObject * obj1 = 0 ;
6864 char *kwnames[] = {
6865 (char *) "self",(char *) "size", NULL
6866 };
6867
6868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6870 if (SWIG_arg_fail(1)) SWIG_fail;
6871 {
6872 arg2 = &temp2;
6873 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6874 }
6875 {
6876 PyThreadState* __tstate = wxPyBeginAllowThreads();
6877 (arg1)->SetSize((wxSize const &)*arg2);
6878
6879 wxPyEndAllowThreads(__tstate);
6880 if (PyErr_Occurred()) SWIG_fail;
6881 }
6882 Py_INCREF(Py_None); resultobj = Py_None;
6883 return resultobj;
6884 fail:
6885 return NULL;
6886 }
6887
6888
6889 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6890 PyObject *resultobj;
6891 wxCaret *arg1 = (wxCaret *) 0 ;
6892 int arg2 = (int) true ;
6893 PyObject * obj0 = 0 ;
6894 PyObject * obj1 = 0 ;
6895 char *kwnames[] = {
6896 (char *) "self",(char *) "show", NULL
6897 };
6898
6899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6901 if (SWIG_arg_fail(1)) SWIG_fail;
6902 if (obj1) {
6903 {
6904 arg2 = (int)(SWIG_As_int(obj1));
6905 if (SWIG_arg_fail(2)) SWIG_fail;
6906 }
6907 }
6908 {
6909 PyThreadState* __tstate = wxPyBeginAllowThreads();
6910 (arg1)->Show(arg2);
6911
6912 wxPyEndAllowThreads(__tstate);
6913 if (PyErr_Occurred()) SWIG_fail;
6914 }
6915 Py_INCREF(Py_None); resultobj = Py_None;
6916 return resultobj;
6917 fail:
6918 return NULL;
6919 }
6920
6921
6922 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6923 PyObject *resultobj;
6924 wxCaret *arg1 = (wxCaret *) 0 ;
6925 PyObject * obj0 = 0 ;
6926 char *kwnames[] = {
6927 (char *) "self", NULL
6928 };
6929
6930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6932 if (SWIG_arg_fail(1)) SWIG_fail;
6933 {
6934 PyThreadState* __tstate = wxPyBeginAllowThreads();
6935 (arg1)->Hide();
6936
6937 wxPyEndAllowThreads(__tstate);
6938 if (PyErr_Occurred()) SWIG_fail;
6939 }
6940 Py_INCREF(Py_None); resultobj = Py_None;
6941 return resultobj;
6942 fail:
6943 return NULL;
6944 }
6945
6946
6947 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6948 PyObject *resultobj;
6949 int result;
6950 char *kwnames[] = {
6951 NULL
6952 };
6953
6954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6955 {
6956 PyThreadState* __tstate = wxPyBeginAllowThreads();
6957 result = (int)wxCaret::GetBlinkTime();
6958
6959 wxPyEndAllowThreads(__tstate);
6960 if (PyErr_Occurred()) SWIG_fail;
6961 }
6962 {
6963 resultobj = SWIG_From_int((int)(result));
6964 }
6965 return resultobj;
6966 fail:
6967 return NULL;
6968 }
6969
6970
6971 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6972 PyObject *resultobj;
6973 int arg1 ;
6974 PyObject * obj0 = 0 ;
6975 char *kwnames[] = {
6976 (char *) "milliseconds", NULL
6977 };
6978
6979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6980 {
6981 arg1 = (int)(SWIG_As_int(obj0));
6982 if (SWIG_arg_fail(1)) SWIG_fail;
6983 }
6984 {
6985 PyThreadState* __tstate = wxPyBeginAllowThreads();
6986 wxCaret::SetBlinkTime(arg1);
6987
6988 wxPyEndAllowThreads(__tstate);
6989 if (PyErr_Occurred()) SWIG_fail;
6990 }
6991 Py_INCREF(Py_None); resultobj = Py_None;
6992 return resultobj;
6993 fail:
6994 return NULL;
6995 }
6996
6997
6998 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6999 PyObject *obj;
7000 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7001 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
7002 Py_INCREF(obj);
7003 return Py_BuildValue((char *)"");
7004 }
7005 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7006 PyObject *resultobj;
7007 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7008 wxBusyCursor *result;
7009 PyObject * obj0 = 0 ;
7010 char *kwnames[] = {
7011 (char *) "cursor", NULL
7012 };
7013
7014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
7015 if (obj0) {
7016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
7017 if (SWIG_arg_fail(1)) SWIG_fail;
7018 }
7019 {
7020 if (!wxPyCheckForApp()) SWIG_fail;
7021 PyThreadState* __tstate = wxPyBeginAllowThreads();
7022 result = (wxBusyCursor *)new wxBusyCursor(arg1);
7023
7024 wxPyEndAllowThreads(__tstate);
7025 if (PyErr_Occurred()) SWIG_fail;
7026 }
7027 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
7028 return resultobj;
7029 fail:
7030 return NULL;
7031 }
7032
7033
7034 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7035 PyObject *resultobj;
7036 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
7037 PyObject * obj0 = 0 ;
7038 char *kwnames[] = {
7039 (char *) "self", NULL
7040 };
7041
7042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
7043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
7044 if (SWIG_arg_fail(1)) SWIG_fail;
7045 {
7046 PyThreadState* __tstate = wxPyBeginAllowThreads();
7047 delete arg1;
7048
7049 wxPyEndAllowThreads(__tstate);
7050 if (PyErr_Occurred()) SWIG_fail;
7051 }
7052 Py_INCREF(Py_None); resultobj = Py_None;
7053 return resultobj;
7054 fail:
7055 return NULL;
7056 }
7057
7058
7059 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
7060 PyObject *obj;
7061 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7062 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
7063 Py_INCREF(obj);
7064 return Py_BuildValue((char *)"");
7065 }
7066 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7067 PyObject *resultobj;
7068 wxWindow *arg1 = (wxWindow *) NULL ;
7069 wxWindowDisabler *result;
7070 PyObject * obj0 = 0 ;
7071 char *kwnames[] = {
7072 (char *) "winToSkip", NULL
7073 };
7074
7075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7076 if (obj0) {
7077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7078 if (SWIG_arg_fail(1)) SWIG_fail;
7079 }
7080 {
7081 if (!wxPyCheckForApp()) SWIG_fail;
7082 PyThreadState* __tstate = wxPyBeginAllowThreads();
7083 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7084
7085 wxPyEndAllowThreads(__tstate);
7086 if (PyErr_Occurred()) SWIG_fail;
7087 }
7088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7089 return resultobj;
7090 fail:
7091 return NULL;
7092 }
7093
7094
7095 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7096 PyObject *resultobj;
7097 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7098 PyObject * obj0 = 0 ;
7099 char *kwnames[] = {
7100 (char *) "self", NULL
7101 };
7102
7103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7105 if (SWIG_arg_fail(1)) SWIG_fail;
7106 {
7107 PyThreadState* __tstate = wxPyBeginAllowThreads();
7108 delete arg1;
7109
7110 wxPyEndAllowThreads(__tstate);
7111 if (PyErr_Occurred()) SWIG_fail;
7112 }
7113 Py_INCREF(Py_None); resultobj = Py_None;
7114 return resultobj;
7115 fail:
7116 return NULL;
7117 }
7118
7119
7120 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7121 PyObject *obj;
7122 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7123 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7124 Py_INCREF(obj);
7125 return Py_BuildValue((char *)"");
7126 }
7127 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7128 PyObject *resultobj;
7129 wxString *arg1 = 0 ;
7130 wxBusyInfo *result;
7131 bool temp1 = false ;
7132 PyObject * obj0 = 0 ;
7133 char *kwnames[] = {
7134 (char *) "message", NULL
7135 };
7136
7137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7138 {
7139 arg1 = wxString_in_helper(obj0);
7140 if (arg1 == NULL) SWIG_fail;
7141 temp1 = true;
7142 }
7143 {
7144 if (!wxPyCheckForApp()) SWIG_fail;
7145 PyThreadState* __tstate = wxPyBeginAllowThreads();
7146 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7147
7148 wxPyEndAllowThreads(__tstate);
7149 if (PyErr_Occurred()) SWIG_fail;
7150 }
7151 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7152 {
7153 if (temp1)
7154 delete arg1;
7155 }
7156 return resultobj;
7157 fail:
7158 {
7159 if (temp1)
7160 delete arg1;
7161 }
7162 return NULL;
7163 }
7164
7165
7166 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7167 PyObject *resultobj;
7168 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7169 PyObject * obj0 = 0 ;
7170 char *kwnames[] = {
7171 (char *) "self", NULL
7172 };
7173
7174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7176 if (SWIG_arg_fail(1)) SWIG_fail;
7177 {
7178 PyThreadState* __tstate = wxPyBeginAllowThreads();
7179 delete arg1;
7180
7181 wxPyEndAllowThreads(__tstate);
7182 if (PyErr_Occurred()) SWIG_fail;
7183 }
7184 Py_INCREF(Py_None); resultobj = Py_None;
7185 return resultobj;
7186 fail:
7187 return NULL;
7188 }
7189
7190
7191 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7192 PyObject *obj;
7193 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7194 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7195 Py_INCREF(obj);
7196 return Py_BuildValue((char *)"");
7197 }
7198 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7199 PyObject *resultobj;
7200 wxStopWatch *result;
7201 char *kwnames[] = {
7202 NULL
7203 };
7204
7205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7206 {
7207 PyThreadState* __tstate = wxPyBeginAllowThreads();
7208 result = (wxStopWatch *)new wxStopWatch();
7209
7210 wxPyEndAllowThreads(__tstate);
7211 if (PyErr_Occurred()) SWIG_fail;
7212 }
7213 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7214 return resultobj;
7215 fail:
7216 return NULL;
7217 }
7218
7219
7220 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7221 PyObject *resultobj;
7222 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7223 long arg2 = (long) 0 ;
7224 PyObject * obj0 = 0 ;
7225 PyObject * obj1 = 0 ;
7226 char *kwnames[] = {
7227 (char *) "self",(char *) "t0", NULL
7228 };
7229
7230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7232 if (SWIG_arg_fail(1)) SWIG_fail;
7233 if (obj1) {
7234 {
7235 arg2 = (long)(SWIG_As_long(obj1));
7236 if (SWIG_arg_fail(2)) SWIG_fail;
7237 }
7238 }
7239 {
7240 PyThreadState* __tstate = wxPyBeginAllowThreads();
7241 (arg1)->Start(arg2);
7242
7243 wxPyEndAllowThreads(__tstate);
7244 if (PyErr_Occurred()) SWIG_fail;
7245 }
7246 Py_INCREF(Py_None); resultobj = Py_None;
7247 return resultobj;
7248 fail:
7249 return NULL;
7250 }
7251
7252
7253 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7254 PyObject *resultobj;
7255 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7256 PyObject * obj0 = 0 ;
7257 char *kwnames[] = {
7258 (char *) "self", NULL
7259 };
7260
7261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7263 if (SWIG_arg_fail(1)) SWIG_fail;
7264 {
7265 PyThreadState* __tstate = wxPyBeginAllowThreads();
7266 (arg1)->Pause();
7267
7268 wxPyEndAllowThreads(__tstate);
7269 if (PyErr_Occurred()) SWIG_fail;
7270 }
7271 Py_INCREF(Py_None); resultobj = Py_None;
7272 return resultobj;
7273 fail:
7274 return NULL;
7275 }
7276
7277
7278 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7279 PyObject *resultobj;
7280 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7281 PyObject * obj0 = 0 ;
7282 char *kwnames[] = {
7283 (char *) "self", NULL
7284 };
7285
7286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7288 if (SWIG_arg_fail(1)) SWIG_fail;
7289 {
7290 PyThreadState* __tstate = wxPyBeginAllowThreads();
7291 (arg1)->Resume();
7292
7293 wxPyEndAllowThreads(__tstate);
7294 if (PyErr_Occurred()) SWIG_fail;
7295 }
7296 Py_INCREF(Py_None); resultobj = Py_None;
7297 return resultobj;
7298 fail:
7299 return NULL;
7300 }
7301
7302
7303 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7304 PyObject *resultobj;
7305 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7306 long result;
7307 PyObject * obj0 = 0 ;
7308 char *kwnames[] = {
7309 (char *) "self", NULL
7310 };
7311
7312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7314 if (SWIG_arg_fail(1)) SWIG_fail;
7315 {
7316 PyThreadState* __tstate = wxPyBeginAllowThreads();
7317 result = (long)((wxStopWatch const *)arg1)->Time();
7318
7319 wxPyEndAllowThreads(__tstate);
7320 if (PyErr_Occurred()) SWIG_fail;
7321 }
7322 {
7323 resultobj = SWIG_From_long((long)(result));
7324 }
7325 return resultobj;
7326 fail:
7327 return NULL;
7328 }
7329
7330
7331 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7332 PyObject *obj;
7333 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7334 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7335 Py_INCREF(obj);
7336 return Py_BuildValue((char *)"");
7337 }
7338 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7339 PyObject *resultobj;
7340 int arg1 = (int) 9 ;
7341 int arg2 = (int) wxID_FILE1 ;
7342 wxFileHistory *result;
7343 PyObject * obj0 = 0 ;
7344 PyObject * obj1 = 0 ;
7345 char *kwnames[] = {
7346 (char *) "maxFiles",(char *) "idBase", NULL
7347 };
7348
7349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7350 if (obj0) {
7351 {
7352 arg1 = (int)(SWIG_As_int(obj0));
7353 if (SWIG_arg_fail(1)) SWIG_fail;
7354 }
7355 }
7356 if (obj1) {
7357 {
7358 arg2 = (int)(SWIG_As_int(obj1));
7359 if (SWIG_arg_fail(2)) SWIG_fail;
7360 }
7361 }
7362 {
7363 PyThreadState* __tstate = wxPyBeginAllowThreads();
7364 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7365
7366 wxPyEndAllowThreads(__tstate);
7367 if (PyErr_Occurred()) SWIG_fail;
7368 }
7369 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7370 return resultobj;
7371 fail:
7372 return NULL;
7373 }
7374
7375
7376 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7377 PyObject *resultobj;
7378 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7379 PyObject * obj0 = 0 ;
7380 char *kwnames[] = {
7381 (char *) "self", NULL
7382 };
7383
7384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7386 if (SWIG_arg_fail(1)) SWIG_fail;
7387 {
7388 PyThreadState* __tstate = wxPyBeginAllowThreads();
7389 delete arg1;
7390
7391 wxPyEndAllowThreads(__tstate);
7392 if (PyErr_Occurred()) SWIG_fail;
7393 }
7394 Py_INCREF(Py_None); resultobj = Py_None;
7395 return resultobj;
7396 fail:
7397 return NULL;
7398 }
7399
7400
7401 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7402 PyObject *resultobj;
7403 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7404 wxString *arg2 = 0 ;
7405 bool temp2 = false ;
7406 PyObject * obj0 = 0 ;
7407 PyObject * obj1 = 0 ;
7408 char *kwnames[] = {
7409 (char *) "self",(char *) "file", NULL
7410 };
7411
7412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7414 if (SWIG_arg_fail(1)) SWIG_fail;
7415 {
7416 arg2 = wxString_in_helper(obj1);
7417 if (arg2 == NULL) SWIG_fail;
7418 temp2 = true;
7419 }
7420 {
7421 PyThreadState* __tstate = wxPyBeginAllowThreads();
7422 (arg1)->AddFileToHistory((wxString const &)*arg2);
7423
7424 wxPyEndAllowThreads(__tstate);
7425 if (PyErr_Occurred()) SWIG_fail;
7426 }
7427 Py_INCREF(Py_None); resultobj = Py_None;
7428 {
7429 if (temp2)
7430 delete arg2;
7431 }
7432 return resultobj;
7433 fail:
7434 {
7435 if (temp2)
7436 delete arg2;
7437 }
7438 return NULL;
7439 }
7440
7441
7442 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7443 PyObject *resultobj;
7444 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7445 int arg2 ;
7446 PyObject * obj0 = 0 ;
7447 PyObject * obj1 = 0 ;
7448 char *kwnames[] = {
7449 (char *) "self",(char *) "i", NULL
7450 };
7451
7452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7454 if (SWIG_arg_fail(1)) SWIG_fail;
7455 {
7456 arg2 = (int)(SWIG_As_int(obj1));
7457 if (SWIG_arg_fail(2)) SWIG_fail;
7458 }
7459 {
7460 PyThreadState* __tstate = wxPyBeginAllowThreads();
7461 (arg1)->RemoveFileFromHistory(arg2);
7462
7463 wxPyEndAllowThreads(__tstate);
7464 if (PyErr_Occurred()) SWIG_fail;
7465 }
7466 Py_INCREF(Py_None); resultobj = Py_None;
7467 return resultobj;
7468 fail:
7469 return NULL;
7470 }
7471
7472
7473 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7474 PyObject *resultobj;
7475 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7476 int result;
7477 PyObject * obj0 = 0 ;
7478 char *kwnames[] = {
7479 (char *) "self", NULL
7480 };
7481
7482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7484 if (SWIG_arg_fail(1)) SWIG_fail;
7485 {
7486 PyThreadState* __tstate = wxPyBeginAllowThreads();
7487 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7488
7489 wxPyEndAllowThreads(__tstate);
7490 if (PyErr_Occurred()) SWIG_fail;
7491 }
7492 {
7493 resultobj = SWIG_From_int((int)(result));
7494 }
7495 return resultobj;
7496 fail:
7497 return NULL;
7498 }
7499
7500
7501 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7502 PyObject *resultobj;
7503 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7504 wxMenu *arg2 = (wxMenu *) 0 ;
7505 PyObject * obj0 = 0 ;
7506 PyObject * obj1 = 0 ;
7507 char *kwnames[] = {
7508 (char *) "self",(char *) "menu", NULL
7509 };
7510
7511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7513 if (SWIG_arg_fail(1)) SWIG_fail;
7514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7515 if (SWIG_arg_fail(2)) SWIG_fail;
7516 {
7517 PyThreadState* __tstate = wxPyBeginAllowThreads();
7518 (arg1)->UseMenu(arg2);
7519
7520 wxPyEndAllowThreads(__tstate);
7521 if (PyErr_Occurred()) SWIG_fail;
7522 }
7523 Py_INCREF(Py_None); resultobj = Py_None;
7524 return resultobj;
7525 fail:
7526 return NULL;
7527 }
7528
7529
7530 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7531 PyObject *resultobj;
7532 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7533 wxMenu *arg2 = (wxMenu *) 0 ;
7534 PyObject * obj0 = 0 ;
7535 PyObject * obj1 = 0 ;
7536 char *kwnames[] = {
7537 (char *) "self",(char *) "menu", NULL
7538 };
7539
7540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7542 if (SWIG_arg_fail(1)) SWIG_fail;
7543 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7544 if (SWIG_arg_fail(2)) SWIG_fail;
7545 {
7546 PyThreadState* __tstate = wxPyBeginAllowThreads();
7547 (arg1)->RemoveMenu(arg2);
7548
7549 wxPyEndAllowThreads(__tstate);
7550 if (PyErr_Occurred()) SWIG_fail;
7551 }
7552 Py_INCREF(Py_None); resultobj = Py_None;
7553 return resultobj;
7554 fail:
7555 return NULL;
7556 }
7557
7558
7559 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7560 PyObject *resultobj;
7561 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7562 wxConfigBase *arg2 = 0 ;
7563 PyObject * obj0 = 0 ;
7564 PyObject * obj1 = 0 ;
7565 char *kwnames[] = {
7566 (char *) "self",(char *) "config", NULL
7567 };
7568
7569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7571 if (SWIG_arg_fail(1)) SWIG_fail;
7572 {
7573 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7574 if (SWIG_arg_fail(2)) SWIG_fail;
7575 if (arg2 == NULL) {
7576 SWIG_null_ref("wxConfigBase");
7577 }
7578 if (SWIG_arg_fail(2)) SWIG_fail;
7579 }
7580 {
7581 PyThreadState* __tstate = wxPyBeginAllowThreads();
7582 (arg1)->Load(*arg2);
7583
7584 wxPyEndAllowThreads(__tstate);
7585 if (PyErr_Occurred()) SWIG_fail;
7586 }
7587 Py_INCREF(Py_None); resultobj = Py_None;
7588 return resultobj;
7589 fail:
7590 return NULL;
7591 }
7592
7593
7594 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7595 PyObject *resultobj;
7596 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7597 wxConfigBase *arg2 = 0 ;
7598 PyObject * obj0 = 0 ;
7599 PyObject * obj1 = 0 ;
7600 char *kwnames[] = {
7601 (char *) "self",(char *) "config", NULL
7602 };
7603
7604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7606 if (SWIG_arg_fail(1)) SWIG_fail;
7607 {
7608 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7609 if (SWIG_arg_fail(2)) SWIG_fail;
7610 if (arg2 == NULL) {
7611 SWIG_null_ref("wxConfigBase");
7612 }
7613 if (SWIG_arg_fail(2)) SWIG_fail;
7614 }
7615 {
7616 PyThreadState* __tstate = wxPyBeginAllowThreads();
7617 (arg1)->Save(*arg2);
7618
7619 wxPyEndAllowThreads(__tstate);
7620 if (PyErr_Occurred()) SWIG_fail;
7621 }
7622 Py_INCREF(Py_None); resultobj = Py_None;
7623 return resultobj;
7624 fail:
7625 return NULL;
7626 }
7627
7628
7629 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7630 PyObject *resultobj;
7631 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7632 PyObject * obj0 = 0 ;
7633 char *kwnames[] = {
7634 (char *) "self", NULL
7635 };
7636
7637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7639 if (SWIG_arg_fail(1)) SWIG_fail;
7640 {
7641 PyThreadState* __tstate = wxPyBeginAllowThreads();
7642 (arg1)->AddFilesToMenu();
7643
7644 wxPyEndAllowThreads(__tstate);
7645 if (PyErr_Occurred()) SWIG_fail;
7646 }
7647 Py_INCREF(Py_None); resultobj = Py_None;
7648 return resultobj;
7649 fail:
7650 return NULL;
7651 }
7652
7653
7654 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7655 PyObject *resultobj;
7656 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7657 wxMenu *arg2 = (wxMenu *) 0 ;
7658 PyObject * obj0 = 0 ;
7659 PyObject * obj1 = 0 ;
7660 char *kwnames[] = {
7661 (char *) "self",(char *) "menu", NULL
7662 };
7663
7664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7666 if (SWIG_arg_fail(1)) SWIG_fail;
7667 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7668 if (SWIG_arg_fail(2)) SWIG_fail;
7669 {
7670 PyThreadState* __tstate = wxPyBeginAllowThreads();
7671 (arg1)->AddFilesToMenu(arg2);
7672
7673 wxPyEndAllowThreads(__tstate);
7674 if (PyErr_Occurred()) SWIG_fail;
7675 }
7676 Py_INCREF(Py_None); resultobj = Py_None;
7677 return resultobj;
7678 fail:
7679 return NULL;
7680 }
7681
7682
7683 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7684 PyObject *resultobj;
7685 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7686 int arg2 ;
7687 wxString result;
7688 PyObject * obj0 = 0 ;
7689 PyObject * obj1 = 0 ;
7690 char *kwnames[] = {
7691 (char *) "self",(char *) "i", NULL
7692 };
7693
7694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7696 if (SWIG_arg_fail(1)) SWIG_fail;
7697 {
7698 arg2 = (int)(SWIG_As_int(obj1));
7699 if (SWIG_arg_fail(2)) SWIG_fail;
7700 }
7701 {
7702 PyThreadState* __tstate = wxPyBeginAllowThreads();
7703 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7704
7705 wxPyEndAllowThreads(__tstate);
7706 if (PyErr_Occurred()) SWIG_fail;
7707 }
7708 {
7709 #if wxUSE_UNICODE
7710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7711 #else
7712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7713 #endif
7714 }
7715 return resultobj;
7716 fail:
7717 return NULL;
7718 }
7719
7720
7721 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7722 PyObject *resultobj;
7723 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7724 int result;
7725 PyObject * obj0 = 0 ;
7726 char *kwnames[] = {
7727 (char *) "self", NULL
7728 };
7729
7730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7732 if (SWIG_arg_fail(1)) SWIG_fail;
7733 {
7734 PyThreadState* __tstate = wxPyBeginAllowThreads();
7735 result = (int)((wxFileHistory const *)arg1)->GetCount();
7736
7737 wxPyEndAllowThreads(__tstate);
7738 if (PyErr_Occurred()) SWIG_fail;
7739 }
7740 {
7741 resultobj = SWIG_From_int((int)(result));
7742 }
7743 return resultobj;
7744 fail:
7745 return NULL;
7746 }
7747
7748
7749 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7750 PyObject *obj;
7751 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7752 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7753 Py_INCREF(obj);
7754 return Py_BuildValue((char *)"");
7755 }
7756 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7757 PyObject *resultobj;
7758 wxString *arg1 = 0 ;
7759 wxString const &arg2_defvalue = wxPyEmptyString ;
7760 wxString *arg2 = (wxString *) &arg2_defvalue ;
7761 wxSingleInstanceChecker *result;
7762 bool temp1 = false ;
7763 bool temp2 = false ;
7764 PyObject * obj0 = 0 ;
7765 PyObject * obj1 = 0 ;
7766 char *kwnames[] = {
7767 (char *) "name",(char *) "path", NULL
7768 };
7769
7770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7771 {
7772 arg1 = wxString_in_helper(obj0);
7773 if (arg1 == NULL) SWIG_fail;
7774 temp1 = true;
7775 }
7776 if (obj1) {
7777 {
7778 arg2 = wxString_in_helper(obj1);
7779 if (arg2 == NULL) SWIG_fail;
7780 temp2 = true;
7781 }
7782 }
7783 {
7784 PyThreadState* __tstate = wxPyBeginAllowThreads();
7785 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7786
7787 wxPyEndAllowThreads(__tstate);
7788 if (PyErr_Occurred()) SWIG_fail;
7789 }
7790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7791 {
7792 if (temp1)
7793 delete arg1;
7794 }
7795 {
7796 if (temp2)
7797 delete arg2;
7798 }
7799 return resultobj;
7800 fail:
7801 {
7802 if (temp1)
7803 delete arg1;
7804 }
7805 {
7806 if (temp2)
7807 delete arg2;
7808 }
7809 return NULL;
7810 }
7811
7812
7813 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7814 PyObject *resultobj;
7815 wxSingleInstanceChecker *result;
7816 char *kwnames[] = {
7817 NULL
7818 };
7819
7820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7821 {
7822 PyThreadState* __tstate = wxPyBeginAllowThreads();
7823 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7824
7825 wxPyEndAllowThreads(__tstate);
7826 if (PyErr_Occurred()) SWIG_fail;
7827 }
7828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7829 return resultobj;
7830 fail:
7831 return NULL;
7832 }
7833
7834
7835 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7836 PyObject *resultobj;
7837 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7838 PyObject * obj0 = 0 ;
7839 char *kwnames[] = {
7840 (char *) "self", NULL
7841 };
7842
7843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7845 if (SWIG_arg_fail(1)) SWIG_fail;
7846 {
7847 PyThreadState* __tstate = wxPyBeginAllowThreads();
7848 delete arg1;
7849
7850 wxPyEndAllowThreads(__tstate);
7851 if (PyErr_Occurred()) SWIG_fail;
7852 }
7853 Py_INCREF(Py_None); resultobj = Py_None;
7854 return resultobj;
7855 fail:
7856 return NULL;
7857 }
7858
7859
7860 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7861 PyObject *resultobj;
7862 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7863 wxString *arg2 = 0 ;
7864 wxString const &arg3_defvalue = wxPyEmptyString ;
7865 wxString *arg3 = (wxString *) &arg3_defvalue ;
7866 bool result;
7867 bool temp2 = false ;
7868 bool temp3 = false ;
7869 PyObject * obj0 = 0 ;
7870 PyObject * obj1 = 0 ;
7871 PyObject * obj2 = 0 ;
7872 char *kwnames[] = {
7873 (char *) "self",(char *) "name",(char *) "path", NULL
7874 };
7875
7876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7878 if (SWIG_arg_fail(1)) SWIG_fail;
7879 {
7880 arg2 = wxString_in_helper(obj1);
7881 if (arg2 == NULL) SWIG_fail;
7882 temp2 = true;
7883 }
7884 if (obj2) {
7885 {
7886 arg3 = wxString_in_helper(obj2);
7887 if (arg3 == NULL) SWIG_fail;
7888 temp3 = true;
7889 }
7890 }
7891 {
7892 PyThreadState* __tstate = wxPyBeginAllowThreads();
7893 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7894
7895 wxPyEndAllowThreads(__tstate);
7896 if (PyErr_Occurred()) SWIG_fail;
7897 }
7898 {
7899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7900 }
7901 {
7902 if (temp2)
7903 delete arg2;
7904 }
7905 {
7906 if (temp3)
7907 delete arg3;
7908 }
7909 return resultobj;
7910 fail:
7911 {
7912 if (temp2)
7913 delete arg2;
7914 }
7915 {
7916 if (temp3)
7917 delete arg3;
7918 }
7919 return NULL;
7920 }
7921
7922
7923 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7924 PyObject *resultobj;
7925 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7926 bool result;
7927 PyObject * obj0 = 0 ;
7928 char *kwnames[] = {
7929 (char *) "self", NULL
7930 };
7931
7932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7934 if (SWIG_arg_fail(1)) SWIG_fail;
7935 {
7936 PyThreadState* __tstate = wxPyBeginAllowThreads();
7937 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7938
7939 wxPyEndAllowThreads(__tstate);
7940 if (PyErr_Occurred()) SWIG_fail;
7941 }
7942 {
7943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7944 }
7945 return resultobj;
7946 fail:
7947 return NULL;
7948 }
7949
7950
7951 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7952 PyObject *obj;
7953 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7954 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7955 Py_INCREF(obj);
7956 return Py_BuildValue((char *)"");
7957 }
7958 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7959 PyObject *resultobj;
7960 wxWindow *arg1 = (wxWindow *) 0 ;
7961 wxDC *arg2 = 0 ;
7962 bool result;
7963 PyObject * obj0 = 0 ;
7964 PyObject * obj1 = 0 ;
7965 char *kwnames[] = {
7966 (char *) "window",(char *) "dc", NULL
7967 };
7968
7969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7971 if (SWIG_arg_fail(1)) SWIG_fail;
7972 {
7973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7974 if (SWIG_arg_fail(2)) SWIG_fail;
7975 if (arg2 == NULL) {
7976 SWIG_null_ref("wxDC");
7977 }
7978 if (SWIG_arg_fail(2)) SWIG_fail;
7979 }
7980 {
7981 PyThreadState* __tstate = wxPyBeginAllowThreads();
7982 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7983
7984 wxPyEndAllowThreads(__tstate);
7985 if (PyErr_Occurred()) SWIG_fail;
7986 }
7987 {
7988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7989 }
7990 return resultobj;
7991 fail:
7992 return NULL;
7993 }
7994
7995
7996 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7997 PyObject *resultobj;
7998 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7999 PyObject * obj0 = 0 ;
8000 char *kwnames[] = {
8001 (char *) "self", NULL
8002 };
8003
8004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
8005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8006 if (SWIG_arg_fail(1)) SWIG_fail;
8007 {
8008 PyThreadState* __tstate = wxPyBeginAllowThreads();
8009 delete arg1;
8010
8011 wxPyEndAllowThreads(__tstate);
8012 if (PyErr_Occurred()) SWIG_fail;
8013 }
8014 Py_INCREF(Py_None); resultobj = Py_None;
8015 return resultobj;
8016 fail:
8017 return NULL;
8018 }
8019
8020
8021 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
8022 PyObject *resultobj;
8023 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8024 wxString result;
8025 PyObject * obj0 = 0 ;
8026 char *kwnames[] = {
8027 (char *) "self", NULL
8028 };
8029
8030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
8031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8032 if (SWIG_arg_fail(1)) SWIG_fail;
8033 {
8034 PyThreadState* __tstate = wxPyBeginAllowThreads();
8035 result = (arg1)->GetTip();
8036
8037 wxPyEndAllowThreads(__tstate);
8038 if (PyErr_Occurred()) SWIG_fail;
8039 }
8040 {
8041 #if wxUSE_UNICODE
8042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8043 #else
8044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8045 #endif
8046 }
8047 return resultobj;
8048 fail:
8049 return NULL;
8050 }
8051
8052
8053 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
8054 PyObject *resultobj;
8055 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8056 size_t result;
8057 PyObject * obj0 = 0 ;
8058 char *kwnames[] = {
8059 (char *) "self", NULL
8060 };
8061
8062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
8063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8064 if (SWIG_arg_fail(1)) SWIG_fail;
8065 {
8066 PyThreadState* __tstate = wxPyBeginAllowThreads();
8067 result = (size_t)(arg1)->GetCurrentTip();
8068
8069 wxPyEndAllowThreads(__tstate);
8070 if (PyErr_Occurred()) SWIG_fail;
8071 }
8072 {
8073 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8074 }
8075 return resultobj;
8076 fail:
8077 return NULL;
8078 }
8079
8080
8081 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8082 PyObject *resultobj;
8083 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8084 wxString *arg2 = 0 ;
8085 wxString result;
8086 bool temp2 = false ;
8087 PyObject * obj0 = 0 ;
8088 PyObject * obj1 = 0 ;
8089 char *kwnames[] = {
8090 (char *) "self",(char *) "tip", NULL
8091 };
8092
8093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8095 if (SWIG_arg_fail(1)) SWIG_fail;
8096 {
8097 arg2 = wxString_in_helper(obj1);
8098 if (arg2 == NULL) SWIG_fail;
8099 temp2 = true;
8100 }
8101 {
8102 PyThreadState* __tstate = wxPyBeginAllowThreads();
8103 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8104
8105 wxPyEndAllowThreads(__tstate);
8106 if (PyErr_Occurred()) SWIG_fail;
8107 }
8108 {
8109 #if wxUSE_UNICODE
8110 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8111 #else
8112 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8113 #endif
8114 }
8115 {
8116 if (temp2)
8117 delete arg2;
8118 }
8119 return resultobj;
8120 fail:
8121 {
8122 if (temp2)
8123 delete arg2;
8124 }
8125 return NULL;
8126 }
8127
8128
8129 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8130 PyObject *obj;
8131 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8132 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8133 Py_INCREF(obj);
8134 return Py_BuildValue((char *)"");
8135 }
8136 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8137 PyObject *resultobj;
8138 size_t arg1 ;
8139 wxPyTipProvider *result;
8140 PyObject * obj0 = 0 ;
8141 char *kwnames[] = {
8142 (char *) "currentTip", NULL
8143 };
8144
8145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8146 {
8147 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8148 if (SWIG_arg_fail(1)) SWIG_fail;
8149 }
8150 {
8151 PyThreadState* __tstate = wxPyBeginAllowThreads();
8152 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8153
8154 wxPyEndAllowThreads(__tstate);
8155 if (PyErr_Occurred()) SWIG_fail;
8156 }
8157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8158 return resultobj;
8159 fail:
8160 return NULL;
8161 }
8162
8163
8164 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8165 PyObject *resultobj;
8166 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8167 PyObject *arg2 = (PyObject *) 0 ;
8168 PyObject *arg3 = (PyObject *) 0 ;
8169 PyObject * obj0 = 0 ;
8170 PyObject * obj1 = 0 ;
8171 PyObject * obj2 = 0 ;
8172 char *kwnames[] = {
8173 (char *) "self",(char *) "self",(char *) "_class", NULL
8174 };
8175
8176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8178 if (SWIG_arg_fail(1)) SWIG_fail;
8179 arg2 = obj1;
8180 arg3 = obj2;
8181 {
8182 PyThreadState* __tstate = wxPyBeginAllowThreads();
8183 (arg1)->_setCallbackInfo(arg2,arg3);
8184
8185 wxPyEndAllowThreads(__tstate);
8186 if (PyErr_Occurred()) SWIG_fail;
8187 }
8188 Py_INCREF(Py_None); resultobj = Py_None;
8189 return resultobj;
8190 fail:
8191 return NULL;
8192 }
8193
8194
8195 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8196 PyObject *obj;
8197 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8198 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8199 Py_INCREF(obj);
8200 return Py_BuildValue((char *)"");
8201 }
8202 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8203 PyObject *resultobj;
8204 wxWindow *arg1 = (wxWindow *) 0 ;
8205 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8206 bool arg3 = (bool) true ;
8207 bool result;
8208 PyObject * obj0 = 0 ;
8209 PyObject * obj1 = 0 ;
8210 PyObject * obj2 = 0 ;
8211 char *kwnames[] = {
8212 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8213 };
8214
8215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8217 if (SWIG_arg_fail(1)) SWIG_fail;
8218 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8219 if (SWIG_arg_fail(2)) SWIG_fail;
8220 if (obj2) {
8221 {
8222 arg3 = (bool)(SWIG_As_bool(obj2));
8223 if (SWIG_arg_fail(3)) SWIG_fail;
8224 }
8225 }
8226 {
8227 if (!wxPyCheckForApp()) SWIG_fail;
8228 PyThreadState* __tstate = wxPyBeginAllowThreads();
8229 result = (bool)wxShowTip(arg1,arg2,arg3);
8230
8231 wxPyEndAllowThreads(__tstate);
8232 if (PyErr_Occurred()) SWIG_fail;
8233 }
8234 {
8235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8236 }
8237 return resultobj;
8238 fail:
8239 return NULL;
8240 }
8241
8242
8243 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8244 PyObject *resultobj;
8245 wxString *arg1 = 0 ;
8246 size_t arg2 ;
8247 wxTipProvider *result;
8248 bool temp1 = false ;
8249 PyObject * obj0 = 0 ;
8250 PyObject * obj1 = 0 ;
8251 char *kwnames[] = {
8252 (char *) "filename",(char *) "currentTip", NULL
8253 };
8254
8255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8256 {
8257 arg1 = wxString_in_helper(obj0);
8258 if (arg1 == NULL) SWIG_fail;
8259 temp1 = true;
8260 }
8261 {
8262 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8263 if (SWIG_arg_fail(2)) SWIG_fail;
8264 }
8265 {
8266 if (!wxPyCheckForApp()) SWIG_fail;
8267 PyThreadState* __tstate = wxPyBeginAllowThreads();
8268 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8269
8270 wxPyEndAllowThreads(__tstate);
8271 if (PyErr_Occurred()) SWIG_fail;
8272 }
8273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8274 {
8275 if (temp1)
8276 delete arg1;
8277 }
8278 return resultobj;
8279 fail:
8280 {
8281 if (temp1)
8282 delete arg1;
8283 }
8284 return NULL;
8285 }
8286
8287
8288 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8289 PyObject *resultobj;
8290 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8291 int arg2 = (int) -1 ;
8292 wxPyTimer *result;
8293 PyObject * obj0 = 0 ;
8294 PyObject * obj1 = 0 ;
8295 char *kwnames[] = {
8296 (char *) "owner",(char *) "id", NULL
8297 };
8298
8299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8300 if (obj0) {
8301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8302 if (SWIG_arg_fail(1)) SWIG_fail;
8303 }
8304 if (obj1) {
8305 {
8306 arg2 = (int)(SWIG_As_int(obj1));
8307 if (SWIG_arg_fail(2)) SWIG_fail;
8308 }
8309 }
8310 {
8311 if (!wxPyCheckForApp()) SWIG_fail;
8312 PyThreadState* __tstate = wxPyBeginAllowThreads();
8313 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8314
8315 wxPyEndAllowThreads(__tstate);
8316 if (PyErr_Occurred()) SWIG_fail;
8317 }
8318 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8319 return resultobj;
8320 fail:
8321 return NULL;
8322 }
8323
8324
8325 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8326 PyObject *resultobj;
8327 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8328 PyObject * obj0 = 0 ;
8329 char *kwnames[] = {
8330 (char *) "self", NULL
8331 };
8332
8333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8335 if (SWIG_arg_fail(1)) SWIG_fail;
8336 {
8337 PyThreadState* __tstate = wxPyBeginAllowThreads();
8338 delete arg1;
8339
8340 wxPyEndAllowThreads(__tstate);
8341 if (PyErr_Occurred()) SWIG_fail;
8342 }
8343 Py_INCREF(Py_None); resultobj = Py_None;
8344 return resultobj;
8345 fail:
8346 return NULL;
8347 }
8348
8349
8350 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8351 PyObject *resultobj;
8352 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8353 PyObject *arg2 = (PyObject *) 0 ;
8354 PyObject *arg3 = (PyObject *) 0 ;
8355 int arg4 = (int) 1 ;
8356 PyObject * obj0 = 0 ;
8357 PyObject * obj1 = 0 ;
8358 PyObject * obj2 = 0 ;
8359 PyObject * obj3 = 0 ;
8360 char *kwnames[] = {
8361 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8362 };
8363
8364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8366 if (SWIG_arg_fail(1)) SWIG_fail;
8367 arg2 = obj1;
8368 arg3 = obj2;
8369 if (obj3) {
8370 {
8371 arg4 = (int)(SWIG_As_int(obj3));
8372 if (SWIG_arg_fail(4)) SWIG_fail;
8373 }
8374 }
8375 {
8376 PyThreadState* __tstate = wxPyBeginAllowThreads();
8377 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8378
8379 wxPyEndAllowThreads(__tstate);
8380 if (PyErr_Occurred()) SWIG_fail;
8381 }
8382 Py_INCREF(Py_None); resultobj = Py_None;
8383 return resultobj;
8384 fail:
8385 return NULL;
8386 }
8387
8388
8389 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8390 PyObject *resultobj;
8391 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8392 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8393 int arg3 = (int) -1 ;
8394 PyObject * obj0 = 0 ;
8395 PyObject * obj1 = 0 ;
8396 PyObject * obj2 = 0 ;
8397 char *kwnames[] = {
8398 (char *) "self",(char *) "owner",(char *) "id", NULL
8399 };
8400
8401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8403 if (SWIG_arg_fail(1)) SWIG_fail;
8404 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8405 if (SWIG_arg_fail(2)) SWIG_fail;
8406 if (obj2) {
8407 {
8408 arg3 = (int)(SWIG_As_int(obj2));
8409 if (SWIG_arg_fail(3)) SWIG_fail;
8410 }
8411 }
8412 {
8413 PyThreadState* __tstate = wxPyBeginAllowThreads();
8414 (arg1)->SetOwner(arg2,arg3);
8415
8416 wxPyEndAllowThreads(__tstate);
8417 if (PyErr_Occurred()) SWIG_fail;
8418 }
8419 Py_INCREF(Py_None); resultobj = Py_None;
8420 return resultobj;
8421 fail:
8422 return NULL;
8423 }
8424
8425
8426 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8427 PyObject *resultobj;
8428 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8429 wxEvtHandler *result;
8430 PyObject * obj0 = 0 ;
8431 char *kwnames[] = {
8432 (char *) "self", NULL
8433 };
8434
8435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8437 if (SWIG_arg_fail(1)) SWIG_fail;
8438 {
8439 PyThreadState* __tstate = wxPyBeginAllowThreads();
8440 result = (wxEvtHandler *)(arg1)->GetOwner();
8441
8442 wxPyEndAllowThreads(__tstate);
8443 if (PyErr_Occurred()) SWIG_fail;
8444 }
8445 {
8446 resultobj = wxPyMake_wxObject(result, 0);
8447 }
8448 return resultobj;
8449 fail:
8450 return NULL;
8451 }
8452
8453
8454 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8455 PyObject *resultobj;
8456 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8457 int arg2 = (int) -1 ;
8458 bool arg3 = (bool) false ;
8459 bool result;
8460 PyObject * obj0 = 0 ;
8461 PyObject * obj1 = 0 ;
8462 PyObject * obj2 = 0 ;
8463 char *kwnames[] = {
8464 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8465 };
8466
8467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8469 if (SWIG_arg_fail(1)) SWIG_fail;
8470 if (obj1) {
8471 {
8472 arg2 = (int)(SWIG_As_int(obj1));
8473 if (SWIG_arg_fail(2)) SWIG_fail;
8474 }
8475 }
8476 if (obj2) {
8477 {
8478 arg3 = (bool)(SWIG_As_bool(obj2));
8479 if (SWIG_arg_fail(3)) SWIG_fail;
8480 }
8481 }
8482 {
8483 PyThreadState* __tstate = wxPyBeginAllowThreads();
8484 result = (bool)(arg1)->Start(arg2,arg3);
8485
8486 wxPyEndAllowThreads(__tstate);
8487 if (PyErr_Occurred()) SWIG_fail;
8488 }
8489 {
8490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8491 }
8492 return resultobj;
8493 fail:
8494 return NULL;
8495 }
8496
8497
8498 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8499 PyObject *resultobj;
8500 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8501 PyObject * obj0 = 0 ;
8502 char *kwnames[] = {
8503 (char *) "self", NULL
8504 };
8505
8506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8508 if (SWIG_arg_fail(1)) SWIG_fail;
8509 {
8510 PyThreadState* __tstate = wxPyBeginAllowThreads();
8511 (arg1)->Stop();
8512
8513 wxPyEndAllowThreads(__tstate);
8514 if (PyErr_Occurred()) SWIG_fail;
8515 }
8516 Py_INCREF(Py_None); resultobj = Py_None;
8517 return resultobj;
8518 fail:
8519 return NULL;
8520 }
8521
8522
8523 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8524 PyObject *resultobj;
8525 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8526 bool result;
8527 PyObject * obj0 = 0 ;
8528 char *kwnames[] = {
8529 (char *) "self", NULL
8530 };
8531
8532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8534 if (SWIG_arg_fail(1)) SWIG_fail;
8535 {
8536 PyThreadState* __tstate = wxPyBeginAllowThreads();
8537 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8538
8539 wxPyEndAllowThreads(__tstate);
8540 if (PyErr_Occurred()) SWIG_fail;
8541 }
8542 {
8543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8544 }
8545 return resultobj;
8546 fail:
8547 return NULL;
8548 }
8549
8550
8551 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8552 PyObject *resultobj;
8553 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8554 int result;
8555 PyObject * obj0 = 0 ;
8556 char *kwnames[] = {
8557 (char *) "self", NULL
8558 };
8559
8560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8562 if (SWIG_arg_fail(1)) SWIG_fail;
8563 {
8564 PyThreadState* __tstate = wxPyBeginAllowThreads();
8565 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8566
8567 wxPyEndAllowThreads(__tstate);
8568 if (PyErr_Occurred()) SWIG_fail;
8569 }
8570 {
8571 resultobj = SWIG_From_int((int)(result));
8572 }
8573 return resultobj;
8574 fail:
8575 return NULL;
8576 }
8577
8578
8579 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8580 PyObject *resultobj;
8581 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8582 bool result;
8583 PyObject * obj0 = 0 ;
8584 char *kwnames[] = {
8585 (char *) "self", NULL
8586 };
8587
8588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8590 if (SWIG_arg_fail(1)) SWIG_fail;
8591 {
8592 PyThreadState* __tstate = wxPyBeginAllowThreads();
8593 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8594
8595 wxPyEndAllowThreads(__tstate);
8596 if (PyErr_Occurred()) SWIG_fail;
8597 }
8598 {
8599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8600 }
8601 return resultobj;
8602 fail:
8603 return NULL;
8604 }
8605
8606
8607 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8608 PyObject *resultobj;
8609 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8610 int result;
8611 PyObject * obj0 = 0 ;
8612 char *kwnames[] = {
8613 (char *) "self", NULL
8614 };
8615
8616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8618 if (SWIG_arg_fail(1)) SWIG_fail;
8619 {
8620 PyThreadState* __tstate = wxPyBeginAllowThreads();
8621 result = (int)((wxPyTimer const *)arg1)->GetId();
8622
8623 wxPyEndAllowThreads(__tstate);
8624 if (PyErr_Occurred()) SWIG_fail;
8625 }
8626 {
8627 resultobj = SWIG_From_int((int)(result));
8628 }
8629 return resultobj;
8630 fail:
8631 return NULL;
8632 }
8633
8634
8635 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8636 PyObject *obj;
8637 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8638 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8639 Py_INCREF(obj);
8640 return Py_BuildValue((char *)"");
8641 }
8642 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8643 PyObject *resultobj;
8644 int arg1 = (int) 0 ;
8645 int arg2 = (int) 0 ;
8646 wxTimerEvent *result;
8647 PyObject * obj0 = 0 ;
8648 PyObject * obj1 = 0 ;
8649 char *kwnames[] = {
8650 (char *) "timerid",(char *) "interval", NULL
8651 };
8652
8653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8654 if (obj0) {
8655 {
8656 arg1 = (int)(SWIG_As_int(obj0));
8657 if (SWIG_arg_fail(1)) SWIG_fail;
8658 }
8659 }
8660 if (obj1) {
8661 {
8662 arg2 = (int)(SWIG_As_int(obj1));
8663 if (SWIG_arg_fail(2)) SWIG_fail;
8664 }
8665 }
8666 {
8667 PyThreadState* __tstate = wxPyBeginAllowThreads();
8668 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8669
8670 wxPyEndAllowThreads(__tstate);
8671 if (PyErr_Occurred()) SWIG_fail;
8672 }
8673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8674 return resultobj;
8675 fail:
8676 return NULL;
8677 }
8678
8679
8680 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8681 PyObject *resultobj;
8682 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8683 int result;
8684 PyObject * obj0 = 0 ;
8685 char *kwnames[] = {
8686 (char *) "self", NULL
8687 };
8688
8689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8691 if (SWIG_arg_fail(1)) SWIG_fail;
8692 {
8693 PyThreadState* __tstate = wxPyBeginAllowThreads();
8694 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8695
8696 wxPyEndAllowThreads(__tstate);
8697 if (PyErr_Occurred()) SWIG_fail;
8698 }
8699 {
8700 resultobj = SWIG_From_int((int)(result));
8701 }
8702 return resultobj;
8703 fail:
8704 return NULL;
8705 }
8706
8707
8708 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8709 PyObject *obj;
8710 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8711 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8712 Py_INCREF(obj);
8713 return Py_BuildValue((char *)"");
8714 }
8715 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8716 PyObject *resultobj;
8717 wxTimer *arg1 = 0 ;
8718 wxTimerRunner *result;
8719 PyObject * obj0 = 0 ;
8720
8721 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8722 {
8723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8724 if (SWIG_arg_fail(1)) SWIG_fail;
8725 if (arg1 == NULL) {
8726 SWIG_null_ref("wxTimer");
8727 }
8728 if (SWIG_arg_fail(1)) SWIG_fail;
8729 }
8730 {
8731 if (!wxPyCheckForApp()) SWIG_fail;
8732 PyThreadState* __tstate = wxPyBeginAllowThreads();
8733 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8734
8735 wxPyEndAllowThreads(__tstate);
8736 if (PyErr_Occurred()) SWIG_fail;
8737 }
8738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8739 return resultobj;
8740 fail:
8741 return NULL;
8742 }
8743
8744
8745 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8746 PyObject *resultobj;
8747 wxTimer *arg1 = 0 ;
8748 int arg2 ;
8749 bool arg3 = (bool) false ;
8750 wxTimerRunner *result;
8751 PyObject * obj0 = 0 ;
8752 PyObject * obj1 = 0 ;
8753 PyObject * obj2 = 0 ;
8754
8755 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8756 {
8757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8758 if (SWIG_arg_fail(1)) SWIG_fail;
8759 if (arg1 == NULL) {
8760 SWIG_null_ref("wxTimer");
8761 }
8762 if (SWIG_arg_fail(1)) SWIG_fail;
8763 }
8764 {
8765 arg2 = (int)(SWIG_As_int(obj1));
8766 if (SWIG_arg_fail(2)) SWIG_fail;
8767 }
8768 if (obj2) {
8769 {
8770 arg3 = (bool)(SWIG_As_bool(obj2));
8771 if (SWIG_arg_fail(3)) SWIG_fail;
8772 }
8773 }
8774 {
8775 if (!wxPyCheckForApp()) SWIG_fail;
8776 PyThreadState* __tstate = wxPyBeginAllowThreads();
8777 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8778
8779 wxPyEndAllowThreads(__tstate);
8780 if (PyErr_Occurred()) SWIG_fail;
8781 }
8782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8783 return resultobj;
8784 fail:
8785 return NULL;
8786 }
8787
8788
8789 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8790 int argc;
8791 PyObject *argv[4];
8792 int ii;
8793
8794 argc = PyObject_Length(args);
8795 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8796 argv[ii] = PyTuple_GetItem(args,ii);
8797 }
8798 if (argc == 1) {
8799 int _v;
8800 {
8801 void *ptr = 0;
8802 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8803 _v = 0;
8804 PyErr_Clear();
8805 } else {
8806 _v = (ptr != 0);
8807 }
8808 }
8809 if (_v) {
8810 return _wrap_new_TimerRunner__SWIG_0(self,args);
8811 }
8812 }
8813 if ((argc >= 2) && (argc <= 3)) {
8814 int _v;
8815 {
8816 void *ptr = 0;
8817 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8818 _v = 0;
8819 PyErr_Clear();
8820 } else {
8821 _v = (ptr != 0);
8822 }
8823 }
8824 if (_v) {
8825 _v = SWIG_Check_int(argv[1]);
8826 if (_v) {
8827 if (argc <= 2) {
8828 return _wrap_new_TimerRunner__SWIG_1(self,args);
8829 }
8830 _v = SWIG_Check_bool(argv[2]);
8831 if (_v) {
8832 return _wrap_new_TimerRunner__SWIG_1(self,args);
8833 }
8834 }
8835 }
8836 }
8837
8838 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8839 return NULL;
8840 }
8841
8842
8843 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8844 PyObject *resultobj;
8845 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8846 PyObject * obj0 = 0 ;
8847 char *kwnames[] = {
8848 (char *) "self", NULL
8849 };
8850
8851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8853 if (SWIG_arg_fail(1)) SWIG_fail;
8854 {
8855 PyThreadState* __tstate = wxPyBeginAllowThreads();
8856 delete arg1;
8857
8858 wxPyEndAllowThreads(__tstate);
8859 if (PyErr_Occurred()) SWIG_fail;
8860 }
8861 Py_INCREF(Py_None); resultobj = Py_None;
8862 return resultobj;
8863 fail:
8864 return NULL;
8865 }
8866
8867
8868 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8869 PyObject *resultobj;
8870 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8871 int arg2 ;
8872 bool arg3 = (bool) false ;
8873 PyObject * obj0 = 0 ;
8874 PyObject * obj1 = 0 ;
8875 PyObject * obj2 = 0 ;
8876 char *kwnames[] = {
8877 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8878 };
8879
8880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8882 if (SWIG_arg_fail(1)) SWIG_fail;
8883 {
8884 arg2 = (int)(SWIG_As_int(obj1));
8885 if (SWIG_arg_fail(2)) SWIG_fail;
8886 }
8887 if (obj2) {
8888 {
8889 arg3 = (bool)(SWIG_As_bool(obj2));
8890 if (SWIG_arg_fail(3)) SWIG_fail;
8891 }
8892 }
8893 {
8894 PyThreadState* __tstate = wxPyBeginAllowThreads();
8895 (arg1)->Start(arg2,arg3);
8896
8897 wxPyEndAllowThreads(__tstate);
8898 if (PyErr_Occurred()) SWIG_fail;
8899 }
8900 Py_INCREF(Py_None); resultobj = Py_None;
8901 return resultobj;
8902 fail:
8903 return NULL;
8904 }
8905
8906
8907 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8908 PyObject *obj;
8909 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8910 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8911 Py_INCREF(obj);
8912 return Py_BuildValue((char *)"");
8913 }
8914 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8915 PyObject *resultobj;
8916 wxLog *result;
8917 char *kwnames[] = {
8918 NULL
8919 };
8920
8921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8922 {
8923 PyThreadState* __tstate = wxPyBeginAllowThreads();
8924 result = (wxLog *)new wxLog();
8925
8926 wxPyEndAllowThreads(__tstate);
8927 if (PyErr_Occurred()) SWIG_fail;
8928 }
8929 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8930 return resultobj;
8931 fail:
8932 return NULL;
8933 }
8934
8935
8936 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8937 PyObject *resultobj;
8938 bool result;
8939 char *kwnames[] = {
8940 NULL
8941 };
8942
8943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8944 {
8945 PyThreadState* __tstate = wxPyBeginAllowThreads();
8946 result = (bool)wxLog::IsEnabled();
8947
8948 wxPyEndAllowThreads(__tstate);
8949 if (PyErr_Occurred()) SWIG_fail;
8950 }
8951 {
8952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8953 }
8954 return resultobj;
8955 fail:
8956 return NULL;
8957 }
8958
8959
8960 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8961 PyObject *resultobj;
8962 bool arg1 = (bool) true ;
8963 bool result;
8964 PyObject * obj0 = 0 ;
8965 char *kwnames[] = {
8966 (char *) "doIt", NULL
8967 };
8968
8969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8970 if (obj0) {
8971 {
8972 arg1 = (bool)(SWIG_As_bool(obj0));
8973 if (SWIG_arg_fail(1)) SWIG_fail;
8974 }
8975 }
8976 {
8977 PyThreadState* __tstate = wxPyBeginAllowThreads();
8978 result = (bool)wxLog::EnableLogging(arg1);
8979
8980 wxPyEndAllowThreads(__tstate);
8981 if (PyErr_Occurred()) SWIG_fail;
8982 }
8983 {
8984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8985 }
8986 return resultobj;
8987 fail:
8988 return NULL;
8989 }
8990
8991
8992 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8993 PyObject *resultobj;
8994 wxLogLevel arg1 ;
8995 wxChar *arg2 = (wxChar *) 0 ;
8996 time_t arg3 ;
8997 PyObject * obj0 = 0 ;
8998 PyObject * obj1 = 0 ;
8999 PyObject * obj2 = 0 ;
9000 char *kwnames[] = {
9001 (char *) "level",(char *) "szString",(char *) "t", NULL
9002 };
9003
9004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
9005 {
9006 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9007 if (SWIG_arg_fail(1)) SWIG_fail;
9008 }
9009 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9010 if (SWIG_arg_fail(2)) SWIG_fail;
9011 {
9012 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
9013 if (SWIG_arg_fail(3)) SWIG_fail;
9014 }
9015 {
9016 PyThreadState* __tstate = wxPyBeginAllowThreads();
9017 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
9018
9019 wxPyEndAllowThreads(__tstate);
9020 if (PyErr_Occurred()) SWIG_fail;
9021 }
9022 Py_INCREF(Py_None); resultobj = Py_None;
9023 return resultobj;
9024 fail:
9025 return NULL;
9026 }
9027
9028
9029 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
9030 PyObject *resultobj;
9031 wxLog *arg1 = (wxLog *) 0 ;
9032 PyObject * obj0 = 0 ;
9033 char *kwnames[] = {
9034 (char *) "self", NULL
9035 };
9036
9037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
9038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9039 if (SWIG_arg_fail(1)) SWIG_fail;
9040 {
9041 PyThreadState* __tstate = wxPyBeginAllowThreads();
9042 (arg1)->Flush();
9043
9044 wxPyEndAllowThreads(__tstate);
9045 if (PyErr_Occurred()) SWIG_fail;
9046 }
9047 Py_INCREF(Py_None); resultobj = Py_None;
9048 return resultobj;
9049 fail:
9050 return NULL;
9051 }
9052
9053
9054 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
9055 PyObject *resultobj;
9056 char *kwnames[] = {
9057 NULL
9058 };
9059
9060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
9061 {
9062 PyThreadState* __tstate = wxPyBeginAllowThreads();
9063 wxLog::FlushActive();
9064
9065 wxPyEndAllowThreads(__tstate);
9066 if (PyErr_Occurred()) SWIG_fail;
9067 }
9068 Py_INCREF(Py_None); resultobj = Py_None;
9069 return resultobj;
9070 fail:
9071 return NULL;
9072 }
9073
9074
9075 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9076 PyObject *resultobj;
9077 wxLog *result;
9078 char *kwnames[] = {
9079 NULL
9080 };
9081
9082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9083 {
9084 PyThreadState* __tstate = wxPyBeginAllowThreads();
9085 result = (wxLog *)wxLog::GetActiveTarget();
9086
9087 wxPyEndAllowThreads(__tstate);
9088 if (PyErr_Occurred()) SWIG_fail;
9089 }
9090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9091 return resultobj;
9092 fail:
9093 return NULL;
9094 }
9095
9096
9097 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9098 PyObject *resultobj;
9099 wxLog *arg1 = (wxLog *) 0 ;
9100 wxLog *result;
9101 PyObject * obj0 = 0 ;
9102 char *kwnames[] = {
9103 (char *) "pLogger", NULL
9104 };
9105
9106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9108 if (SWIG_arg_fail(1)) SWIG_fail;
9109 {
9110 PyThreadState* __tstate = wxPyBeginAllowThreads();
9111 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9112
9113 wxPyEndAllowThreads(__tstate);
9114 if (PyErr_Occurred()) SWIG_fail;
9115 }
9116 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9117 return resultobj;
9118 fail:
9119 return NULL;
9120 }
9121
9122
9123 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9124 PyObject *resultobj;
9125 char *kwnames[] = {
9126 NULL
9127 };
9128
9129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9130 {
9131 PyThreadState* __tstate = wxPyBeginAllowThreads();
9132 wxLog::Suspend();
9133
9134 wxPyEndAllowThreads(__tstate);
9135 if (PyErr_Occurred()) SWIG_fail;
9136 }
9137 Py_INCREF(Py_None); resultobj = Py_None;
9138 return resultobj;
9139 fail:
9140 return NULL;
9141 }
9142
9143
9144 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9145 PyObject *resultobj;
9146 char *kwnames[] = {
9147 NULL
9148 };
9149
9150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9151 {
9152 PyThreadState* __tstate = wxPyBeginAllowThreads();
9153 wxLog::Resume();
9154
9155 wxPyEndAllowThreads(__tstate);
9156 if (PyErr_Occurred()) SWIG_fail;
9157 }
9158 Py_INCREF(Py_None); resultobj = Py_None;
9159 return resultobj;
9160 fail:
9161 return NULL;
9162 }
9163
9164
9165 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9166 PyObject *resultobj;
9167 bool arg1 = (bool) true ;
9168 PyObject * obj0 = 0 ;
9169 char *kwnames[] = {
9170 (char *) "bVerbose", NULL
9171 };
9172
9173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9174 if (obj0) {
9175 {
9176 arg1 = (bool)(SWIG_As_bool(obj0));
9177 if (SWIG_arg_fail(1)) SWIG_fail;
9178 }
9179 }
9180 {
9181 PyThreadState* __tstate = wxPyBeginAllowThreads();
9182 wxLog::SetVerbose(arg1);
9183
9184 wxPyEndAllowThreads(__tstate);
9185 if (PyErr_Occurred()) SWIG_fail;
9186 }
9187 Py_INCREF(Py_None); resultobj = Py_None;
9188 return resultobj;
9189 fail:
9190 return NULL;
9191 }
9192
9193
9194 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9195 PyObject *resultobj;
9196 wxLogLevel arg1 ;
9197 PyObject * obj0 = 0 ;
9198 char *kwnames[] = {
9199 (char *) "logLevel", NULL
9200 };
9201
9202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9203 {
9204 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9205 if (SWIG_arg_fail(1)) SWIG_fail;
9206 }
9207 {
9208 PyThreadState* __tstate = wxPyBeginAllowThreads();
9209 wxLog::SetLogLevel(arg1);
9210
9211 wxPyEndAllowThreads(__tstate);
9212 if (PyErr_Occurred()) SWIG_fail;
9213 }
9214 Py_INCREF(Py_None); resultobj = Py_None;
9215 return resultobj;
9216 fail:
9217 return NULL;
9218 }
9219
9220
9221 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9222 PyObject *resultobj;
9223 char *kwnames[] = {
9224 NULL
9225 };
9226
9227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9228 {
9229 PyThreadState* __tstate = wxPyBeginAllowThreads();
9230 wxLog::DontCreateOnDemand();
9231
9232 wxPyEndAllowThreads(__tstate);
9233 if (PyErr_Occurred()) SWIG_fail;
9234 }
9235 Py_INCREF(Py_None); resultobj = Py_None;
9236 return resultobj;
9237 fail:
9238 return NULL;
9239 }
9240
9241
9242 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9243 PyObject *resultobj;
9244 wxTraceMask arg1 ;
9245 PyObject * obj0 = 0 ;
9246 char *kwnames[] = {
9247 (char *) "ulMask", NULL
9248 };
9249
9250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9251 {
9252 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9253 if (SWIG_arg_fail(1)) SWIG_fail;
9254 }
9255 {
9256 PyThreadState* __tstate = wxPyBeginAllowThreads();
9257 wxLog::SetTraceMask(arg1);
9258
9259 wxPyEndAllowThreads(__tstate);
9260 if (PyErr_Occurred()) SWIG_fail;
9261 }
9262 Py_INCREF(Py_None); resultobj = Py_None;
9263 return resultobj;
9264 fail:
9265 return NULL;
9266 }
9267
9268
9269 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9270 PyObject *resultobj;
9271 wxString *arg1 = 0 ;
9272 bool temp1 = false ;
9273 PyObject * obj0 = 0 ;
9274 char *kwnames[] = {
9275 (char *) "str", NULL
9276 };
9277
9278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9279 {
9280 arg1 = wxString_in_helper(obj0);
9281 if (arg1 == NULL) SWIG_fail;
9282 temp1 = true;
9283 }
9284 {
9285 PyThreadState* __tstate = wxPyBeginAllowThreads();
9286 wxLog::AddTraceMask((wxString const &)*arg1);
9287
9288 wxPyEndAllowThreads(__tstate);
9289 if (PyErr_Occurred()) SWIG_fail;
9290 }
9291 Py_INCREF(Py_None); resultobj = Py_None;
9292 {
9293 if (temp1)
9294 delete arg1;
9295 }
9296 return resultobj;
9297 fail:
9298 {
9299 if (temp1)
9300 delete arg1;
9301 }
9302 return NULL;
9303 }
9304
9305
9306 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9307 PyObject *resultobj;
9308 wxString *arg1 = 0 ;
9309 bool temp1 = false ;
9310 PyObject * obj0 = 0 ;
9311 char *kwnames[] = {
9312 (char *) "str", NULL
9313 };
9314
9315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9316 {
9317 arg1 = wxString_in_helper(obj0);
9318 if (arg1 == NULL) SWIG_fail;
9319 temp1 = true;
9320 }
9321 {
9322 PyThreadState* __tstate = wxPyBeginAllowThreads();
9323 wxLog::RemoveTraceMask((wxString const &)*arg1);
9324
9325 wxPyEndAllowThreads(__tstate);
9326 if (PyErr_Occurred()) SWIG_fail;
9327 }
9328 Py_INCREF(Py_None); resultobj = Py_None;
9329 {
9330 if (temp1)
9331 delete arg1;
9332 }
9333 return resultobj;
9334 fail:
9335 {
9336 if (temp1)
9337 delete arg1;
9338 }
9339 return NULL;
9340 }
9341
9342
9343 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9344 PyObject *resultobj;
9345 char *kwnames[] = {
9346 NULL
9347 };
9348
9349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9350 {
9351 PyThreadState* __tstate = wxPyBeginAllowThreads();
9352 wxLog::ClearTraceMasks();
9353
9354 wxPyEndAllowThreads(__tstate);
9355 if (PyErr_Occurred()) SWIG_fail;
9356 }
9357 Py_INCREF(Py_None); resultobj = Py_None;
9358 return resultobj;
9359 fail:
9360 return NULL;
9361 }
9362
9363
9364 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9365 PyObject *resultobj;
9366 wxArrayString *result;
9367 char *kwnames[] = {
9368 NULL
9369 };
9370
9371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9372 {
9373 PyThreadState* __tstate = wxPyBeginAllowThreads();
9374 {
9375 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9376 result = (wxArrayString *) &_result_ref;
9377 }
9378
9379 wxPyEndAllowThreads(__tstate);
9380 if (PyErr_Occurred()) SWIG_fail;
9381 }
9382 {
9383 resultobj = wxArrayString2PyList_helper(*result);
9384 }
9385 return resultobj;
9386 fail:
9387 return NULL;
9388 }
9389
9390
9391 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9392 PyObject *resultobj;
9393 wxChar *arg1 = (wxChar *) 0 ;
9394 PyObject * obj0 = 0 ;
9395 char *kwnames[] = {
9396 (char *) "ts", NULL
9397 };
9398
9399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9401 if (SWIG_arg_fail(1)) SWIG_fail;
9402 {
9403 PyThreadState* __tstate = wxPyBeginAllowThreads();
9404 wxLog::SetTimestamp((wxChar const *)arg1);
9405
9406 wxPyEndAllowThreads(__tstate);
9407 if (PyErr_Occurred()) SWIG_fail;
9408 }
9409 Py_INCREF(Py_None); resultobj = Py_None;
9410 return resultobj;
9411 fail:
9412 return NULL;
9413 }
9414
9415
9416 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9417 PyObject *resultobj;
9418 bool result;
9419 char *kwnames[] = {
9420 NULL
9421 };
9422
9423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9424 {
9425 PyThreadState* __tstate = wxPyBeginAllowThreads();
9426 result = (bool)wxLog::GetVerbose();
9427
9428 wxPyEndAllowThreads(__tstate);
9429 if (PyErr_Occurred()) SWIG_fail;
9430 }
9431 {
9432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9433 }
9434 return resultobj;
9435 fail:
9436 return NULL;
9437 }
9438
9439
9440 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9441 PyObject *resultobj;
9442 wxTraceMask result;
9443 char *kwnames[] = {
9444 NULL
9445 };
9446
9447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9448 {
9449 PyThreadState* __tstate = wxPyBeginAllowThreads();
9450 result = (wxTraceMask)wxLog::GetTraceMask();
9451
9452 wxPyEndAllowThreads(__tstate);
9453 if (PyErr_Occurred()) SWIG_fail;
9454 }
9455 {
9456 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9457 }
9458 return resultobj;
9459 fail:
9460 return NULL;
9461 }
9462
9463
9464 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9465 PyObject *resultobj;
9466 wxChar *arg1 = (wxChar *) 0 ;
9467 bool result;
9468 PyObject * obj0 = 0 ;
9469 char *kwnames[] = {
9470 (char *) "mask", NULL
9471 };
9472
9473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9475 if (SWIG_arg_fail(1)) SWIG_fail;
9476 {
9477 PyThreadState* __tstate = wxPyBeginAllowThreads();
9478 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9479
9480 wxPyEndAllowThreads(__tstate);
9481 if (PyErr_Occurred()) SWIG_fail;
9482 }
9483 {
9484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9485 }
9486 return resultobj;
9487 fail:
9488 return NULL;
9489 }
9490
9491
9492 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9493 PyObject *resultobj;
9494 wxLogLevel result;
9495 char *kwnames[] = {
9496 NULL
9497 };
9498
9499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9500 {
9501 PyThreadState* __tstate = wxPyBeginAllowThreads();
9502 result = (wxLogLevel)wxLog::GetLogLevel();
9503
9504 wxPyEndAllowThreads(__tstate);
9505 if (PyErr_Occurred()) SWIG_fail;
9506 }
9507 {
9508 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9509 }
9510 return resultobj;
9511 fail:
9512 return NULL;
9513 }
9514
9515
9516 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9517 PyObject *resultobj;
9518 wxChar *result;
9519 char *kwnames[] = {
9520 NULL
9521 };
9522
9523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9524 {
9525 PyThreadState* __tstate = wxPyBeginAllowThreads();
9526 result = (wxChar *)wxLog::GetTimestamp();
9527
9528 wxPyEndAllowThreads(__tstate);
9529 if (PyErr_Occurred()) SWIG_fail;
9530 }
9531 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9532 return resultobj;
9533 fail:
9534 return NULL;
9535 }
9536
9537
9538 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9539 PyObject *resultobj;
9540 wxString result;
9541 char *kwnames[] = {
9542 NULL
9543 };
9544
9545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9546 {
9547 PyThreadState* __tstate = wxPyBeginAllowThreads();
9548 result = Log_TimeStamp();
9549
9550 wxPyEndAllowThreads(__tstate);
9551 if (PyErr_Occurred()) SWIG_fail;
9552 }
9553 {
9554 #if wxUSE_UNICODE
9555 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9556 #else
9557 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9558 #endif
9559 }
9560 return resultobj;
9561 fail:
9562 return NULL;
9563 }
9564
9565
9566 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9567 PyObject *resultobj;
9568 wxLog *arg1 = (wxLog *) 0 ;
9569 PyObject * obj0 = 0 ;
9570 char *kwnames[] = {
9571 (char *) "self", NULL
9572 };
9573
9574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9576 if (SWIG_arg_fail(1)) SWIG_fail;
9577 {
9578 PyThreadState* __tstate = wxPyBeginAllowThreads();
9579 wxLog_Destroy(arg1);
9580
9581 wxPyEndAllowThreads(__tstate);
9582 if (PyErr_Occurred()) SWIG_fail;
9583 }
9584 Py_INCREF(Py_None); resultobj = Py_None;
9585 return resultobj;
9586 fail:
9587 return NULL;
9588 }
9589
9590
9591 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9592 PyObject *obj;
9593 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9594 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9595 Py_INCREF(obj);
9596 return Py_BuildValue((char *)"");
9597 }
9598 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9599 PyObject *resultobj;
9600 wxLogStderr *result;
9601 char *kwnames[] = {
9602 NULL
9603 };
9604
9605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9606 {
9607 PyThreadState* __tstate = wxPyBeginAllowThreads();
9608 result = (wxLogStderr *)new wxLogStderr();
9609
9610 wxPyEndAllowThreads(__tstate);
9611 if (PyErr_Occurred()) SWIG_fail;
9612 }
9613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9614 return resultobj;
9615 fail:
9616 return NULL;
9617 }
9618
9619
9620 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9621 PyObject *obj;
9622 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9623 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9624 Py_INCREF(obj);
9625 return Py_BuildValue((char *)"");
9626 }
9627 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9628 PyObject *resultobj;
9629 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9630 wxLogTextCtrl *result;
9631 PyObject * obj0 = 0 ;
9632 char *kwnames[] = {
9633 (char *) "pTextCtrl", NULL
9634 };
9635
9636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9638 if (SWIG_arg_fail(1)) SWIG_fail;
9639 {
9640 PyThreadState* __tstate = wxPyBeginAllowThreads();
9641 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9642
9643 wxPyEndAllowThreads(__tstate);
9644 if (PyErr_Occurred()) SWIG_fail;
9645 }
9646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9647 return resultobj;
9648 fail:
9649 return NULL;
9650 }
9651
9652
9653 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9654 PyObject *obj;
9655 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9656 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9657 Py_INCREF(obj);
9658 return Py_BuildValue((char *)"");
9659 }
9660 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9661 PyObject *resultobj;
9662 wxLogGui *result;
9663 char *kwnames[] = {
9664 NULL
9665 };
9666
9667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9668 {
9669 PyThreadState* __tstate = wxPyBeginAllowThreads();
9670 result = (wxLogGui *)new wxLogGui();
9671
9672 wxPyEndAllowThreads(__tstate);
9673 if (PyErr_Occurred()) SWIG_fail;
9674 }
9675 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9676 return resultobj;
9677 fail:
9678 return NULL;
9679 }
9680
9681
9682 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9683 PyObject *obj;
9684 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9685 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9686 Py_INCREF(obj);
9687 return Py_BuildValue((char *)"");
9688 }
9689 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9690 PyObject *resultobj;
9691 wxFrame *arg1 = (wxFrame *) 0 ;
9692 wxString *arg2 = 0 ;
9693 bool arg3 = (bool) true ;
9694 bool arg4 = (bool) true ;
9695 wxLogWindow *result;
9696 bool temp2 = false ;
9697 PyObject * obj0 = 0 ;
9698 PyObject * obj1 = 0 ;
9699 PyObject * obj2 = 0 ;
9700 PyObject * obj3 = 0 ;
9701 char *kwnames[] = {
9702 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9703 };
9704
9705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9707 if (SWIG_arg_fail(1)) SWIG_fail;
9708 {
9709 arg2 = wxString_in_helper(obj1);
9710 if (arg2 == NULL) SWIG_fail;
9711 temp2 = true;
9712 }
9713 if (obj2) {
9714 {
9715 arg3 = (bool)(SWIG_As_bool(obj2));
9716 if (SWIG_arg_fail(3)) SWIG_fail;
9717 }
9718 }
9719 if (obj3) {
9720 {
9721 arg4 = (bool)(SWIG_As_bool(obj3));
9722 if (SWIG_arg_fail(4)) SWIG_fail;
9723 }
9724 }
9725 {
9726 PyThreadState* __tstate = wxPyBeginAllowThreads();
9727 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9728
9729 wxPyEndAllowThreads(__tstate);
9730 if (PyErr_Occurred()) SWIG_fail;
9731 }
9732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9733 {
9734 if (temp2)
9735 delete arg2;
9736 }
9737 return resultobj;
9738 fail:
9739 {
9740 if (temp2)
9741 delete arg2;
9742 }
9743 return NULL;
9744 }
9745
9746
9747 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9748 PyObject *resultobj;
9749 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9750 bool arg2 = (bool) true ;
9751 PyObject * obj0 = 0 ;
9752 PyObject * obj1 = 0 ;
9753 char *kwnames[] = {
9754 (char *) "self",(char *) "bShow", NULL
9755 };
9756
9757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9759 if (SWIG_arg_fail(1)) SWIG_fail;
9760 if (obj1) {
9761 {
9762 arg2 = (bool)(SWIG_As_bool(obj1));
9763 if (SWIG_arg_fail(2)) SWIG_fail;
9764 }
9765 }
9766 {
9767 PyThreadState* __tstate = wxPyBeginAllowThreads();
9768 (arg1)->Show(arg2);
9769
9770 wxPyEndAllowThreads(__tstate);
9771 if (PyErr_Occurred()) SWIG_fail;
9772 }
9773 Py_INCREF(Py_None); resultobj = Py_None;
9774 return resultobj;
9775 fail:
9776 return NULL;
9777 }
9778
9779
9780 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9781 PyObject *resultobj;
9782 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9783 wxFrame *result;
9784 PyObject * obj0 = 0 ;
9785 char *kwnames[] = {
9786 (char *) "self", NULL
9787 };
9788
9789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9791 if (SWIG_arg_fail(1)) SWIG_fail;
9792 {
9793 PyThreadState* __tstate = wxPyBeginAllowThreads();
9794 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9795
9796 wxPyEndAllowThreads(__tstate);
9797 if (PyErr_Occurred()) SWIG_fail;
9798 }
9799 {
9800 resultobj = wxPyMake_wxObject(result, 0);
9801 }
9802 return resultobj;
9803 fail:
9804 return NULL;
9805 }
9806
9807
9808 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9809 PyObject *resultobj;
9810 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9811 wxLog *result;
9812 PyObject * obj0 = 0 ;
9813 char *kwnames[] = {
9814 (char *) "self", NULL
9815 };
9816
9817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9819 if (SWIG_arg_fail(1)) SWIG_fail;
9820 {
9821 PyThreadState* __tstate = wxPyBeginAllowThreads();
9822 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9823
9824 wxPyEndAllowThreads(__tstate);
9825 if (PyErr_Occurred()) SWIG_fail;
9826 }
9827 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9828 return resultobj;
9829 fail:
9830 return NULL;
9831 }
9832
9833
9834 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9835 PyObject *resultobj;
9836 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9837 bool result;
9838 PyObject * obj0 = 0 ;
9839 char *kwnames[] = {
9840 (char *) "self", NULL
9841 };
9842
9843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9845 if (SWIG_arg_fail(1)) SWIG_fail;
9846 {
9847 PyThreadState* __tstate = wxPyBeginAllowThreads();
9848 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9849
9850 wxPyEndAllowThreads(__tstate);
9851 if (PyErr_Occurred()) SWIG_fail;
9852 }
9853 {
9854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9855 }
9856 return resultobj;
9857 fail:
9858 return NULL;
9859 }
9860
9861
9862 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9863 PyObject *resultobj;
9864 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9865 bool arg2 ;
9866 PyObject * obj0 = 0 ;
9867 PyObject * obj1 = 0 ;
9868 char *kwnames[] = {
9869 (char *) "self",(char *) "bDoPass", NULL
9870 };
9871
9872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9874 if (SWIG_arg_fail(1)) SWIG_fail;
9875 {
9876 arg2 = (bool)(SWIG_As_bool(obj1));
9877 if (SWIG_arg_fail(2)) SWIG_fail;
9878 }
9879 {
9880 PyThreadState* __tstate = wxPyBeginAllowThreads();
9881 (arg1)->PassMessages(arg2);
9882
9883 wxPyEndAllowThreads(__tstate);
9884 if (PyErr_Occurred()) SWIG_fail;
9885 }
9886 Py_INCREF(Py_None); resultobj = Py_None;
9887 return resultobj;
9888 fail:
9889 return NULL;
9890 }
9891
9892
9893 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9894 PyObject *obj;
9895 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9896 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9897 Py_INCREF(obj);
9898 return Py_BuildValue((char *)"");
9899 }
9900 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9901 PyObject *resultobj;
9902 wxLog *arg1 = (wxLog *) 0 ;
9903 wxLogChain *result;
9904 PyObject * obj0 = 0 ;
9905 char *kwnames[] = {
9906 (char *) "logger", NULL
9907 };
9908
9909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9911 if (SWIG_arg_fail(1)) SWIG_fail;
9912 {
9913 PyThreadState* __tstate = wxPyBeginAllowThreads();
9914 result = (wxLogChain *)new wxLogChain(arg1);
9915
9916 wxPyEndAllowThreads(__tstate);
9917 if (PyErr_Occurred()) SWIG_fail;
9918 }
9919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9920 return resultobj;
9921 fail:
9922 return NULL;
9923 }
9924
9925
9926 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9927 PyObject *resultobj;
9928 wxLogChain *arg1 = (wxLogChain *) 0 ;
9929 wxLog *arg2 = (wxLog *) 0 ;
9930 PyObject * obj0 = 0 ;
9931 PyObject * obj1 = 0 ;
9932 char *kwnames[] = {
9933 (char *) "self",(char *) "logger", NULL
9934 };
9935
9936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9938 if (SWIG_arg_fail(1)) SWIG_fail;
9939 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9940 if (SWIG_arg_fail(2)) SWIG_fail;
9941 {
9942 PyThreadState* __tstate = wxPyBeginAllowThreads();
9943 (arg1)->SetLog(arg2);
9944
9945 wxPyEndAllowThreads(__tstate);
9946 if (PyErr_Occurred()) SWIG_fail;
9947 }
9948 Py_INCREF(Py_None); resultobj = Py_None;
9949 return resultobj;
9950 fail:
9951 return NULL;
9952 }
9953
9954
9955 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9956 PyObject *resultobj;
9957 wxLogChain *arg1 = (wxLogChain *) 0 ;
9958 bool arg2 ;
9959 PyObject * obj0 = 0 ;
9960 PyObject * obj1 = 0 ;
9961 char *kwnames[] = {
9962 (char *) "self",(char *) "bDoPass", NULL
9963 };
9964
9965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9967 if (SWIG_arg_fail(1)) SWIG_fail;
9968 {
9969 arg2 = (bool)(SWIG_As_bool(obj1));
9970 if (SWIG_arg_fail(2)) SWIG_fail;
9971 }
9972 {
9973 PyThreadState* __tstate = wxPyBeginAllowThreads();
9974 (arg1)->PassMessages(arg2);
9975
9976 wxPyEndAllowThreads(__tstate);
9977 if (PyErr_Occurred()) SWIG_fail;
9978 }
9979 Py_INCREF(Py_None); resultobj = Py_None;
9980 return resultobj;
9981 fail:
9982 return NULL;
9983 }
9984
9985
9986 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9987 PyObject *resultobj;
9988 wxLogChain *arg1 = (wxLogChain *) 0 ;
9989 bool result;
9990 PyObject * obj0 = 0 ;
9991 char *kwnames[] = {
9992 (char *) "self", NULL
9993 };
9994
9995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9997 if (SWIG_arg_fail(1)) SWIG_fail;
9998 {
9999 PyThreadState* __tstate = wxPyBeginAllowThreads();
10000 result = (bool)(arg1)->IsPassingMessages();
10001
10002 wxPyEndAllowThreads(__tstate);
10003 if (PyErr_Occurred()) SWIG_fail;
10004 }
10005 {
10006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10007 }
10008 return resultobj;
10009 fail:
10010 return NULL;
10011 }
10012
10013
10014 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
10015 PyObject *resultobj;
10016 wxLogChain *arg1 = (wxLogChain *) 0 ;
10017 wxLog *result;
10018 PyObject * obj0 = 0 ;
10019 char *kwnames[] = {
10020 (char *) "self", NULL
10021 };
10022
10023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
10024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10025 if (SWIG_arg_fail(1)) SWIG_fail;
10026 {
10027 PyThreadState* __tstate = wxPyBeginAllowThreads();
10028 result = (wxLog *)(arg1)->GetOldLog();
10029
10030 wxPyEndAllowThreads(__tstate);
10031 if (PyErr_Occurred()) SWIG_fail;
10032 }
10033 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
10034 return resultobj;
10035 fail:
10036 return NULL;
10037 }
10038
10039
10040 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
10041 PyObject *obj;
10042 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10043 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
10044 Py_INCREF(obj);
10045 return Py_BuildValue((char *)"");
10046 }
10047 static PyObject *_wrap_new_LogBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
10048 PyObject *resultobj;
10049 wxLogBuffer *result;
10050 char *kwnames[] = {
10051 NULL
10052 };
10053
10054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogBuffer",kwnames)) goto fail;
10055 {
10056 PyThreadState* __tstate = wxPyBeginAllowThreads();
10057 result = (wxLogBuffer *)new wxLogBuffer();
10058
10059 wxPyEndAllowThreads(__tstate);
10060 if (PyErr_Occurred()) SWIG_fail;
10061 }
10062 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogBuffer, 1);
10063 return resultobj;
10064 fail:
10065 return NULL;
10066 }
10067
10068
10069 static PyObject *_wrap_LogBuffer_GetBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
10070 PyObject *resultobj;
10071 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
10072 wxString *result;
10073 PyObject * obj0 = 0 ;
10074 char *kwnames[] = {
10075 (char *) "self", NULL
10076 };
10077
10078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogBuffer_GetBuffer",kwnames,&obj0)) goto fail;
10079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_EXCEPTION | 0);
10080 if (SWIG_arg_fail(1)) SWIG_fail;
10081 {
10082 PyThreadState* __tstate = wxPyBeginAllowThreads();
10083 {
10084 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
10085 result = (wxString *) &_result_ref;
10086 }
10087
10088 wxPyEndAllowThreads(__tstate);
10089 if (PyErr_Occurred()) SWIG_fail;
10090 }
10091 {
10092 #if wxUSE_UNICODE
10093 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10094 #else
10095 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10096 #endif
10097 }
10098 return resultobj;
10099 fail:
10100 return NULL;
10101 }
10102
10103
10104 static PyObject *_wrap_LogBuffer_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
10105 PyObject *resultobj;
10106 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
10107 PyObject * obj0 = 0 ;
10108 char *kwnames[] = {
10109 (char *) "self", NULL
10110 };
10111
10112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogBuffer_Flush",kwnames,&obj0)) goto fail;
10113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_EXCEPTION | 0);
10114 if (SWIG_arg_fail(1)) SWIG_fail;
10115 {
10116 PyThreadState* __tstate = wxPyBeginAllowThreads();
10117 (arg1)->Flush();
10118
10119 wxPyEndAllowThreads(__tstate);
10120 if (PyErr_Occurred()) SWIG_fail;
10121 }
10122 Py_INCREF(Py_None); resultobj = Py_None;
10123 return resultobj;
10124 fail:
10125 return NULL;
10126 }
10127
10128
10129 static PyObject * LogBuffer_swigregister(PyObject *, PyObject *args) {
10130 PyObject *obj;
10131 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10132 SWIG_TypeClientData(SWIGTYPE_p_wxLogBuffer, obj);
10133 Py_INCREF(obj);
10134 return Py_BuildValue((char *)"");
10135 }
10136 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10137 PyObject *resultobj;
10138 unsigned long result;
10139 char *kwnames[] = {
10140 NULL
10141 };
10142
10143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10144 {
10145 PyThreadState* __tstate = wxPyBeginAllowThreads();
10146 result = (unsigned long)wxSysErrorCode();
10147
10148 wxPyEndAllowThreads(__tstate);
10149 if (PyErr_Occurred()) SWIG_fail;
10150 }
10151 {
10152 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10153 }
10154 return resultobj;
10155 fail:
10156 return NULL;
10157 }
10158
10159
10160 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10161 PyObject *resultobj;
10162 unsigned long arg1 = (unsigned long) 0 ;
10163 wxString result;
10164 PyObject * obj0 = 0 ;
10165 char *kwnames[] = {
10166 (char *) "nErrCode", NULL
10167 };
10168
10169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10170 if (obj0) {
10171 {
10172 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10173 if (SWIG_arg_fail(1)) SWIG_fail;
10174 }
10175 }
10176 {
10177 PyThreadState* __tstate = wxPyBeginAllowThreads();
10178 result = wxSysErrorMsg(arg1);
10179
10180 wxPyEndAllowThreads(__tstate);
10181 if (PyErr_Occurred()) SWIG_fail;
10182 }
10183 {
10184 #if wxUSE_UNICODE
10185 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10186 #else
10187 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10188 #endif
10189 }
10190 return resultobj;
10191 fail:
10192 return NULL;
10193 }
10194
10195
10196 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10197 PyObject *resultobj;
10198 wxString *arg1 = 0 ;
10199 bool temp1 = false ;
10200 PyObject * obj0 = 0 ;
10201 char *kwnames[] = {
10202 (char *) "msg", NULL
10203 };
10204
10205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10206 {
10207 arg1 = wxString_in_helper(obj0);
10208 if (arg1 == NULL) SWIG_fail;
10209 temp1 = true;
10210 }
10211 {
10212 PyThreadState* __tstate = wxPyBeginAllowThreads();
10213 wxPyLogFatalError((wxString const &)*arg1);
10214
10215 wxPyEndAllowThreads(__tstate);
10216 if (PyErr_Occurred()) SWIG_fail;
10217 }
10218 Py_INCREF(Py_None); resultobj = Py_None;
10219 {
10220 if (temp1)
10221 delete arg1;
10222 }
10223 return resultobj;
10224 fail:
10225 {
10226 if (temp1)
10227 delete arg1;
10228 }
10229 return NULL;
10230 }
10231
10232
10233 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10234 PyObject *resultobj;
10235 wxString *arg1 = 0 ;
10236 bool temp1 = false ;
10237 PyObject * obj0 = 0 ;
10238 char *kwnames[] = {
10239 (char *) "msg", NULL
10240 };
10241
10242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10243 {
10244 arg1 = wxString_in_helper(obj0);
10245 if (arg1 == NULL) SWIG_fail;
10246 temp1 = true;
10247 }
10248 {
10249 PyThreadState* __tstate = wxPyBeginAllowThreads();
10250 wxPyLogError((wxString const &)*arg1);
10251
10252 wxPyEndAllowThreads(__tstate);
10253 if (PyErr_Occurred()) SWIG_fail;
10254 }
10255 Py_INCREF(Py_None); resultobj = Py_None;
10256 {
10257 if (temp1)
10258 delete arg1;
10259 }
10260 return resultobj;
10261 fail:
10262 {
10263 if (temp1)
10264 delete arg1;
10265 }
10266 return NULL;
10267 }
10268
10269
10270 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10271 PyObject *resultobj;
10272 wxString *arg1 = 0 ;
10273 bool temp1 = false ;
10274 PyObject * obj0 = 0 ;
10275 char *kwnames[] = {
10276 (char *) "msg", NULL
10277 };
10278
10279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10280 {
10281 arg1 = wxString_in_helper(obj0);
10282 if (arg1 == NULL) SWIG_fail;
10283 temp1 = true;
10284 }
10285 {
10286 PyThreadState* __tstate = wxPyBeginAllowThreads();
10287 wxPyLogWarning((wxString const &)*arg1);
10288
10289 wxPyEndAllowThreads(__tstate);
10290 if (PyErr_Occurred()) SWIG_fail;
10291 }
10292 Py_INCREF(Py_None); resultobj = Py_None;
10293 {
10294 if (temp1)
10295 delete arg1;
10296 }
10297 return resultobj;
10298 fail:
10299 {
10300 if (temp1)
10301 delete arg1;
10302 }
10303 return NULL;
10304 }
10305
10306
10307 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10308 PyObject *resultobj;
10309 wxString *arg1 = 0 ;
10310 bool temp1 = false ;
10311 PyObject * obj0 = 0 ;
10312 char *kwnames[] = {
10313 (char *) "msg", NULL
10314 };
10315
10316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10317 {
10318 arg1 = wxString_in_helper(obj0);
10319 if (arg1 == NULL) SWIG_fail;
10320 temp1 = true;
10321 }
10322 {
10323 PyThreadState* __tstate = wxPyBeginAllowThreads();
10324 wxPyLogMessage((wxString const &)*arg1);
10325
10326 wxPyEndAllowThreads(__tstate);
10327 if (PyErr_Occurred()) SWIG_fail;
10328 }
10329 Py_INCREF(Py_None); resultobj = Py_None;
10330 {
10331 if (temp1)
10332 delete arg1;
10333 }
10334 return resultobj;
10335 fail:
10336 {
10337 if (temp1)
10338 delete arg1;
10339 }
10340 return NULL;
10341 }
10342
10343
10344 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10345 PyObject *resultobj;
10346 wxString *arg1 = 0 ;
10347 bool temp1 = false ;
10348 PyObject * obj0 = 0 ;
10349 char *kwnames[] = {
10350 (char *) "msg", NULL
10351 };
10352
10353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10354 {
10355 arg1 = wxString_in_helper(obj0);
10356 if (arg1 == NULL) SWIG_fail;
10357 temp1 = true;
10358 }
10359 {
10360 PyThreadState* __tstate = wxPyBeginAllowThreads();
10361 wxPyLogInfo((wxString const &)*arg1);
10362
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 Py_INCREF(Py_None); resultobj = Py_None;
10367 {
10368 if (temp1)
10369 delete arg1;
10370 }
10371 return resultobj;
10372 fail:
10373 {
10374 if (temp1)
10375 delete arg1;
10376 }
10377 return NULL;
10378 }
10379
10380
10381 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10382 PyObject *resultobj;
10383 wxString *arg1 = 0 ;
10384 bool temp1 = false ;
10385 PyObject * obj0 = 0 ;
10386 char *kwnames[] = {
10387 (char *) "msg", NULL
10388 };
10389
10390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10391 {
10392 arg1 = wxString_in_helper(obj0);
10393 if (arg1 == NULL) SWIG_fail;
10394 temp1 = true;
10395 }
10396 {
10397 PyThreadState* __tstate = wxPyBeginAllowThreads();
10398 wxPyLogDebug((wxString const &)*arg1);
10399
10400 wxPyEndAllowThreads(__tstate);
10401 if (PyErr_Occurred()) SWIG_fail;
10402 }
10403 Py_INCREF(Py_None); resultobj = Py_None;
10404 {
10405 if (temp1)
10406 delete arg1;
10407 }
10408 return resultobj;
10409 fail:
10410 {
10411 if (temp1)
10412 delete arg1;
10413 }
10414 return NULL;
10415 }
10416
10417
10418 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10419 PyObject *resultobj;
10420 wxString *arg1 = 0 ;
10421 bool temp1 = false ;
10422 PyObject * obj0 = 0 ;
10423 char *kwnames[] = {
10424 (char *) "msg", NULL
10425 };
10426
10427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10428 {
10429 arg1 = wxString_in_helper(obj0);
10430 if (arg1 == NULL) SWIG_fail;
10431 temp1 = true;
10432 }
10433 {
10434 PyThreadState* __tstate = wxPyBeginAllowThreads();
10435 wxPyLogVerbose((wxString const &)*arg1);
10436
10437 wxPyEndAllowThreads(__tstate);
10438 if (PyErr_Occurred()) SWIG_fail;
10439 }
10440 Py_INCREF(Py_None); resultobj = Py_None;
10441 {
10442 if (temp1)
10443 delete arg1;
10444 }
10445 return resultobj;
10446 fail:
10447 {
10448 if (temp1)
10449 delete arg1;
10450 }
10451 return NULL;
10452 }
10453
10454
10455 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10456 PyObject *resultobj;
10457 wxString *arg1 = 0 ;
10458 bool temp1 = false ;
10459 PyObject * obj0 = 0 ;
10460 char *kwnames[] = {
10461 (char *) "msg", NULL
10462 };
10463
10464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10465 {
10466 arg1 = wxString_in_helper(obj0);
10467 if (arg1 == NULL) SWIG_fail;
10468 temp1 = true;
10469 }
10470 {
10471 PyThreadState* __tstate = wxPyBeginAllowThreads();
10472 wxPyLogStatus((wxString const &)*arg1);
10473
10474 wxPyEndAllowThreads(__tstate);
10475 if (PyErr_Occurred()) SWIG_fail;
10476 }
10477 Py_INCREF(Py_None); resultobj = Py_None;
10478 {
10479 if (temp1)
10480 delete arg1;
10481 }
10482 return resultobj;
10483 fail:
10484 {
10485 if (temp1)
10486 delete arg1;
10487 }
10488 return NULL;
10489 }
10490
10491
10492 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10493 PyObject *resultobj;
10494 wxFrame *arg1 = (wxFrame *) 0 ;
10495 wxString *arg2 = 0 ;
10496 bool temp2 = false ;
10497 PyObject * obj0 = 0 ;
10498 PyObject * obj1 = 0 ;
10499 char *kwnames[] = {
10500 (char *) "pFrame",(char *) "msg", NULL
10501 };
10502
10503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10505 if (SWIG_arg_fail(1)) SWIG_fail;
10506 {
10507 arg2 = wxString_in_helper(obj1);
10508 if (arg2 == NULL) SWIG_fail;
10509 temp2 = true;
10510 }
10511 {
10512 PyThreadState* __tstate = wxPyBeginAllowThreads();
10513 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10514
10515 wxPyEndAllowThreads(__tstate);
10516 if (PyErr_Occurred()) SWIG_fail;
10517 }
10518 Py_INCREF(Py_None); resultobj = Py_None;
10519 {
10520 if (temp2)
10521 delete arg2;
10522 }
10523 return resultobj;
10524 fail:
10525 {
10526 if (temp2)
10527 delete arg2;
10528 }
10529 return NULL;
10530 }
10531
10532
10533 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10534 PyObject *resultobj;
10535 wxString *arg1 = 0 ;
10536 bool temp1 = false ;
10537 PyObject * obj0 = 0 ;
10538 char *kwnames[] = {
10539 (char *) "msg", NULL
10540 };
10541
10542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10543 {
10544 arg1 = wxString_in_helper(obj0);
10545 if (arg1 == NULL) SWIG_fail;
10546 temp1 = true;
10547 }
10548 {
10549 PyThreadState* __tstate = wxPyBeginAllowThreads();
10550 wxPyLogSysError((wxString const &)*arg1);
10551
10552 wxPyEndAllowThreads(__tstate);
10553 if (PyErr_Occurred()) SWIG_fail;
10554 }
10555 Py_INCREF(Py_None); resultobj = Py_None;
10556 {
10557 if (temp1)
10558 delete arg1;
10559 }
10560 return resultobj;
10561 fail:
10562 {
10563 if (temp1)
10564 delete arg1;
10565 }
10566 return NULL;
10567 }
10568
10569
10570 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10571 PyObject *resultobj;
10572 unsigned long arg1 ;
10573 wxString *arg2 = 0 ;
10574 bool temp2 = false ;
10575 PyObject * obj0 = 0 ;
10576 PyObject * obj1 = 0 ;
10577 char *kwnames[] = {
10578 (char *) "level",(char *) "msg", NULL
10579 };
10580
10581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10582 {
10583 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10584 if (SWIG_arg_fail(1)) SWIG_fail;
10585 }
10586 {
10587 arg2 = wxString_in_helper(obj1);
10588 if (arg2 == NULL) SWIG_fail;
10589 temp2 = true;
10590 }
10591 {
10592 PyThreadState* __tstate = wxPyBeginAllowThreads();
10593 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10594
10595 wxPyEndAllowThreads(__tstate);
10596 if (PyErr_Occurred()) SWIG_fail;
10597 }
10598 Py_INCREF(Py_None); resultobj = Py_None;
10599 {
10600 if (temp2)
10601 delete arg2;
10602 }
10603 return resultobj;
10604 fail:
10605 {
10606 if (temp2)
10607 delete arg2;
10608 }
10609 return NULL;
10610 }
10611
10612
10613 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10614 PyObject *resultobj;
10615 unsigned long arg1 ;
10616 wxString *arg2 = 0 ;
10617 bool temp2 = false ;
10618 PyObject * obj0 = 0 ;
10619 PyObject * obj1 = 0 ;
10620
10621 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10622 {
10623 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10624 if (SWIG_arg_fail(1)) SWIG_fail;
10625 }
10626 {
10627 arg2 = wxString_in_helper(obj1);
10628 if (arg2 == NULL) SWIG_fail;
10629 temp2 = true;
10630 }
10631 {
10632 PyThreadState* __tstate = wxPyBeginAllowThreads();
10633 wxPyLogTrace(arg1,(wxString const &)*arg2);
10634
10635 wxPyEndAllowThreads(__tstate);
10636 if (PyErr_Occurred()) SWIG_fail;
10637 }
10638 Py_INCREF(Py_None); resultobj = Py_None;
10639 {
10640 if (temp2)
10641 delete arg2;
10642 }
10643 return resultobj;
10644 fail:
10645 {
10646 if (temp2)
10647 delete arg2;
10648 }
10649 return NULL;
10650 }
10651
10652
10653 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10654 PyObject *resultobj;
10655 wxString *arg1 = 0 ;
10656 wxString *arg2 = 0 ;
10657 bool temp1 = false ;
10658 bool temp2 = false ;
10659 PyObject * obj0 = 0 ;
10660 PyObject * obj1 = 0 ;
10661
10662 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10663 {
10664 arg1 = wxString_in_helper(obj0);
10665 if (arg1 == NULL) SWIG_fail;
10666 temp1 = true;
10667 }
10668 {
10669 arg2 = wxString_in_helper(obj1);
10670 if (arg2 == NULL) SWIG_fail;
10671 temp2 = true;
10672 }
10673 {
10674 PyThreadState* __tstate = wxPyBeginAllowThreads();
10675 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10676
10677 wxPyEndAllowThreads(__tstate);
10678 if (PyErr_Occurred()) SWIG_fail;
10679 }
10680 Py_INCREF(Py_None); resultobj = Py_None;
10681 {
10682 if (temp1)
10683 delete arg1;
10684 }
10685 {
10686 if (temp2)
10687 delete arg2;
10688 }
10689 return resultobj;
10690 fail:
10691 {
10692 if (temp1)
10693 delete arg1;
10694 }
10695 {
10696 if (temp2)
10697 delete arg2;
10698 }
10699 return NULL;
10700 }
10701
10702
10703 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10704 int argc;
10705 PyObject *argv[3];
10706 int ii;
10707
10708 argc = PyObject_Length(args);
10709 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10710 argv[ii] = PyTuple_GetItem(args,ii);
10711 }
10712 if (argc == 2) {
10713 int _v;
10714 {
10715 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10716 }
10717 if (_v) {
10718 {
10719 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10720 }
10721 if (_v) {
10722 return _wrap_LogTrace__SWIG_1(self,args);
10723 }
10724 }
10725 }
10726 if (argc == 2) {
10727 int _v;
10728 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10729 if (_v) {
10730 {
10731 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10732 }
10733 if (_v) {
10734 return _wrap_LogTrace__SWIG_0(self,args);
10735 }
10736 }
10737 }
10738
10739 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10740 return NULL;
10741 }
10742
10743
10744 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10745 PyObject *resultobj;
10746 wxString *arg1 = 0 ;
10747 wxString *arg2 = 0 ;
10748 bool temp1 = false ;
10749 bool temp2 = false ;
10750 PyObject * obj0 = 0 ;
10751 PyObject * obj1 = 0 ;
10752 char *kwnames[] = {
10753 (char *) "title",(char *) "text", NULL
10754 };
10755
10756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10757 {
10758 arg1 = wxString_in_helper(obj0);
10759 if (arg1 == NULL) SWIG_fail;
10760 temp1 = true;
10761 }
10762 {
10763 arg2 = wxString_in_helper(obj1);
10764 if (arg2 == NULL) SWIG_fail;
10765 temp2 = true;
10766 }
10767 {
10768 PyThreadState* __tstate = wxPyBeginAllowThreads();
10769 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10770
10771 wxPyEndAllowThreads(__tstate);
10772 if (PyErr_Occurred()) SWIG_fail;
10773 }
10774 Py_INCREF(Py_None); resultobj = Py_None;
10775 {
10776 if (temp1)
10777 delete arg1;
10778 }
10779 {
10780 if (temp2)
10781 delete arg2;
10782 }
10783 return resultobj;
10784 fail:
10785 {
10786 if (temp1)
10787 delete arg1;
10788 }
10789 {
10790 if (temp2)
10791 delete arg2;
10792 }
10793 return NULL;
10794 }
10795
10796
10797 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10798 PyObject *resultobj;
10799 wxLogNull *result;
10800 char *kwnames[] = {
10801 NULL
10802 };
10803
10804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10805 {
10806 PyThreadState* __tstate = wxPyBeginAllowThreads();
10807 result = (wxLogNull *)new wxLogNull();
10808
10809 wxPyEndAllowThreads(__tstate);
10810 if (PyErr_Occurred()) SWIG_fail;
10811 }
10812 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10813 return resultobj;
10814 fail:
10815 return NULL;
10816 }
10817
10818
10819 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10820 PyObject *resultobj;
10821 wxLogNull *arg1 = (wxLogNull *) 0 ;
10822 PyObject * obj0 = 0 ;
10823 char *kwnames[] = {
10824 (char *) "self", NULL
10825 };
10826
10827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10829 if (SWIG_arg_fail(1)) SWIG_fail;
10830 {
10831 PyThreadState* __tstate = wxPyBeginAllowThreads();
10832 delete arg1;
10833
10834 wxPyEndAllowThreads(__tstate);
10835 if (PyErr_Occurred()) SWIG_fail;
10836 }
10837 Py_INCREF(Py_None); resultobj = Py_None;
10838 return resultobj;
10839 fail:
10840 return NULL;
10841 }
10842
10843
10844 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10845 PyObject *obj;
10846 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10847 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10848 Py_INCREF(obj);
10849 return Py_BuildValue((char *)"");
10850 }
10851 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10852 PyObject *resultobj;
10853 wxPyLog *result;
10854 char *kwnames[] = {
10855 NULL
10856 };
10857
10858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10859 {
10860 PyThreadState* __tstate = wxPyBeginAllowThreads();
10861 result = (wxPyLog *)new wxPyLog();
10862
10863 wxPyEndAllowThreads(__tstate);
10864 if (PyErr_Occurred()) SWIG_fail;
10865 }
10866 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10867 return resultobj;
10868 fail:
10869 return NULL;
10870 }
10871
10872
10873 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10874 PyObject *resultobj;
10875 wxPyLog *arg1 = (wxPyLog *) 0 ;
10876 PyObject *arg2 = (PyObject *) 0 ;
10877 PyObject *arg3 = (PyObject *) 0 ;
10878 PyObject * obj0 = 0 ;
10879 PyObject * obj1 = 0 ;
10880 PyObject * obj2 = 0 ;
10881 char *kwnames[] = {
10882 (char *) "self",(char *) "self",(char *) "_class", NULL
10883 };
10884
10885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10887 if (SWIG_arg_fail(1)) SWIG_fail;
10888 arg2 = obj1;
10889 arg3 = obj2;
10890 {
10891 PyThreadState* __tstate = wxPyBeginAllowThreads();
10892 (arg1)->_setCallbackInfo(arg2,arg3);
10893
10894 wxPyEndAllowThreads(__tstate);
10895 if (PyErr_Occurred()) SWIG_fail;
10896 }
10897 Py_INCREF(Py_None); resultobj = Py_None;
10898 return resultobj;
10899 fail:
10900 return NULL;
10901 }
10902
10903
10904 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10905 PyObject *obj;
10906 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10907 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10908 Py_INCREF(obj);
10909 return Py_BuildValue((char *)"");
10910 }
10911 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10912 PyObject *resultobj;
10913 int arg1 ;
10914 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10915 int arg3 = (int) wxKILL_NOCHILDREN ;
10916 wxKillError result;
10917 PyObject * obj0 = 0 ;
10918 PyObject * obj1 = 0 ;
10919 PyObject * obj2 = 0 ;
10920 char *kwnames[] = {
10921 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10922 };
10923
10924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10925 {
10926 arg1 = (int)(SWIG_As_int(obj0));
10927 if (SWIG_arg_fail(1)) SWIG_fail;
10928 }
10929 if (obj1) {
10930 {
10931 arg2 = (wxSignal)(SWIG_As_int(obj1));
10932 if (SWIG_arg_fail(2)) SWIG_fail;
10933 }
10934 }
10935 if (obj2) {
10936 {
10937 arg3 = (int)(SWIG_As_int(obj2));
10938 if (SWIG_arg_fail(3)) SWIG_fail;
10939 }
10940 }
10941 {
10942 PyThreadState* __tstate = wxPyBeginAllowThreads();
10943 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10944
10945 wxPyEndAllowThreads(__tstate);
10946 if (PyErr_Occurred()) SWIG_fail;
10947 }
10948 resultobj = SWIG_From_int((result));
10949 return resultobj;
10950 fail:
10951 return NULL;
10952 }
10953
10954
10955 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10956 PyObject *resultobj;
10957 int arg1 ;
10958 bool result;
10959 PyObject * obj0 = 0 ;
10960 char *kwnames[] = {
10961 (char *) "pid", NULL
10962 };
10963
10964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10965 {
10966 arg1 = (int)(SWIG_As_int(obj0));
10967 if (SWIG_arg_fail(1)) SWIG_fail;
10968 }
10969 {
10970 PyThreadState* __tstate = wxPyBeginAllowThreads();
10971 result = (bool)wxPyProcess::Exists(arg1);
10972
10973 wxPyEndAllowThreads(__tstate);
10974 if (PyErr_Occurred()) SWIG_fail;
10975 }
10976 {
10977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10978 }
10979 return resultobj;
10980 fail:
10981 return NULL;
10982 }
10983
10984
10985 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10986 PyObject *resultobj;
10987 wxString *arg1 = 0 ;
10988 int arg2 = (int) wxEXEC_ASYNC ;
10989 wxPyProcess *result;
10990 bool temp1 = false ;
10991 PyObject * obj0 = 0 ;
10992 PyObject * obj1 = 0 ;
10993 char *kwnames[] = {
10994 (char *) "cmd",(char *) "flags", NULL
10995 };
10996
10997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10998 {
10999 arg1 = wxString_in_helper(obj0);
11000 if (arg1 == NULL) SWIG_fail;
11001 temp1 = true;
11002 }
11003 if (obj1) {
11004 {
11005 arg2 = (int)(SWIG_As_int(obj1));
11006 if (SWIG_arg_fail(2)) SWIG_fail;
11007 }
11008 }
11009 {
11010 PyThreadState* __tstate = wxPyBeginAllowThreads();
11011 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
11012
11013 wxPyEndAllowThreads(__tstate);
11014 if (PyErr_Occurred()) SWIG_fail;
11015 }
11016 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
11017 {
11018 if (temp1)
11019 delete arg1;
11020 }
11021 return resultobj;
11022 fail:
11023 {
11024 if (temp1)
11025 delete arg1;
11026 }
11027 return NULL;
11028 }
11029
11030
11031 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
11032 PyObject *resultobj;
11033 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11034 int arg2 = (int) -1 ;
11035 wxPyProcess *result;
11036 PyObject * obj0 = 0 ;
11037 PyObject * obj1 = 0 ;
11038 char *kwnames[] = {
11039 (char *) "parent",(char *) "id", NULL
11040 };
11041
11042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
11043 if (obj0) {
11044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
11045 if (SWIG_arg_fail(1)) SWIG_fail;
11046 }
11047 if (obj1) {
11048 {
11049 arg2 = (int)(SWIG_As_int(obj1));
11050 if (SWIG_arg_fail(2)) SWIG_fail;
11051 }
11052 }
11053 {
11054 PyThreadState* __tstate = wxPyBeginAllowThreads();
11055 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
11056
11057 wxPyEndAllowThreads(__tstate);
11058 if (PyErr_Occurred()) SWIG_fail;
11059 }
11060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
11061 return resultobj;
11062 fail:
11063 return NULL;
11064 }
11065
11066
11067 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11068 PyObject *resultobj;
11069 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11070 PyObject *arg2 = (PyObject *) 0 ;
11071 PyObject *arg3 = (PyObject *) 0 ;
11072 PyObject * obj0 = 0 ;
11073 PyObject * obj1 = 0 ;
11074 PyObject * obj2 = 0 ;
11075 char *kwnames[] = {
11076 (char *) "self",(char *) "self",(char *) "_class", NULL
11077 };
11078
11079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11081 if (SWIG_arg_fail(1)) SWIG_fail;
11082 arg2 = obj1;
11083 arg3 = obj2;
11084 {
11085 PyThreadState* __tstate = wxPyBeginAllowThreads();
11086 (arg1)->_setCallbackInfo(arg2,arg3);
11087
11088 wxPyEndAllowThreads(__tstate);
11089 if (PyErr_Occurred()) SWIG_fail;
11090 }
11091 Py_INCREF(Py_None); resultobj = Py_None;
11092 return resultobj;
11093 fail:
11094 return NULL;
11095 }
11096
11097
11098 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
11099 PyObject *resultobj;
11100 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11101 int arg2 ;
11102 int arg3 ;
11103 PyObject * obj0 = 0 ;
11104 PyObject * obj1 = 0 ;
11105 PyObject * obj2 = 0 ;
11106 char *kwnames[] = {
11107 (char *) "self",(char *) "pid",(char *) "status", NULL
11108 };
11109
11110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
11111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11112 if (SWIG_arg_fail(1)) SWIG_fail;
11113 {
11114 arg2 = (int)(SWIG_As_int(obj1));
11115 if (SWIG_arg_fail(2)) SWIG_fail;
11116 }
11117 {
11118 arg3 = (int)(SWIG_As_int(obj2));
11119 if (SWIG_arg_fail(3)) SWIG_fail;
11120 }
11121 {
11122 PyThreadState* __tstate = wxPyBeginAllowThreads();
11123 (arg1)->base_OnTerminate(arg2,arg3);
11124
11125 wxPyEndAllowThreads(__tstate);
11126 if (PyErr_Occurred()) SWIG_fail;
11127 }
11128 Py_INCREF(Py_None); resultobj = Py_None;
11129 return resultobj;
11130 fail:
11131 return NULL;
11132 }
11133
11134
11135 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11136 PyObject *resultobj;
11137 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11138 PyObject * obj0 = 0 ;
11139 char *kwnames[] = {
11140 (char *) "self", NULL
11141 };
11142
11143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11145 if (SWIG_arg_fail(1)) SWIG_fail;
11146 {
11147 PyThreadState* __tstate = wxPyBeginAllowThreads();
11148 (arg1)->Redirect();
11149
11150 wxPyEndAllowThreads(__tstate);
11151 if (PyErr_Occurred()) SWIG_fail;
11152 }
11153 Py_INCREF(Py_None); resultobj = Py_None;
11154 return resultobj;
11155 fail:
11156 return NULL;
11157 }
11158
11159
11160 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11161 PyObject *resultobj;
11162 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11163 bool result;
11164 PyObject * obj0 = 0 ;
11165 char *kwnames[] = {
11166 (char *) "self", NULL
11167 };
11168
11169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11171 if (SWIG_arg_fail(1)) SWIG_fail;
11172 {
11173 PyThreadState* __tstate = wxPyBeginAllowThreads();
11174 result = (bool)(arg1)->IsRedirected();
11175
11176 wxPyEndAllowThreads(__tstate);
11177 if (PyErr_Occurred()) SWIG_fail;
11178 }
11179 {
11180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11181 }
11182 return resultobj;
11183 fail:
11184 return NULL;
11185 }
11186
11187
11188 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11189 PyObject *resultobj;
11190 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11191 PyObject * obj0 = 0 ;
11192 char *kwnames[] = {
11193 (char *) "self", NULL
11194 };
11195
11196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11198 if (SWIG_arg_fail(1)) SWIG_fail;
11199 {
11200 PyThreadState* __tstate = wxPyBeginAllowThreads();
11201 (arg1)->Detach();
11202
11203 wxPyEndAllowThreads(__tstate);
11204 if (PyErr_Occurred()) SWIG_fail;
11205 }
11206 Py_INCREF(Py_None); resultobj = Py_None;
11207 return resultobj;
11208 fail:
11209 return NULL;
11210 }
11211
11212
11213 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11214 PyObject *resultobj;
11215 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11216 wxInputStream *result;
11217 PyObject * obj0 = 0 ;
11218 char *kwnames[] = {
11219 (char *) "self", NULL
11220 };
11221
11222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11224 if (SWIG_arg_fail(1)) SWIG_fail;
11225 {
11226 PyThreadState* __tstate = wxPyBeginAllowThreads();
11227 result = (wxInputStream *)(arg1)->GetInputStream();
11228
11229 wxPyEndAllowThreads(__tstate);
11230 if (PyErr_Occurred()) SWIG_fail;
11231 }
11232 {
11233 wxPyInputStream * _ptr = NULL;
11234
11235 if (result) {
11236 _ptr = new wxPyInputStream(result);
11237 }
11238 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11239 }
11240 return resultobj;
11241 fail:
11242 return NULL;
11243 }
11244
11245
11246 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11247 PyObject *resultobj;
11248 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11249 wxInputStream *result;
11250 PyObject * obj0 = 0 ;
11251 char *kwnames[] = {
11252 (char *) "self", NULL
11253 };
11254
11255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11257 if (SWIG_arg_fail(1)) SWIG_fail;
11258 {
11259 PyThreadState* __tstate = wxPyBeginAllowThreads();
11260 result = (wxInputStream *)(arg1)->GetErrorStream();
11261
11262 wxPyEndAllowThreads(__tstate);
11263 if (PyErr_Occurred()) SWIG_fail;
11264 }
11265 {
11266 wxPyInputStream * _ptr = NULL;
11267
11268 if (result) {
11269 _ptr = new wxPyInputStream(result);
11270 }
11271 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11272 }
11273 return resultobj;
11274 fail:
11275 return NULL;
11276 }
11277
11278
11279 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11280 PyObject *resultobj;
11281 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11282 wxOutputStream *result;
11283 PyObject * obj0 = 0 ;
11284 char *kwnames[] = {
11285 (char *) "self", NULL
11286 };
11287
11288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11290 if (SWIG_arg_fail(1)) SWIG_fail;
11291 {
11292 PyThreadState* __tstate = wxPyBeginAllowThreads();
11293 result = (wxOutputStream *)(arg1)->GetOutputStream();
11294
11295 wxPyEndAllowThreads(__tstate);
11296 if (PyErr_Occurred()) SWIG_fail;
11297 }
11298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11299 return resultobj;
11300 fail:
11301 return NULL;
11302 }
11303
11304
11305 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11306 PyObject *resultobj;
11307 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11308 PyObject * obj0 = 0 ;
11309 char *kwnames[] = {
11310 (char *) "self", NULL
11311 };
11312
11313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11315 if (SWIG_arg_fail(1)) SWIG_fail;
11316 {
11317 PyThreadState* __tstate = wxPyBeginAllowThreads();
11318 (arg1)->CloseOutput();
11319
11320 wxPyEndAllowThreads(__tstate);
11321 if (PyErr_Occurred()) SWIG_fail;
11322 }
11323 Py_INCREF(Py_None); resultobj = Py_None;
11324 return resultobj;
11325 fail:
11326 return NULL;
11327 }
11328
11329
11330 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11331 PyObject *resultobj;
11332 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11333 bool result;
11334 PyObject * obj0 = 0 ;
11335 char *kwnames[] = {
11336 (char *) "self", NULL
11337 };
11338
11339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11341 if (SWIG_arg_fail(1)) SWIG_fail;
11342 {
11343 PyThreadState* __tstate = wxPyBeginAllowThreads();
11344 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11345
11346 wxPyEndAllowThreads(__tstate);
11347 if (PyErr_Occurred()) SWIG_fail;
11348 }
11349 {
11350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11351 }
11352 return resultobj;
11353 fail:
11354 return NULL;
11355 }
11356
11357
11358 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11359 PyObject *resultobj;
11360 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11361 bool result;
11362 PyObject * obj0 = 0 ;
11363 char *kwnames[] = {
11364 (char *) "self", NULL
11365 };
11366
11367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11369 if (SWIG_arg_fail(1)) SWIG_fail;
11370 {
11371 PyThreadState* __tstate = wxPyBeginAllowThreads();
11372 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11373
11374 wxPyEndAllowThreads(__tstate);
11375 if (PyErr_Occurred()) SWIG_fail;
11376 }
11377 {
11378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11379 }
11380 return resultobj;
11381 fail:
11382 return NULL;
11383 }
11384
11385
11386 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11387 PyObject *resultobj;
11388 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11389 bool result;
11390 PyObject * obj0 = 0 ;
11391 char *kwnames[] = {
11392 (char *) "self", NULL
11393 };
11394
11395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11397 if (SWIG_arg_fail(1)) SWIG_fail;
11398 {
11399 PyThreadState* __tstate = wxPyBeginAllowThreads();
11400 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11401
11402 wxPyEndAllowThreads(__tstate);
11403 if (PyErr_Occurred()) SWIG_fail;
11404 }
11405 {
11406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11407 }
11408 return resultobj;
11409 fail:
11410 return NULL;
11411 }
11412
11413
11414 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11415 PyObject *obj;
11416 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11417 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11418 Py_INCREF(obj);
11419 return Py_BuildValue((char *)"");
11420 }
11421 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11422 PyObject *resultobj;
11423 int arg1 = (int) 0 ;
11424 int arg2 = (int) 0 ;
11425 int arg3 = (int) 0 ;
11426 wxProcessEvent *result;
11427 PyObject * obj0 = 0 ;
11428 PyObject * obj1 = 0 ;
11429 PyObject * obj2 = 0 ;
11430 char *kwnames[] = {
11431 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11432 };
11433
11434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11435 if (obj0) {
11436 {
11437 arg1 = (int)(SWIG_As_int(obj0));
11438 if (SWIG_arg_fail(1)) SWIG_fail;
11439 }
11440 }
11441 if (obj1) {
11442 {
11443 arg2 = (int)(SWIG_As_int(obj1));
11444 if (SWIG_arg_fail(2)) SWIG_fail;
11445 }
11446 }
11447 if (obj2) {
11448 {
11449 arg3 = (int)(SWIG_As_int(obj2));
11450 if (SWIG_arg_fail(3)) SWIG_fail;
11451 }
11452 }
11453 {
11454 PyThreadState* __tstate = wxPyBeginAllowThreads();
11455 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11456
11457 wxPyEndAllowThreads(__tstate);
11458 if (PyErr_Occurred()) SWIG_fail;
11459 }
11460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11461 return resultobj;
11462 fail:
11463 return NULL;
11464 }
11465
11466
11467 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11468 PyObject *resultobj;
11469 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11470 int result;
11471 PyObject * obj0 = 0 ;
11472 char *kwnames[] = {
11473 (char *) "self", NULL
11474 };
11475
11476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11478 if (SWIG_arg_fail(1)) SWIG_fail;
11479 {
11480 PyThreadState* __tstate = wxPyBeginAllowThreads();
11481 result = (int)(arg1)->GetPid();
11482
11483 wxPyEndAllowThreads(__tstate);
11484 if (PyErr_Occurred()) SWIG_fail;
11485 }
11486 {
11487 resultobj = SWIG_From_int((int)(result));
11488 }
11489 return resultobj;
11490 fail:
11491 return NULL;
11492 }
11493
11494
11495 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11496 PyObject *resultobj;
11497 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11498 int result;
11499 PyObject * obj0 = 0 ;
11500 char *kwnames[] = {
11501 (char *) "self", NULL
11502 };
11503
11504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11506 if (SWIG_arg_fail(1)) SWIG_fail;
11507 {
11508 PyThreadState* __tstate = wxPyBeginAllowThreads();
11509 result = (int)(arg1)->GetExitCode();
11510
11511 wxPyEndAllowThreads(__tstate);
11512 if (PyErr_Occurred()) SWIG_fail;
11513 }
11514 {
11515 resultobj = SWIG_From_int((int)(result));
11516 }
11517 return resultobj;
11518 fail:
11519 return NULL;
11520 }
11521
11522
11523 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11524 PyObject *resultobj;
11525 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11526 int arg2 ;
11527 PyObject * obj0 = 0 ;
11528 PyObject * obj1 = 0 ;
11529 char *kwnames[] = {
11530 (char *) "self",(char *) "m_pid", NULL
11531 };
11532
11533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11535 if (SWIG_arg_fail(1)) SWIG_fail;
11536 {
11537 arg2 = (int)(SWIG_As_int(obj1));
11538 if (SWIG_arg_fail(2)) SWIG_fail;
11539 }
11540 if (arg1) (arg1)->m_pid = arg2;
11541
11542 Py_INCREF(Py_None); resultobj = Py_None;
11543 return resultobj;
11544 fail:
11545 return NULL;
11546 }
11547
11548
11549 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11550 PyObject *resultobj;
11551 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11552 int result;
11553 PyObject * obj0 = 0 ;
11554 char *kwnames[] = {
11555 (char *) "self", NULL
11556 };
11557
11558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11560 if (SWIG_arg_fail(1)) SWIG_fail;
11561 result = (int) ((arg1)->m_pid);
11562
11563 {
11564 resultobj = SWIG_From_int((int)(result));
11565 }
11566 return resultobj;
11567 fail:
11568 return NULL;
11569 }
11570
11571
11572 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11573 PyObject *resultobj;
11574 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11575 int arg2 ;
11576 PyObject * obj0 = 0 ;
11577 PyObject * obj1 = 0 ;
11578 char *kwnames[] = {
11579 (char *) "self",(char *) "m_exitcode", NULL
11580 };
11581
11582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11584 if (SWIG_arg_fail(1)) SWIG_fail;
11585 {
11586 arg2 = (int)(SWIG_As_int(obj1));
11587 if (SWIG_arg_fail(2)) SWIG_fail;
11588 }
11589 if (arg1) (arg1)->m_exitcode = arg2;
11590
11591 Py_INCREF(Py_None); resultobj = Py_None;
11592 return resultobj;
11593 fail:
11594 return NULL;
11595 }
11596
11597
11598 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11599 PyObject *resultobj;
11600 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11601 int result;
11602 PyObject * obj0 = 0 ;
11603 char *kwnames[] = {
11604 (char *) "self", NULL
11605 };
11606
11607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11609 if (SWIG_arg_fail(1)) SWIG_fail;
11610 result = (int) ((arg1)->m_exitcode);
11611
11612 {
11613 resultobj = SWIG_From_int((int)(result));
11614 }
11615 return resultobj;
11616 fail:
11617 return NULL;
11618 }
11619
11620
11621 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11622 PyObject *obj;
11623 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11624 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11625 Py_INCREF(obj);
11626 return Py_BuildValue((char *)"");
11627 }
11628 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11629 PyObject *resultobj;
11630 wxString *arg1 = 0 ;
11631 int arg2 = (int) wxEXEC_ASYNC ;
11632 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11633 long result;
11634 bool temp1 = false ;
11635 PyObject * obj0 = 0 ;
11636 PyObject * obj1 = 0 ;
11637 PyObject * obj2 = 0 ;
11638 char *kwnames[] = {
11639 (char *) "command",(char *) "flags",(char *) "process", NULL
11640 };
11641
11642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11643 {
11644 arg1 = wxString_in_helper(obj0);
11645 if (arg1 == NULL) SWIG_fail;
11646 temp1 = true;
11647 }
11648 if (obj1) {
11649 {
11650 arg2 = (int)(SWIG_As_int(obj1));
11651 if (SWIG_arg_fail(2)) SWIG_fail;
11652 }
11653 }
11654 if (obj2) {
11655 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11656 if (SWIG_arg_fail(3)) SWIG_fail;
11657 }
11658 {
11659 if (!wxPyCheckForApp()) SWIG_fail;
11660 PyThreadState* __tstate = wxPyBeginAllowThreads();
11661 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11662
11663 wxPyEndAllowThreads(__tstate);
11664 if (PyErr_Occurred()) SWIG_fail;
11665 }
11666 {
11667 resultobj = SWIG_From_long((long)(result));
11668 }
11669 {
11670 if (temp1)
11671 delete arg1;
11672 }
11673 return resultobj;
11674 fail:
11675 {
11676 if (temp1)
11677 delete arg1;
11678 }
11679 return NULL;
11680 }
11681
11682
11683 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11684 PyObject *resultobj;
11685 long arg1 ;
11686 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11687 wxKillError *arg3 = (wxKillError *) 0 ;
11688 int arg4 = (int) wxKILL_NOCHILDREN ;
11689 int result;
11690 wxKillError temp3 ;
11691 PyObject * obj0 = 0 ;
11692 PyObject * obj1 = 0 ;
11693 PyObject * obj2 = 0 ;
11694 char *kwnames[] = {
11695 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11696 };
11697
11698 {
11699 arg3 = &temp3;
11700 }
11701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11702 {
11703 arg1 = (long)(SWIG_As_long(obj0));
11704 if (SWIG_arg_fail(1)) SWIG_fail;
11705 }
11706 if (obj1) {
11707 {
11708 arg2 = (wxSignal)(SWIG_As_int(obj1));
11709 if (SWIG_arg_fail(2)) SWIG_fail;
11710 }
11711 }
11712 if (obj2) {
11713 {
11714 arg4 = (int)(SWIG_As_int(obj2));
11715 if (SWIG_arg_fail(4)) SWIG_fail;
11716 }
11717 }
11718 {
11719 PyThreadState* __tstate = wxPyBeginAllowThreads();
11720 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11721
11722 wxPyEndAllowThreads(__tstate);
11723 if (PyErr_Occurred()) SWIG_fail;
11724 }
11725 {
11726 resultobj = SWIG_From_int((int)(result));
11727 }
11728 {
11729 PyObject* o;
11730 o = PyInt_FromLong((long) (*arg3));
11731 resultobj = t_output_helper(resultobj, o);
11732 }
11733 return resultobj;
11734 fail:
11735 return NULL;
11736 }
11737
11738
11739 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11740 PyObject *resultobj;
11741 int arg1 = (int) wxJOYSTICK1 ;
11742 wxJoystick *result;
11743 PyObject * obj0 = 0 ;
11744 char *kwnames[] = {
11745 (char *) "joystick", NULL
11746 };
11747
11748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11749 if (obj0) {
11750 {
11751 arg1 = (int)(SWIG_As_int(obj0));
11752 if (SWIG_arg_fail(1)) SWIG_fail;
11753 }
11754 }
11755 {
11756 if (!wxPyCheckForApp()) SWIG_fail;
11757 PyThreadState* __tstate = wxPyBeginAllowThreads();
11758 result = (wxJoystick *)new wxJoystick(arg1);
11759
11760 wxPyEndAllowThreads(__tstate);
11761 if (PyErr_Occurred()) SWIG_fail;
11762 }
11763 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11764 return resultobj;
11765 fail:
11766 return NULL;
11767 }
11768
11769
11770 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11771 PyObject *resultobj;
11772 wxJoystick *arg1 = (wxJoystick *) 0 ;
11773 PyObject * obj0 = 0 ;
11774 char *kwnames[] = {
11775 (char *) "self", NULL
11776 };
11777
11778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11780 if (SWIG_arg_fail(1)) SWIG_fail;
11781 {
11782 PyThreadState* __tstate = wxPyBeginAllowThreads();
11783 delete arg1;
11784
11785 wxPyEndAllowThreads(__tstate);
11786 if (PyErr_Occurred()) SWIG_fail;
11787 }
11788 Py_INCREF(Py_None); resultobj = Py_None;
11789 return resultobj;
11790 fail:
11791 return NULL;
11792 }
11793
11794
11795 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11796 PyObject *resultobj;
11797 wxJoystick *arg1 = (wxJoystick *) 0 ;
11798 wxPoint result;
11799 PyObject * obj0 = 0 ;
11800 char *kwnames[] = {
11801 (char *) "self", NULL
11802 };
11803
11804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11806 if (SWIG_arg_fail(1)) SWIG_fail;
11807 {
11808 PyThreadState* __tstate = wxPyBeginAllowThreads();
11809 result = (arg1)->GetPosition();
11810
11811 wxPyEndAllowThreads(__tstate);
11812 if (PyErr_Occurred()) SWIG_fail;
11813 }
11814 {
11815 wxPoint * resultptr;
11816 resultptr = new wxPoint((wxPoint &)(result));
11817 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11818 }
11819 return resultobj;
11820 fail:
11821 return NULL;
11822 }
11823
11824
11825 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11826 PyObject *resultobj;
11827 wxJoystick *arg1 = (wxJoystick *) 0 ;
11828 int result;
11829 PyObject * obj0 = 0 ;
11830 char *kwnames[] = {
11831 (char *) "self", NULL
11832 };
11833
11834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11836 if (SWIG_arg_fail(1)) SWIG_fail;
11837 {
11838 PyThreadState* __tstate = wxPyBeginAllowThreads();
11839 result = (int)(arg1)->GetZPosition();
11840
11841 wxPyEndAllowThreads(__tstate);
11842 if (PyErr_Occurred()) SWIG_fail;
11843 }
11844 {
11845 resultobj = SWIG_From_int((int)(result));
11846 }
11847 return resultobj;
11848 fail:
11849 return NULL;
11850 }
11851
11852
11853 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11854 PyObject *resultobj;
11855 wxJoystick *arg1 = (wxJoystick *) 0 ;
11856 int result;
11857 PyObject * obj0 = 0 ;
11858 char *kwnames[] = {
11859 (char *) "self", NULL
11860 };
11861
11862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11864 if (SWIG_arg_fail(1)) SWIG_fail;
11865 {
11866 PyThreadState* __tstate = wxPyBeginAllowThreads();
11867 result = (int)(arg1)->GetButtonState();
11868
11869 wxPyEndAllowThreads(__tstate);
11870 if (PyErr_Occurred()) SWIG_fail;
11871 }
11872 {
11873 resultobj = SWIG_From_int((int)(result));
11874 }
11875 return resultobj;
11876 fail:
11877 return NULL;
11878 }
11879
11880
11881 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11882 PyObject *resultobj;
11883 wxJoystick *arg1 = (wxJoystick *) 0 ;
11884 int result;
11885 PyObject * obj0 = 0 ;
11886 char *kwnames[] = {
11887 (char *) "self", NULL
11888 };
11889
11890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11892 if (SWIG_arg_fail(1)) SWIG_fail;
11893 {
11894 PyThreadState* __tstate = wxPyBeginAllowThreads();
11895 result = (int)(arg1)->GetPOVPosition();
11896
11897 wxPyEndAllowThreads(__tstate);
11898 if (PyErr_Occurred()) SWIG_fail;
11899 }
11900 {
11901 resultobj = SWIG_From_int((int)(result));
11902 }
11903 return resultobj;
11904 fail:
11905 return NULL;
11906 }
11907
11908
11909 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11910 PyObject *resultobj;
11911 wxJoystick *arg1 = (wxJoystick *) 0 ;
11912 int result;
11913 PyObject * obj0 = 0 ;
11914 char *kwnames[] = {
11915 (char *) "self", NULL
11916 };
11917
11918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11920 if (SWIG_arg_fail(1)) SWIG_fail;
11921 {
11922 PyThreadState* __tstate = wxPyBeginAllowThreads();
11923 result = (int)(arg1)->GetPOVCTSPosition();
11924
11925 wxPyEndAllowThreads(__tstate);
11926 if (PyErr_Occurred()) SWIG_fail;
11927 }
11928 {
11929 resultobj = SWIG_From_int((int)(result));
11930 }
11931 return resultobj;
11932 fail:
11933 return NULL;
11934 }
11935
11936
11937 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11938 PyObject *resultobj;
11939 wxJoystick *arg1 = (wxJoystick *) 0 ;
11940 int result;
11941 PyObject * obj0 = 0 ;
11942 char *kwnames[] = {
11943 (char *) "self", NULL
11944 };
11945
11946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11948 if (SWIG_arg_fail(1)) SWIG_fail;
11949 {
11950 PyThreadState* __tstate = wxPyBeginAllowThreads();
11951 result = (int)(arg1)->GetRudderPosition();
11952
11953 wxPyEndAllowThreads(__tstate);
11954 if (PyErr_Occurred()) SWIG_fail;
11955 }
11956 {
11957 resultobj = SWIG_From_int((int)(result));
11958 }
11959 return resultobj;
11960 fail:
11961 return NULL;
11962 }
11963
11964
11965 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11966 PyObject *resultobj;
11967 wxJoystick *arg1 = (wxJoystick *) 0 ;
11968 int result;
11969 PyObject * obj0 = 0 ;
11970 char *kwnames[] = {
11971 (char *) "self", NULL
11972 };
11973
11974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11976 if (SWIG_arg_fail(1)) SWIG_fail;
11977 {
11978 PyThreadState* __tstate = wxPyBeginAllowThreads();
11979 result = (int)(arg1)->GetUPosition();
11980
11981 wxPyEndAllowThreads(__tstate);
11982 if (PyErr_Occurred()) SWIG_fail;
11983 }
11984 {
11985 resultobj = SWIG_From_int((int)(result));
11986 }
11987 return resultobj;
11988 fail:
11989 return NULL;
11990 }
11991
11992
11993 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11994 PyObject *resultobj;
11995 wxJoystick *arg1 = (wxJoystick *) 0 ;
11996 int result;
11997 PyObject * obj0 = 0 ;
11998 char *kwnames[] = {
11999 (char *) "self", NULL
12000 };
12001
12002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
12003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12004 if (SWIG_arg_fail(1)) SWIG_fail;
12005 {
12006 PyThreadState* __tstate = wxPyBeginAllowThreads();
12007 result = (int)(arg1)->GetVPosition();
12008
12009 wxPyEndAllowThreads(__tstate);
12010 if (PyErr_Occurred()) SWIG_fail;
12011 }
12012 {
12013 resultobj = SWIG_From_int((int)(result));
12014 }
12015 return resultobj;
12016 fail:
12017 return NULL;
12018 }
12019
12020
12021 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
12022 PyObject *resultobj;
12023 wxJoystick *arg1 = (wxJoystick *) 0 ;
12024 int result;
12025 PyObject * obj0 = 0 ;
12026 char *kwnames[] = {
12027 (char *) "self", NULL
12028 };
12029
12030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
12031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12032 if (SWIG_arg_fail(1)) SWIG_fail;
12033 {
12034 PyThreadState* __tstate = wxPyBeginAllowThreads();
12035 result = (int)(arg1)->GetMovementThreshold();
12036
12037 wxPyEndAllowThreads(__tstate);
12038 if (PyErr_Occurred()) SWIG_fail;
12039 }
12040 {
12041 resultobj = SWIG_From_int((int)(result));
12042 }
12043 return resultobj;
12044 fail:
12045 return NULL;
12046 }
12047
12048
12049 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
12050 PyObject *resultobj;
12051 wxJoystick *arg1 = (wxJoystick *) 0 ;
12052 int arg2 ;
12053 PyObject * obj0 = 0 ;
12054 PyObject * obj1 = 0 ;
12055 char *kwnames[] = {
12056 (char *) "self",(char *) "threshold", NULL
12057 };
12058
12059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
12064 if (SWIG_arg_fail(2)) SWIG_fail;
12065 }
12066 {
12067 PyThreadState* __tstate = wxPyBeginAllowThreads();
12068 (arg1)->SetMovementThreshold(arg2);
12069
12070 wxPyEndAllowThreads(__tstate);
12071 if (PyErr_Occurred()) SWIG_fail;
12072 }
12073 Py_INCREF(Py_None); resultobj = Py_None;
12074 return resultobj;
12075 fail:
12076 return NULL;
12077 }
12078
12079
12080 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
12081 PyObject *resultobj;
12082 wxJoystick *arg1 = (wxJoystick *) 0 ;
12083 bool result;
12084 PyObject * obj0 = 0 ;
12085 char *kwnames[] = {
12086 (char *) "self", NULL
12087 };
12088
12089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
12090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12091 if (SWIG_arg_fail(1)) SWIG_fail;
12092 {
12093 PyThreadState* __tstate = wxPyBeginAllowThreads();
12094 result = (bool)(arg1)->IsOk();
12095
12096 wxPyEndAllowThreads(__tstate);
12097 if (PyErr_Occurred()) SWIG_fail;
12098 }
12099 {
12100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12101 }
12102 return resultobj;
12103 fail:
12104 return NULL;
12105 }
12106
12107
12108 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
12109 PyObject *resultobj;
12110 wxJoystick *arg1 = (wxJoystick *) 0 ;
12111 int result;
12112 PyObject * obj0 = 0 ;
12113 char *kwnames[] = {
12114 (char *) "self", NULL
12115 };
12116
12117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
12118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12119 if (SWIG_arg_fail(1)) SWIG_fail;
12120 {
12121 PyThreadState* __tstate = wxPyBeginAllowThreads();
12122 result = (int)(arg1)->GetNumberJoysticks();
12123
12124 wxPyEndAllowThreads(__tstate);
12125 if (PyErr_Occurred()) SWIG_fail;
12126 }
12127 {
12128 resultobj = SWIG_From_int((int)(result));
12129 }
12130 return resultobj;
12131 fail:
12132 return NULL;
12133 }
12134
12135
12136 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12137 PyObject *resultobj;
12138 wxJoystick *arg1 = (wxJoystick *) 0 ;
12139 int result;
12140 PyObject * obj0 = 0 ;
12141 char *kwnames[] = {
12142 (char *) "self", NULL
12143 };
12144
12145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12147 if (SWIG_arg_fail(1)) SWIG_fail;
12148 {
12149 PyThreadState* __tstate = wxPyBeginAllowThreads();
12150 result = (int)(arg1)->GetManufacturerId();
12151
12152 wxPyEndAllowThreads(__tstate);
12153 if (PyErr_Occurred()) SWIG_fail;
12154 }
12155 {
12156 resultobj = SWIG_From_int((int)(result));
12157 }
12158 return resultobj;
12159 fail:
12160 return NULL;
12161 }
12162
12163
12164 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12165 PyObject *resultobj;
12166 wxJoystick *arg1 = (wxJoystick *) 0 ;
12167 int result;
12168 PyObject * obj0 = 0 ;
12169 char *kwnames[] = {
12170 (char *) "self", NULL
12171 };
12172
12173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12175 if (SWIG_arg_fail(1)) SWIG_fail;
12176 {
12177 PyThreadState* __tstate = wxPyBeginAllowThreads();
12178 result = (int)(arg1)->GetProductId();
12179
12180 wxPyEndAllowThreads(__tstate);
12181 if (PyErr_Occurred()) SWIG_fail;
12182 }
12183 {
12184 resultobj = SWIG_From_int((int)(result));
12185 }
12186 return resultobj;
12187 fail:
12188 return NULL;
12189 }
12190
12191
12192 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12193 PyObject *resultobj;
12194 wxJoystick *arg1 = (wxJoystick *) 0 ;
12195 wxString result;
12196 PyObject * obj0 = 0 ;
12197 char *kwnames[] = {
12198 (char *) "self", NULL
12199 };
12200
12201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12203 if (SWIG_arg_fail(1)) SWIG_fail;
12204 {
12205 PyThreadState* __tstate = wxPyBeginAllowThreads();
12206 result = (arg1)->GetProductName();
12207
12208 wxPyEndAllowThreads(__tstate);
12209 if (PyErr_Occurred()) SWIG_fail;
12210 }
12211 {
12212 #if wxUSE_UNICODE
12213 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12214 #else
12215 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12216 #endif
12217 }
12218 return resultobj;
12219 fail:
12220 return NULL;
12221 }
12222
12223
12224 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12225 PyObject *resultobj;
12226 wxJoystick *arg1 = (wxJoystick *) 0 ;
12227 int result;
12228 PyObject * obj0 = 0 ;
12229 char *kwnames[] = {
12230 (char *) "self", NULL
12231 };
12232
12233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12235 if (SWIG_arg_fail(1)) SWIG_fail;
12236 {
12237 PyThreadState* __tstate = wxPyBeginAllowThreads();
12238 result = (int)(arg1)->GetXMin();
12239
12240 wxPyEndAllowThreads(__tstate);
12241 if (PyErr_Occurred()) SWIG_fail;
12242 }
12243 {
12244 resultobj = SWIG_From_int((int)(result));
12245 }
12246 return resultobj;
12247 fail:
12248 return NULL;
12249 }
12250
12251
12252 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12253 PyObject *resultobj;
12254 wxJoystick *arg1 = (wxJoystick *) 0 ;
12255 int result;
12256 PyObject * obj0 = 0 ;
12257 char *kwnames[] = {
12258 (char *) "self", NULL
12259 };
12260
12261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12263 if (SWIG_arg_fail(1)) SWIG_fail;
12264 {
12265 PyThreadState* __tstate = wxPyBeginAllowThreads();
12266 result = (int)(arg1)->GetYMin();
12267
12268 wxPyEndAllowThreads(__tstate);
12269 if (PyErr_Occurred()) SWIG_fail;
12270 }
12271 {
12272 resultobj = SWIG_From_int((int)(result));
12273 }
12274 return resultobj;
12275 fail:
12276 return NULL;
12277 }
12278
12279
12280 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12281 PyObject *resultobj;
12282 wxJoystick *arg1 = (wxJoystick *) 0 ;
12283 int result;
12284 PyObject * obj0 = 0 ;
12285 char *kwnames[] = {
12286 (char *) "self", NULL
12287 };
12288
12289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12291 if (SWIG_arg_fail(1)) SWIG_fail;
12292 {
12293 PyThreadState* __tstate = wxPyBeginAllowThreads();
12294 result = (int)(arg1)->GetZMin();
12295
12296 wxPyEndAllowThreads(__tstate);
12297 if (PyErr_Occurred()) SWIG_fail;
12298 }
12299 {
12300 resultobj = SWIG_From_int((int)(result));
12301 }
12302 return resultobj;
12303 fail:
12304 return NULL;
12305 }
12306
12307
12308 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12309 PyObject *resultobj;
12310 wxJoystick *arg1 = (wxJoystick *) 0 ;
12311 int result;
12312 PyObject * obj0 = 0 ;
12313 char *kwnames[] = {
12314 (char *) "self", NULL
12315 };
12316
12317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12319 if (SWIG_arg_fail(1)) SWIG_fail;
12320 {
12321 PyThreadState* __tstate = wxPyBeginAllowThreads();
12322 result = (int)(arg1)->GetXMax();
12323
12324 wxPyEndAllowThreads(__tstate);
12325 if (PyErr_Occurred()) SWIG_fail;
12326 }
12327 {
12328 resultobj = SWIG_From_int((int)(result));
12329 }
12330 return resultobj;
12331 fail:
12332 return NULL;
12333 }
12334
12335
12336 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12337 PyObject *resultobj;
12338 wxJoystick *arg1 = (wxJoystick *) 0 ;
12339 int result;
12340 PyObject * obj0 = 0 ;
12341 char *kwnames[] = {
12342 (char *) "self", NULL
12343 };
12344
12345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12347 if (SWIG_arg_fail(1)) SWIG_fail;
12348 {
12349 PyThreadState* __tstate = wxPyBeginAllowThreads();
12350 result = (int)(arg1)->GetYMax();
12351
12352 wxPyEndAllowThreads(__tstate);
12353 if (PyErr_Occurred()) SWIG_fail;
12354 }
12355 {
12356 resultobj = SWIG_From_int((int)(result));
12357 }
12358 return resultobj;
12359 fail:
12360 return NULL;
12361 }
12362
12363
12364 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12365 PyObject *resultobj;
12366 wxJoystick *arg1 = (wxJoystick *) 0 ;
12367 int result;
12368 PyObject * obj0 = 0 ;
12369 char *kwnames[] = {
12370 (char *) "self", NULL
12371 };
12372
12373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12375 if (SWIG_arg_fail(1)) SWIG_fail;
12376 {
12377 PyThreadState* __tstate = wxPyBeginAllowThreads();
12378 result = (int)(arg1)->GetZMax();
12379
12380 wxPyEndAllowThreads(__tstate);
12381 if (PyErr_Occurred()) SWIG_fail;
12382 }
12383 {
12384 resultobj = SWIG_From_int((int)(result));
12385 }
12386 return resultobj;
12387 fail:
12388 return NULL;
12389 }
12390
12391
12392 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12393 PyObject *resultobj;
12394 wxJoystick *arg1 = (wxJoystick *) 0 ;
12395 int result;
12396 PyObject * obj0 = 0 ;
12397 char *kwnames[] = {
12398 (char *) "self", NULL
12399 };
12400
12401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12403 if (SWIG_arg_fail(1)) SWIG_fail;
12404 {
12405 PyThreadState* __tstate = wxPyBeginAllowThreads();
12406 result = (int)(arg1)->GetNumberButtons();
12407
12408 wxPyEndAllowThreads(__tstate);
12409 if (PyErr_Occurred()) SWIG_fail;
12410 }
12411 {
12412 resultobj = SWIG_From_int((int)(result));
12413 }
12414 return resultobj;
12415 fail:
12416 return NULL;
12417 }
12418
12419
12420 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12421 PyObject *resultobj;
12422 wxJoystick *arg1 = (wxJoystick *) 0 ;
12423 int result;
12424 PyObject * obj0 = 0 ;
12425 char *kwnames[] = {
12426 (char *) "self", NULL
12427 };
12428
12429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12431 if (SWIG_arg_fail(1)) SWIG_fail;
12432 {
12433 PyThreadState* __tstate = wxPyBeginAllowThreads();
12434 result = (int)(arg1)->GetNumberAxes();
12435
12436 wxPyEndAllowThreads(__tstate);
12437 if (PyErr_Occurred()) SWIG_fail;
12438 }
12439 {
12440 resultobj = SWIG_From_int((int)(result));
12441 }
12442 return resultobj;
12443 fail:
12444 return NULL;
12445 }
12446
12447
12448 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12449 PyObject *resultobj;
12450 wxJoystick *arg1 = (wxJoystick *) 0 ;
12451 int result;
12452 PyObject * obj0 = 0 ;
12453 char *kwnames[] = {
12454 (char *) "self", NULL
12455 };
12456
12457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12459 if (SWIG_arg_fail(1)) SWIG_fail;
12460 {
12461 PyThreadState* __tstate = wxPyBeginAllowThreads();
12462 result = (int)(arg1)->GetMaxButtons();
12463
12464 wxPyEndAllowThreads(__tstate);
12465 if (PyErr_Occurred()) SWIG_fail;
12466 }
12467 {
12468 resultobj = SWIG_From_int((int)(result));
12469 }
12470 return resultobj;
12471 fail:
12472 return NULL;
12473 }
12474
12475
12476 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12477 PyObject *resultobj;
12478 wxJoystick *arg1 = (wxJoystick *) 0 ;
12479 int result;
12480 PyObject * obj0 = 0 ;
12481 char *kwnames[] = {
12482 (char *) "self", NULL
12483 };
12484
12485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12487 if (SWIG_arg_fail(1)) SWIG_fail;
12488 {
12489 PyThreadState* __tstate = wxPyBeginAllowThreads();
12490 result = (int)(arg1)->GetMaxAxes();
12491
12492 wxPyEndAllowThreads(__tstate);
12493 if (PyErr_Occurred()) SWIG_fail;
12494 }
12495 {
12496 resultobj = SWIG_From_int((int)(result));
12497 }
12498 return resultobj;
12499 fail:
12500 return NULL;
12501 }
12502
12503
12504 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12505 PyObject *resultobj;
12506 wxJoystick *arg1 = (wxJoystick *) 0 ;
12507 int result;
12508 PyObject * obj0 = 0 ;
12509 char *kwnames[] = {
12510 (char *) "self", NULL
12511 };
12512
12513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12515 if (SWIG_arg_fail(1)) SWIG_fail;
12516 {
12517 PyThreadState* __tstate = wxPyBeginAllowThreads();
12518 result = (int)(arg1)->GetPollingMin();
12519
12520 wxPyEndAllowThreads(__tstate);
12521 if (PyErr_Occurred()) SWIG_fail;
12522 }
12523 {
12524 resultobj = SWIG_From_int((int)(result));
12525 }
12526 return resultobj;
12527 fail:
12528 return NULL;
12529 }
12530
12531
12532 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12533 PyObject *resultobj;
12534 wxJoystick *arg1 = (wxJoystick *) 0 ;
12535 int result;
12536 PyObject * obj0 = 0 ;
12537 char *kwnames[] = {
12538 (char *) "self", NULL
12539 };
12540
12541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12543 if (SWIG_arg_fail(1)) SWIG_fail;
12544 {
12545 PyThreadState* __tstate = wxPyBeginAllowThreads();
12546 result = (int)(arg1)->GetPollingMax();
12547
12548 wxPyEndAllowThreads(__tstate);
12549 if (PyErr_Occurred()) SWIG_fail;
12550 }
12551 {
12552 resultobj = SWIG_From_int((int)(result));
12553 }
12554 return resultobj;
12555 fail:
12556 return NULL;
12557 }
12558
12559
12560 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12561 PyObject *resultobj;
12562 wxJoystick *arg1 = (wxJoystick *) 0 ;
12563 int result;
12564 PyObject * obj0 = 0 ;
12565 char *kwnames[] = {
12566 (char *) "self", NULL
12567 };
12568
12569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12571 if (SWIG_arg_fail(1)) SWIG_fail;
12572 {
12573 PyThreadState* __tstate = wxPyBeginAllowThreads();
12574 result = (int)(arg1)->GetRudderMin();
12575
12576 wxPyEndAllowThreads(__tstate);
12577 if (PyErr_Occurred()) SWIG_fail;
12578 }
12579 {
12580 resultobj = SWIG_From_int((int)(result));
12581 }
12582 return resultobj;
12583 fail:
12584 return NULL;
12585 }
12586
12587
12588 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12589 PyObject *resultobj;
12590 wxJoystick *arg1 = (wxJoystick *) 0 ;
12591 int result;
12592 PyObject * obj0 = 0 ;
12593 char *kwnames[] = {
12594 (char *) "self", NULL
12595 };
12596
12597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12599 if (SWIG_arg_fail(1)) SWIG_fail;
12600 {
12601 PyThreadState* __tstate = wxPyBeginAllowThreads();
12602 result = (int)(arg1)->GetRudderMax();
12603
12604 wxPyEndAllowThreads(__tstate);
12605 if (PyErr_Occurred()) SWIG_fail;
12606 }
12607 {
12608 resultobj = SWIG_From_int((int)(result));
12609 }
12610 return resultobj;
12611 fail:
12612 return NULL;
12613 }
12614
12615
12616 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12617 PyObject *resultobj;
12618 wxJoystick *arg1 = (wxJoystick *) 0 ;
12619 int result;
12620 PyObject * obj0 = 0 ;
12621 char *kwnames[] = {
12622 (char *) "self", NULL
12623 };
12624
12625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12627 if (SWIG_arg_fail(1)) SWIG_fail;
12628 {
12629 PyThreadState* __tstate = wxPyBeginAllowThreads();
12630 result = (int)(arg1)->GetUMin();
12631
12632 wxPyEndAllowThreads(__tstate);
12633 if (PyErr_Occurred()) SWIG_fail;
12634 }
12635 {
12636 resultobj = SWIG_From_int((int)(result));
12637 }
12638 return resultobj;
12639 fail:
12640 return NULL;
12641 }
12642
12643
12644 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12645 PyObject *resultobj;
12646 wxJoystick *arg1 = (wxJoystick *) 0 ;
12647 int result;
12648 PyObject * obj0 = 0 ;
12649 char *kwnames[] = {
12650 (char *) "self", NULL
12651 };
12652
12653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12655 if (SWIG_arg_fail(1)) SWIG_fail;
12656 {
12657 PyThreadState* __tstate = wxPyBeginAllowThreads();
12658 result = (int)(arg1)->GetUMax();
12659
12660 wxPyEndAllowThreads(__tstate);
12661 if (PyErr_Occurred()) SWIG_fail;
12662 }
12663 {
12664 resultobj = SWIG_From_int((int)(result));
12665 }
12666 return resultobj;
12667 fail:
12668 return NULL;
12669 }
12670
12671
12672 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12673 PyObject *resultobj;
12674 wxJoystick *arg1 = (wxJoystick *) 0 ;
12675 int result;
12676 PyObject * obj0 = 0 ;
12677 char *kwnames[] = {
12678 (char *) "self", NULL
12679 };
12680
12681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12683 if (SWIG_arg_fail(1)) SWIG_fail;
12684 {
12685 PyThreadState* __tstate = wxPyBeginAllowThreads();
12686 result = (int)(arg1)->GetVMin();
12687
12688 wxPyEndAllowThreads(__tstate);
12689 if (PyErr_Occurred()) SWIG_fail;
12690 }
12691 {
12692 resultobj = SWIG_From_int((int)(result));
12693 }
12694 return resultobj;
12695 fail:
12696 return NULL;
12697 }
12698
12699
12700 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12701 PyObject *resultobj;
12702 wxJoystick *arg1 = (wxJoystick *) 0 ;
12703 int result;
12704 PyObject * obj0 = 0 ;
12705 char *kwnames[] = {
12706 (char *) "self", NULL
12707 };
12708
12709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12711 if (SWIG_arg_fail(1)) SWIG_fail;
12712 {
12713 PyThreadState* __tstate = wxPyBeginAllowThreads();
12714 result = (int)(arg1)->GetVMax();
12715
12716 wxPyEndAllowThreads(__tstate);
12717 if (PyErr_Occurred()) SWIG_fail;
12718 }
12719 {
12720 resultobj = SWIG_From_int((int)(result));
12721 }
12722 return resultobj;
12723 fail:
12724 return NULL;
12725 }
12726
12727
12728 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12729 PyObject *resultobj;
12730 wxJoystick *arg1 = (wxJoystick *) 0 ;
12731 bool result;
12732 PyObject * obj0 = 0 ;
12733 char *kwnames[] = {
12734 (char *) "self", NULL
12735 };
12736
12737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12739 if (SWIG_arg_fail(1)) SWIG_fail;
12740 {
12741 PyThreadState* __tstate = wxPyBeginAllowThreads();
12742 result = (bool)(arg1)->HasRudder();
12743
12744 wxPyEndAllowThreads(__tstate);
12745 if (PyErr_Occurred()) SWIG_fail;
12746 }
12747 {
12748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12749 }
12750 return resultobj;
12751 fail:
12752 return NULL;
12753 }
12754
12755
12756 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12757 PyObject *resultobj;
12758 wxJoystick *arg1 = (wxJoystick *) 0 ;
12759 bool result;
12760 PyObject * obj0 = 0 ;
12761 char *kwnames[] = {
12762 (char *) "self", NULL
12763 };
12764
12765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12767 if (SWIG_arg_fail(1)) SWIG_fail;
12768 {
12769 PyThreadState* __tstate = wxPyBeginAllowThreads();
12770 result = (bool)(arg1)->HasZ();
12771
12772 wxPyEndAllowThreads(__tstate);
12773 if (PyErr_Occurred()) SWIG_fail;
12774 }
12775 {
12776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12777 }
12778 return resultobj;
12779 fail:
12780 return NULL;
12781 }
12782
12783
12784 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12785 PyObject *resultobj;
12786 wxJoystick *arg1 = (wxJoystick *) 0 ;
12787 bool result;
12788 PyObject * obj0 = 0 ;
12789 char *kwnames[] = {
12790 (char *) "self", NULL
12791 };
12792
12793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12795 if (SWIG_arg_fail(1)) SWIG_fail;
12796 {
12797 PyThreadState* __tstate = wxPyBeginAllowThreads();
12798 result = (bool)(arg1)->HasU();
12799
12800 wxPyEndAllowThreads(__tstate);
12801 if (PyErr_Occurred()) SWIG_fail;
12802 }
12803 {
12804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12805 }
12806 return resultobj;
12807 fail:
12808 return NULL;
12809 }
12810
12811
12812 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12813 PyObject *resultobj;
12814 wxJoystick *arg1 = (wxJoystick *) 0 ;
12815 bool result;
12816 PyObject * obj0 = 0 ;
12817 char *kwnames[] = {
12818 (char *) "self", NULL
12819 };
12820
12821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12823 if (SWIG_arg_fail(1)) SWIG_fail;
12824 {
12825 PyThreadState* __tstate = wxPyBeginAllowThreads();
12826 result = (bool)(arg1)->HasV();
12827
12828 wxPyEndAllowThreads(__tstate);
12829 if (PyErr_Occurred()) SWIG_fail;
12830 }
12831 {
12832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12833 }
12834 return resultobj;
12835 fail:
12836 return NULL;
12837 }
12838
12839
12840 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12841 PyObject *resultobj;
12842 wxJoystick *arg1 = (wxJoystick *) 0 ;
12843 bool result;
12844 PyObject * obj0 = 0 ;
12845 char *kwnames[] = {
12846 (char *) "self", NULL
12847 };
12848
12849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12851 if (SWIG_arg_fail(1)) SWIG_fail;
12852 {
12853 PyThreadState* __tstate = wxPyBeginAllowThreads();
12854 result = (bool)(arg1)->HasPOV();
12855
12856 wxPyEndAllowThreads(__tstate);
12857 if (PyErr_Occurred()) SWIG_fail;
12858 }
12859 {
12860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12861 }
12862 return resultobj;
12863 fail:
12864 return NULL;
12865 }
12866
12867
12868 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12869 PyObject *resultobj;
12870 wxJoystick *arg1 = (wxJoystick *) 0 ;
12871 bool result;
12872 PyObject * obj0 = 0 ;
12873 char *kwnames[] = {
12874 (char *) "self", NULL
12875 };
12876
12877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12879 if (SWIG_arg_fail(1)) SWIG_fail;
12880 {
12881 PyThreadState* __tstate = wxPyBeginAllowThreads();
12882 result = (bool)(arg1)->HasPOV4Dir();
12883
12884 wxPyEndAllowThreads(__tstate);
12885 if (PyErr_Occurred()) SWIG_fail;
12886 }
12887 {
12888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12889 }
12890 return resultobj;
12891 fail:
12892 return NULL;
12893 }
12894
12895
12896 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12897 PyObject *resultobj;
12898 wxJoystick *arg1 = (wxJoystick *) 0 ;
12899 bool result;
12900 PyObject * obj0 = 0 ;
12901 char *kwnames[] = {
12902 (char *) "self", NULL
12903 };
12904
12905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12907 if (SWIG_arg_fail(1)) SWIG_fail;
12908 {
12909 PyThreadState* __tstate = wxPyBeginAllowThreads();
12910 result = (bool)(arg1)->HasPOVCTS();
12911
12912 wxPyEndAllowThreads(__tstate);
12913 if (PyErr_Occurred()) SWIG_fail;
12914 }
12915 {
12916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12917 }
12918 return resultobj;
12919 fail:
12920 return NULL;
12921 }
12922
12923
12924 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12925 PyObject *resultobj;
12926 wxJoystick *arg1 = (wxJoystick *) 0 ;
12927 wxWindow *arg2 = (wxWindow *) 0 ;
12928 int arg3 = (int) 0 ;
12929 bool result;
12930 PyObject * obj0 = 0 ;
12931 PyObject * obj1 = 0 ;
12932 PyObject * obj2 = 0 ;
12933 char *kwnames[] = {
12934 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12935 };
12936
12937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12939 if (SWIG_arg_fail(1)) SWIG_fail;
12940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12941 if (SWIG_arg_fail(2)) SWIG_fail;
12942 if (obj2) {
12943 {
12944 arg3 = (int)(SWIG_As_int(obj2));
12945 if (SWIG_arg_fail(3)) SWIG_fail;
12946 }
12947 }
12948 {
12949 PyThreadState* __tstate = wxPyBeginAllowThreads();
12950 result = (bool)(arg1)->SetCapture(arg2,arg3);
12951
12952 wxPyEndAllowThreads(__tstate);
12953 if (PyErr_Occurred()) SWIG_fail;
12954 }
12955 {
12956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12957 }
12958 return resultobj;
12959 fail:
12960 return NULL;
12961 }
12962
12963
12964 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12965 PyObject *resultobj;
12966 wxJoystick *arg1 = (wxJoystick *) 0 ;
12967 bool result;
12968 PyObject * obj0 = 0 ;
12969 char *kwnames[] = {
12970 (char *) "self", NULL
12971 };
12972
12973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12975 if (SWIG_arg_fail(1)) SWIG_fail;
12976 {
12977 PyThreadState* __tstate = wxPyBeginAllowThreads();
12978 result = (bool)(arg1)->ReleaseCapture();
12979
12980 wxPyEndAllowThreads(__tstate);
12981 if (PyErr_Occurred()) SWIG_fail;
12982 }
12983 {
12984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12985 }
12986 return resultobj;
12987 fail:
12988 return NULL;
12989 }
12990
12991
12992 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12993 PyObject *obj;
12994 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12995 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12996 Py_INCREF(obj);
12997 return Py_BuildValue((char *)"");
12998 }
12999 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
13000 PyObject *resultobj;
13001 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
13002 int arg2 = (int) 0 ;
13003 int arg3 = (int) wxJOYSTICK1 ;
13004 int arg4 = (int) 0 ;
13005 wxJoystickEvent *result;
13006 PyObject * obj0 = 0 ;
13007 PyObject * obj1 = 0 ;
13008 PyObject * obj2 = 0 ;
13009 PyObject * obj3 = 0 ;
13010 char *kwnames[] = {
13011 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
13012 };
13013
13014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13015 if (obj0) {
13016 {
13017 arg1 = (wxEventType)(SWIG_As_int(obj0));
13018 if (SWIG_arg_fail(1)) SWIG_fail;
13019 }
13020 }
13021 if (obj1) {
13022 {
13023 arg2 = (int)(SWIG_As_int(obj1));
13024 if (SWIG_arg_fail(2)) SWIG_fail;
13025 }
13026 }
13027 if (obj2) {
13028 {
13029 arg3 = (int)(SWIG_As_int(obj2));
13030 if (SWIG_arg_fail(3)) SWIG_fail;
13031 }
13032 }
13033 if (obj3) {
13034 {
13035 arg4 = (int)(SWIG_As_int(obj3));
13036 if (SWIG_arg_fail(4)) SWIG_fail;
13037 }
13038 }
13039 {
13040 PyThreadState* __tstate = wxPyBeginAllowThreads();
13041 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
13042
13043 wxPyEndAllowThreads(__tstate);
13044 if (PyErr_Occurred()) SWIG_fail;
13045 }
13046 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
13047 return resultobj;
13048 fail:
13049 return NULL;
13050 }
13051
13052
13053 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13054 PyObject *resultobj;
13055 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13056 wxPoint result;
13057 PyObject * obj0 = 0 ;
13058 char *kwnames[] = {
13059 (char *) "self", NULL
13060 };
13061
13062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
13063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13064 if (SWIG_arg_fail(1)) SWIG_fail;
13065 {
13066 PyThreadState* __tstate = wxPyBeginAllowThreads();
13067 result = ((wxJoystickEvent const *)arg1)->GetPosition();
13068
13069 wxPyEndAllowThreads(__tstate);
13070 if (PyErr_Occurred()) SWIG_fail;
13071 }
13072 {
13073 wxPoint * resultptr;
13074 resultptr = new wxPoint((wxPoint &)(result));
13075 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
13076 }
13077 return resultobj;
13078 fail:
13079 return NULL;
13080 }
13081
13082
13083 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13084 PyObject *resultobj;
13085 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13086 int result;
13087 PyObject * obj0 = 0 ;
13088 char *kwnames[] = {
13089 (char *) "self", NULL
13090 };
13091
13092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
13093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13094 if (SWIG_arg_fail(1)) SWIG_fail;
13095 {
13096 PyThreadState* __tstate = wxPyBeginAllowThreads();
13097 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
13098
13099 wxPyEndAllowThreads(__tstate);
13100 if (PyErr_Occurred()) SWIG_fail;
13101 }
13102 {
13103 resultobj = SWIG_From_int((int)(result));
13104 }
13105 return resultobj;
13106 fail:
13107 return NULL;
13108 }
13109
13110
13111 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13112 PyObject *resultobj;
13113 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13114 int result;
13115 PyObject * obj0 = 0 ;
13116 char *kwnames[] = {
13117 (char *) "self", NULL
13118 };
13119
13120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
13121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13122 if (SWIG_arg_fail(1)) SWIG_fail;
13123 {
13124 PyThreadState* __tstate = wxPyBeginAllowThreads();
13125 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13126
13127 wxPyEndAllowThreads(__tstate);
13128 if (PyErr_Occurred()) SWIG_fail;
13129 }
13130 {
13131 resultobj = SWIG_From_int((int)(result));
13132 }
13133 return resultobj;
13134 fail:
13135 return NULL;
13136 }
13137
13138
13139 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13140 PyObject *resultobj;
13141 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13142 int result;
13143 PyObject * obj0 = 0 ;
13144 char *kwnames[] = {
13145 (char *) "self", NULL
13146 };
13147
13148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13150 if (SWIG_arg_fail(1)) SWIG_fail;
13151 {
13152 PyThreadState* __tstate = wxPyBeginAllowThreads();
13153 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13154
13155 wxPyEndAllowThreads(__tstate);
13156 if (PyErr_Occurred()) SWIG_fail;
13157 }
13158 {
13159 resultobj = SWIG_From_int((int)(result));
13160 }
13161 return resultobj;
13162 fail:
13163 return NULL;
13164 }
13165
13166
13167 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13168 PyObject *resultobj;
13169 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13170 int result;
13171 PyObject * obj0 = 0 ;
13172 char *kwnames[] = {
13173 (char *) "self", NULL
13174 };
13175
13176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13178 if (SWIG_arg_fail(1)) SWIG_fail;
13179 {
13180 PyThreadState* __tstate = wxPyBeginAllowThreads();
13181 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13182
13183 wxPyEndAllowThreads(__tstate);
13184 if (PyErr_Occurred()) SWIG_fail;
13185 }
13186 {
13187 resultobj = SWIG_From_int((int)(result));
13188 }
13189 return resultobj;
13190 fail:
13191 return NULL;
13192 }
13193
13194
13195 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13196 PyObject *resultobj;
13197 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13198 int arg2 ;
13199 PyObject * obj0 = 0 ;
13200 PyObject * obj1 = 0 ;
13201 char *kwnames[] = {
13202 (char *) "self",(char *) "stick", NULL
13203 };
13204
13205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13207 if (SWIG_arg_fail(1)) SWIG_fail;
13208 {
13209 arg2 = (int)(SWIG_As_int(obj1));
13210 if (SWIG_arg_fail(2)) SWIG_fail;
13211 }
13212 {
13213 PyThreadState* __tstate = wxPyBeginAllowThreads();
13214 (arg1)->SetJoystick(arg2);
13215
13216 wxPyEndAllowThreads(__tstate);
13217 if (PyErr_Occurred()) SWIG_fail;
13218 }
13219 Py_INCREF(Py_None); resultobj = Py_None;
13220 return resultobj;
13221 fail:
13222 return NULL;
13223 }
13224
13225
13226 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13227 PyObject *resultobj;
13228 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13229 int arg2 ;
13230 PyObject * obj0 = 0 ;
13231 PyObject * obj1 = 0 ;
13232 char *kwnames[] = {
13233 (char *) "self",(char *) "state", NULL
13234 };
13235
13236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13238 if (SWIG_arg_fail(1)) SWIG_fail;
13239 {
13240 arg2 = (int)(SWIG_As_int(obj1));
13241 if (SWIG_arg_fail(2)) SWIG_fail;
13242 }
13243 {
13244 PyThreadState* __tstate = wxPyBeginAllowThreads();
13245 (arg1)->SetButtonState(arg2);
13246
13247 wxPyEndAllowThreads(__tstate);
13248 if (PyErr_Occurred()) SWIG_fail;
13249 }
13250 Py_INCREF(Py_None); resultobj = Py_None;
13251 return resultobj;
13252 fail:
13253 return NULL;
13254 }
13255
13256
13257 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13258 PyObject *resultobj;
13259 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13260 int arg2 ;
13261 PyObject * obj0 = 0 ;
13262 PyObject * obj1 = 0 ;
13263 char *kwnames[] = {
13264 (char *) "self",(char *) "change", NULL
13265 };
13266
13267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13269 if (SWIG_arg_fail(1)) SWIG_fail;
13270 {
13271 arg2 = (int)(SWIG_As_int(obj1));
13272 if (SWIG_arg_fail(2)) SWIG_fail;
13273 }
13274 {
13275 PyThreadState* __tstate = wxPyBeginAllowThreads();
13276 (arg1)->SetButtonChange(arg2);
13277
13278 wxPyEndAllowThreads(__tstate);
13279 if (PyErr_Occurred()) SWIG_fail;
13280 }
13281 Py_INCREF(Py_None); resultobj = Py_None;
13282 return resultobj;
13283 fail:
13284 return NULL;
13285 }
13286
13287
13288 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13289 PyObject *resultobj;
13290 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13291 wxPoint *arg2 = 0 ;
13292 wxPoint temp2 ;
13293 PyObject * obj0 = 0 ;
13294 PyObject * obj1 = 0 ;
13295 char *kwnames[] = {
13296 (char *) "self",(char *) "pos", NULL
13297 };
13298
13299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13301 if (SWIG_arg_fail(1)) SWIG_fail;
13302 {
13303 arg2 = &temp2;
13304 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13305 }
13306 {
13307 PyThreadState* __tstate = wxPyBeginAllowThreads();
13308 (arg1)->SetPosition((wxPoint const &)*arg2);
13309
13310 wxPyEndAllowThreads(__tstate);
13311 if (PyErr_Occurred()) SWIG_fail;
13312 }
13313 Py_INCREF(Py_None); resultobj = Py_None;
13314 return resultobj;
13315 fail:
13316 return NULL;
13317 }
13318
13319
13320 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13321 PyObject *resultobj;
13322 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13323 int arg2 ;
13324 PyObject * obj0 = 0 ;
13325 PyObject * obj1 = 0 ;
13326 char *kwnames[] = {
13327 (char *) "self",(char *) "zPos", NULL
13328 };
13329
13330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13332 if (SWIG_arg_fail(1)) SWIG_fail;
13333 {
13334 arg2 = (int)(SWIG_As_int(obj1));
13335 if (SWIG_arg_fail(2)) SWIG_fail;
13336 }
13337 {
13338 PyThreadState* __tstate = wxPyBeginAllowThreads();
13339 (arg1)->SetZPosition(arg2);
13340
13341 wxPyEndAllowThreads(__tstate);
13342 if (PyErr_Occurred()) SWIG_fail;
13343 }
13344 Py_INCREF(Py_None); resultobj = Py_None;
13345 return resultobj;
13346 fail:
13347 return NULL;
13348 }
13349
13350
13351 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13352 PyObject *resultobj;
13353 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13354 bool result;
13355 PyObject * obj0 = 0 ;
13356 char *kwnames[] = {
13357 (char *) "self", NULL
13358 };
13359
13360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13362 if (SWIG_arg_fail(1)) SWIG_fail;
13363 {
13364 PyThreadState* __tstate = wxPyBeginAllowThreads();
13365 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13366
13367 wxPyEndAllowThreads(__tstate);
13368 if (PyErr_Occurred()) SWIG_fail;
13369 }
13370 {
13371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13372 }
13373 return resultobj;
13374 fail:
13375 return NULL;
13376 }
13377
13378
13379 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13380 PyObject *resultobj;
13381 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13382 bool result;
13383 PyObject * obj0 = 0 ;
13384 char *kwnames[] = {
13385 (char *) "self", NULL
13386 };
13387
13388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13390 if (SWIG_arg_fail(1)) SWIG_fail;
13391 {
13392 PyThreadState* __tstate = wxPyBeginAllowThreads();
13393 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13394
13395 wxPyEndAllowThreads(__tstate);
13396 if (PyErr_Occurred()) SWIG_fail;
13397 }
13398 {
13399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13400 }
13401 return resultobj;
13402 fail:
13403 return NULL;
13404 }
13405
13406
13407 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13408 PyObject *resultobj;
13409 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13410 bool result;
13411 PyObject * obj0 = 0 ;
13412 char *kwnames[] = {
13413 (char *) "self", NULL
13414 };
13415
13416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13418 if (SWIG_arg_fail(1)) SWIG_fail;
13419 {
13420 PyThreadState* __tstate = wxPyBeginAllowThreads();
13421 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13422
13423 wxPyEndAllowThreads(__tstate);
13424 if (PyErr_Occurred()) SWIG_fail;
13425 }
13426 {
13427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13428 }
13429 return resultobj;
13430 fail:
13431 return NULL;
13432 }
13433
13434
13435 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13436 PyObject *resultobj;
13437 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13438 int arg2 = (int) wxJOY_BUTTON_ANY ;
13439 bool result;
13440 PyObject * obj0 = 0 ;
13441 PyObject * obj1 = 0 ;
13442 char *kwnames[] = {
13443 (char *) "self",(char *) "but", NULL
13444 };
13445
13446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13448 if (SWIG_arg_fail(1)) SWIG_fail;
13449 if (obj1) {
13450 {
13451 arg2 = (int)(SWIG_As_int(obj1));
13452 if (SWIG_arg_fail(2)) SWIG_fail;
13453 }
13454 }
13455 {
13456 PyThreadState* __tstate = wxPyBeginAllowThreads();
13457 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13458
13459 wxPyEndAllowThreads(__tstate);
13460 if (PyErr_Occurred()) SWIG_fail;
13461 }
13462 {
13463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13464 }
13465 return resultobj;
13466 fail:
13467 return NULL;
13468 }
13469
13470
13471 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13472 PyObject *resultobj;
13473 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13474 int arg2 = (int) wxJOY_BUTTON_ANY ;
13475 bool result;
13476 PyObject * obj0 = 0 ;
13477 PyObject * obj1 = 0 ;
13478 char *kwnames[] = {
13479 (char *) "self",(char *) "but", NULL
13480 };
13481
13482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13484 if (SWIG_arg_fail(1)) SWIG_fail;
13485 if (obj1) {
13486 {
13487 arg2 = (int)(SWIG_As_int(obj1));
13488 if (SWIG_arg_fail(2)) SWIG_fail;
13489 }
13490 }
13491 {
13492 PyThreadState* __tstate = wxPyBeginAllowThreads();
13493 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13494
13495 wxPyEndAllowThreads(__tstate);
13496 if (PyErr_Occurred()) SWIG_fail;
13497 }
13498 {
13499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13500 }
13501 return resultobj;
13502 fail:
13503 return NULL;
13504 }
13505
13506
13507 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13508 PyObject *resultobj;
13509 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13510 int arg2 = (int) wxJOY_BUTTON_ANY ;
13511 bool result;
13512 PyObject * obj0 = 0 ;
13513 PyObject * obj1 = 0 ;
13514 char *kwnames[] = {
13515 (char *) "self",(char *) "but", NULL
13516 };
13517
13518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13520 if (SWIG_arg_fail(1)) SWIG_fail;
13521 if (obj1) {
13522 {
13523 arg2 = (int)(SWIG_As_int(obj1));
13524 if (SWIG_arg_fail(2)) SWIG_fail;
13525 }
13526 }
13527 {
13528 PyThreadState* __tstate = wxPyBeginAllowThreads();
13529 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13530
13531 wxPyEndAllowThreads(__tstate);
13532 if (PyErr_Occurred()) SWIG_fail;
13533 }
13534 {
13535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13536 }
13537 return resultobj;
13538 fail:
13539 return NULL;
13540 }
13541
13542
13543 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13544 PyObject *obj;
13545 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13546 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13547 Py_INCREF(obj);
13548 return Py_BuildValue((char *)"");
13549 }
13550 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13551 PyObject *resultobj;
13552 wxString const &arg1_defvalue = wxPyEmptyString ;
13553 wxString *arg1 = (wxString *) &arg1_defvalue ;
13554 wxSound *result;
13555 bool temp1 = false ;
13556 PyObject * obj0 = 0 ;
13557 char *kwnames[] = {
13558 (char *) "fileName", NULL
13559 };
13560
13561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13562 if (obj0) {
13563 {
13564 arg1 = wxString_in_helper(obj0);
13565 if (arg1 == NULL) SWIG_fail;
13566 temp1 = true;
13567 }
13568 }
13569 {
13570 if (!wxPyCheckForApp()) SWIG_fail;
13571 PyThreadState* __tstate = wxPyBeginAllowThreads();
13572 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13573
13574 wxPyEndAllowThreads(__tstate);
13575 if (PyErr_Occurred()) SWIG_fail;
13576 }
13577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13578 {
13579 if (temp1)
13580 delete arg1;
13581 }
13582 return resultobj;
13583 fail:
13584 {
13585 if (temp1)
13586 delete arg1;
13587 }
13588 return NULL;
13589 }
13590
13591
13592 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13593 PyObject *resultobj;
13594 PyObject *arg1 = (PyObject *) 0 ;
13595 wxSound *result;
13596 PyObject * obj0 = 0 ;
13597 char *kwnames[] = {
13598 (char *) "data", NULL
13599 };
13600
13601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13602 arg1 = obj0;
13603 {
13604 if (!wxPyCheckForApp()) SWIG_fail;
13605 PyThreadState* __tstate = wxPyBeginAllowThreads();
13606 result = (wxSound *)new_wxSound(arg1);
13607
13608 wxPyEndAllowThreads(__tstate);
13609 if (PyErr_Occurred()) SWIG_fail;
13610 }
13611 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13612 return resultobj;
13613 fail:
13614 return NULL;
13615 }
13616
13617
13618 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13619 PyObject *resultobj;
13620 wxSound *arg1 = (wxSound *) 0 ;
13621 PyObject * obj0 = 0 ;
13622 char *kwnames[] = {
13623 (char *) "self", NULL
13624 };
13625
13626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13628 if (SWIG_arg_fail(1)) SWIG_fail;
13629 {
13630 PyThreadState* __tstate = wxPyBeginAllowThreads();
13631 delete arg1;
13632
13633 wxPyEndAllowThreads(__tstate);
13634 if (PyErr_Occurred()) SWIG_fail;
13635 }
13636 Py_INCREF(Py_None); resultobj = Py_None;
13637 return resultobj;
13638 fail:
13639 return NULL;
13640 }
13641
13642
13643 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13644 PyObject *resultobj;
13645 wxSound *arg1 = (wxSound *) 0 ;
13646 wxString *arg2 = 0 ;
13647 bool result;
13648 bool temp2 = false ;
13649 PyObject * obj0 = 0 ;
13650 PyObject * obj1 = 0 ;
13651 char *kwnames[] = {
13652 (char *) "self",(char *) "fileName", NULL
13653 };
13654
13655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13657 if (SWIG_arg_fail(1)) SWIG_fail;
13658 {
13659 arg2 = wxString_in_helper(obj1);
13660 if (arg2 == NULL) SWIG_fail;
13661 temp2 = true;
13662 }
13663 {
13664 PyThreadState* __tstate = wxPyBeginAllowThreads();
13665 result = (bool)(arg1)->Create((wxString const &)*arg2);
13666
13667 wxPyEndAllowThreads(__tstate);
13668 if (PyErr_Occurred()) SWIG_fail;
13669 }
13670 {
13671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13672 }
13673 {
13674 if (temp2)
13675 delete arg2;
13676 }
13677 return resultobj;
13678 fail:
13679 {
13680 if (temp2)
13681 delete arg2;
13682 }
13683 return NULL;
13684 }
13685
13686
13687 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13688 PyObject *resultobj;
13689 wxSound *arg1 = (wxSound *) 0 ;
13690 PyObject *arg2 = (PyObject *) 0 ;
13691 bool result;
13692 PyObject * obj0 = 0 ;
13693 PyObject * obj1 = 0 ;
13694 char *kwnames[] = {
13695 (char *) "self",(char *) "data", NULL
13696 };
13697
13698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13700 if (SWIG_arg_fail(1)) SWIG_fail;
13701 arg2 = obj1;
13702 {
13703 PyThreadState* __tstate = wxPyBeginAllowThreads();
13704 result = (bool)wxSound_CreateFromData(arg1,arg2);
13705
13706 wxPyEndAllowThreads(__tstate);
13707 if (PyErr_Occurred()) SWIG_fail;
13708 }
13709 {
13710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13711 }
13712 return resultobj;
13713 fail:
13714 return NULL;
13715 }
13716
13717
13718 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13719 PyObject *resultobj;
13720 wxSound *arg1 = (wxSound *) 0 ;
13721 bool result;
13722 PyObject * obj0 = 0 ;
13723 char *kwnames[] = {
13724 (char *) "self", NULL
13725 };
13726
13727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13729 if (SWIG_arg_fail(1)) SWIG_fail;
13730 {
13731 PyThreadState* __tstate = wxPyBeginAllowThreads();
13732 result = (bool)(arg1)->IsOk();
13733
13734 wxPyEndAllowThreads(__tstate);
13735 if (PyErr_Occurred()) SWIG_fail;
13736 }
13737 {
13738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13739 }
13740 return resultobj;
13741 fail:
13742 return NULL;
13743 }
13744
13745
13746 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13747 PyObject *resultobj;
13748 wxSound *arg1 = (wxSound *) 0 ;
13749 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13750 bool result;
13751 PyObject * obj0 = 0 ;
13752 PyObject * obj1 = 0 ;
13753 char *kwnames[] = {
13754 (char *) "self",(char *) "flags", NULL
13755 };
13756
13757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13759 if (SWIG_arg_fail(1)) SWIG_fail;
13760 if (obj1) {
13761 {
13762 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13763 if (SWIG_arg_fail(2)) SWIG_fail;
13764 }
13765 }
13766 {
13767 if (!wxPyCheckForApp()) SWIG_fail;
13768 PyThreadState* __tstate = wxPyBeginAllowThreads();
13769 result = (bool)((wxSound const *)arg1)->Play(arg2);
13770
13771 wxPyEndAllowThreads(__tstate);
13772 if (PyErr_Occurred()) SWIG_fail;
13773 }
13774 {
13775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13776 }
13777 return resultobj;
13778 fail:
13779 return NULL;
13780 }
13781
13782
13783 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13784 PyObject *resultobj;
13785 wxString *arg1 = 0 ;
13786 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13787 bool result;
13788 bool temp1 = false ;
13789 PyObject * obj0 = 0 ;
13790 PyObject * obj1 = 0 ;
13791 char *kwnames[] = {
13792 (char *) "filename",(char *) "flags", NULL
13793 };
13794
13795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13796 {
13797 arg1 = wxString_in_helper(obj0);
13798 if (arg1 == NULL) SWIG_fail;
13799 temp1 = true;
13800 }
13801 if (obj1) {
13802 {
13803 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13804 if (SWIG_arg_fail(2)) SWIG_fail;
13805 }
13806 }
13807 {
13808 if (!wxPyCheckForApp()) SWIG_fail;
13809 PyThreadState* __tstate = wxPyBeginAllowThreads();
13810 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13811
13812 wxPyEndAllowThreads(__tstate);
13813 if (PyErr_Occurred()) SWIG_fail;
13814 }
13815 {
13816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13817 }
13818 {
13819 if (temp1)
13820 delete arg1;
13821 }
13822 return resultobj;
13823 fail:
13824 {
13825 if (temp1)
13826 delete arg1;
13827 }
13828 return NULL;
13829 }
13830
13831
13832 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13833 PyObject *resultobj;
13834 char *kwnames[] = {
13835 NULL
13836 };
13837
13838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13839 {
13840 if (!wxPyCheckForApp()) SWIG_fail;
13841 PyThreadState* __tstate = wxPyBeginAllowThreads();
13842 wxSound::Stop();
13843
13844 wxPyEndAllowThreads(__tstate);
13845 if (PyErr_Occurred()) SWIG_fail;
13846 }
13847 Py_INCREF(Py_None); resultobj = Py_None;
13848 return resultobj;
13849 fail:
13850 return NULL;
13851 }
13852
13853
13854 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13855 PyObject *obj;
13856 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13857 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13858 Py_INCREF(obj);
13859 return Py_BuildValue((char *)"");
13860 }
13861 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13862 PyObject *resultobj;
13863 wxString *arg1 = 0 ;
13864 wxString *arg2 = 0 ;
13865 wxString *arg3 = 0 ;
13866 wxString *arg4 = 0 ;
13867 wxFileTypeInfo *result;
13868 bool temp1 = false ;
13869 bool temp2 = false ;
13870 bool temp3 = false ;
13871 bool temp4 = false ;
13872 PyObject * obj0 = 0 ;
13873 PyObject * obj1 = 0 ;
13874 PyObject * obj2 = 0 ;
13875 PyObject * obj3 = 0 ;
13876 char *kwnames[] = {
13877 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13878 };
13879
13880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13881 {
13882 arg1 = wxString_in_helper(obj0);
13883 if (arg1 == NULL) SWIG_fail;
13884 temp1 = true;
13885 }
13886 {
13887 arg2 = wxString_in_helper(obj1);
13888 if (arg2 == NULL) SWIG_fail;
13889 temp2 = true;
13890 }
13891 {
13892 arg3 = wxString_in_helper(obj2);
13893 if (arg3 == NULL) SWIG_fail;
13894 temp3 = true;
13895 }
13896 {
13897 arg4 = wxString_in_helper(obj3);
13898 if (arg4 == NULL) SWIG_fail;
13899 temp4 = true;
13900 }
13901 {
13902 PyThreadState* __tstate = wxPyBeginAllowThreads();
13903 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13904
13905 wxPyEndAllowThreads(__tstate);
13906 if (PyErr_Occurred()) SWIG_fail;
13907 }
13908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13909 {
13910 if (temp1)
13911 delete arg1;
13912 }
13913 {
13914 if (temp2)
13915 delete arg2;
13916 }
13917 {
13918 if (temp3)
13919 delete arg3;
13920 }
13921 {
13922 if (temp4)
13923 delete arg4;
13924 }
13925 return resultobj;
13926 fail:
13927 {
13928 if (temp1)
13929 delete arg1;
13930 }
13931 {
13932 if (temp2)
13933 delete arg2;
13934 }
13935 {
13936 if (temp3)
13937 delete arg3;
13938 }
13939 {
13940 if (temp4)
13941 delete arg4;
13942 }
13943 return NULL;
13944 }
13945
13946
13947 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13948 PyObject *resultobj;
13949 wxArrayString *arg1 = 0 ;
13950 wxFileTypeInfo *result;
13951 bool temp1 = false ;
13952 PyObject * obj0 = 0 ;
13953 char *kwnames[] = {
13954 (char *) "sArray", NULL
13955 };
13956
13957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13958 {
13959 if (! PySequence_Check(obj0)) {
13960 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13961 SWIG_fail;
13962 }
13963 arg1 = new wxArrayString;
13964 temp1 = true;
13965 int i, len=PySequence_Length(obj0);
13966 for (i=0; i<len; i++) {
13967 PyObject* item = PySequence_GetItem(obj0, i);
13968 wxString* s = wxString_in_helper(item);
13969 if (PyErr_Occurred()) SWIG_fail;
13970 arg1->Add(*s);
13971 delete s;
13972 Py_DECREF(item);
13973 }
13974 }
13975 {
13976 PyThreadState* __tstate = wxPyBeginAllowThreads();
13977 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13978
13979 wxPyEndAllowThreads(__tstate);
13980 if (PyErr_Occurred()) SWIG_fail;
13981 }
13982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13983 {
13984 if (temp1) delete arg1;
13985 }
13986 return resultobj;
13987 fail:
13988 {
13989 if (temp1) delete arg1;
13990 }
13991 return NULL;
13992 }
13993
13994
13995 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13996 PyObject *resultobj;
13997 wxFileTypeInfo *result;
13998 char *kwnames[] = {
13999 NULL
14000 };
14001
14002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
14003 {
14004 PyThreadState* __tstate = wxPyBeginAllowThreads();
14005 result = (wxFileTypeInfo *)new wxFileTypeInfo();
14006
14007 wxPyEndAllowThreads(__tstate);
14008 if (PyErr_Occurred()) SWIG_fail;
14009 }
14010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
14011 return resultobj;
14012 fail:
14013 return NULL;
14014 }
14015
14016
14017 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
14018 PyObject *resultobj;
14019 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14020 bool result;
14021 PyObject * obj0 = 0 ;
14022 char *kwnames[] = {
14023 (char *) "self", NULL
14024 };
14025
14026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
14027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14028 if (SWIG_arg_fail(1)) SWIG_fail;
14029 {
14030 PyThreadState* __tstate = wxPyBeginAllowThreads();
14031 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
14032
14033 wxPyEndAllowThreads(__tstate);
14034 if (PyErr_Occurred()) SWIG_fail;
14035 }
14036 {
14037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14038 }
14039 return resultobj;
14040 fail:
14041 return NULL;
14042 }
14043
14044
14045 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14046 PyObject *resultobj;
14047 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14048 wxString *arg2 = 0 ;
14049 int arg3 = (int) 0 ;
14050 bool temp2 = false ;
14051 PyObject * obj0 = 0 ;
14052 PyObject * obj1 = 0 ;
14053 PyObject * obj2 = 0 ;
14054 char *kwnames[] = {
14055 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
14056 };
14057
14058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14060 if (SWIG_arg_fail(1)) SWIG_fail;
14061 {
14062 arg2 = wxString_in_helper(obj1);
14063 if (arg2 == NULL) SWIG_fail;
14064 temp2 = true;
14065 }
14066 if (obj2) {
14067 {
14068 arg3 = (int)(SWIG_As_int(obj2));
14069 if (SWIG_arg_fail(3)) SWIG_fail;
14070 }
14071 }
14072 {
14073 PyThreadState* __tstate = wxPyBeginAllowThreads();
14074 (arg1)->SetIcon((wxString const &)*arg2,arg3);
14075
14076 wxPyEndAllowThreads(__tstate);
14077 if (PyErr_Occurred()) SWIG_fail;
14078 }
14079 Py_INCREF(Py_None); resultobj = Py_None;
14080 {
14081 if (temp2)
14082 delete arg2;
14083 }
14084 return resultobj;
14085 fail:
14086 {
14087 if (temp2)
14088 delete arg2;
14089 }
14090 return NULL;
14091 }
14092
14093
14094 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14095 PyObject *resultobj;
14096 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14097 wxString *arg2 = 0 ;
14098 bool temp2 = false ;
14099 PyObject * obj0 = 0 ;
14100 PyObject * obj1 = 0 ;
14101 char *kwnames[] = {
14102 (char *) "self",(char *) "shortDesc", NULL
14103 };
14104
14105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
14106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14107 if (SWIG_arg_fail(1)) SWIG_fail;
14108 {
14109 arg2 = wxString_in_helper(obj1);
14110 if (arg2 == NULL) SWIG_fail;
14111 temp2 = true;
14112 }
14113 {
14114 PyThreadState* __tstate = wxPyBeginAllowThreads();
14115 (arg1)->SetShortDesc((wxString const &)*arg2);
14116
14117 wxPyEndAllowThreads(__tstate);
14118 if (PyErr_Occurred()) SWIG_fail;
14119 }
14120 Py_INCREF(Py_None); resultobj = Py_None;
14121 {
14122 if (temp2)
14123 delete arg2;
14124 }
14125 return resultobj;
14126 fail:
14127 {
14128 if (temp2)
14129 delete arg2;
14130 }
14131 return NULL;
14132 }
14133
14134
14135 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14136 PyObject *resultobj;
14137 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14138 wxString *result;
14139 PyObject * obj0 = 0 ;
14140 char *kwnames[] = {
14141 (char *) "self", NULL
14142 };
14143
14144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14146 if (SWIG_arg_fail(1)) SWIG_fail;
14147 {
14148 PyThreadState* __tstate = wxPyBeginAllowThreads();
14149 {
14150 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14151 result = (wxString *) &_result_ref;
14152 }
14153
14154 wxPyEndAllowThreads(__tstate);
14155 if (PyErr_Occurred()) SWIG_fail;
14156 }
14157 {
14158 #if wxUSE_UNICODE
14159 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14160 #else
14161 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14162 #endif
14163 }
14164 return resultobj;
14165 fail:
14166 return NULL;
14167 }
14168
14169
14170 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14171 PyObject *resultobj;
14172 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14173 wxString *result;
14174 PyObject * obj0 = 0 ;
14175 char *kwnames[] = {
14176 (char *) "self", NULL
14177 };
14178
14179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14181 if (SWIG_arg_fail(1)) SWIG_fail;
14182 {
14183 PyThreadState* __tstate = wxPyBeginAllowThreads();
14184 {
14185 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14186 result = (wxString *) &_result_ref;
14187 }
14188
14189 wxPyEndAllowThreads(__tstate);
14190 if (PyErr_Occurred()) SWIG_fail;
14191 }
14192 {
14193 #if wxUSE_UNICODE
14194 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14195 #else
14196 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14197 #endif
14198 }
14199 return resultobj;
14200 fail:
14201 return NULL;
14202 }
14203
14204
14205 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14206 PyObject *resultobj;
14207 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14208 wxString *result;
14209 PyObject * obj0 = 0 ;
14210 char *kwnames[] = {
14211 (char *) "self", NULL
14212 };
14213
14214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14216 if (SWIG_arg_fail(1)) SWIG_fail;
14217 {
14218 PyThreadState* __tstate = wxPyBeginAllowThreads();
14219 {
14220 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14221 result = (wxString *) &_result_ref;
14222 }
14223
14224 wxPyEndAllowThreads(__tstate);
14225 if (PyErr_Occurred()) SWIG_fail;
14226 }
14227 {
14228 #if wxUSE_UNICODE
14229 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14230 #else
14231 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14232 #endif
14233 }
14234 return resultobj;
14235 fail:
14236 return NULL;
14237 }
14238
14239
14240 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14241 PyObject *resultobj;
14242 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14243 wxString *result;
14244 PyObject * obj0 = 0 ;
14245 char *kwnames[] = {
14246 (char *) "self", NULL
14247 };
14248
14249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14251 if (SWIG_arg_fail(1)) SWIG_fail;
14252 {
14253 PyThreadState* __tstate = wxPyBeginAllowThreads();
14254 {
14255 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14256 result = (wxString *) &_result_ref;
14257 }
14258
14259 wxPyEndAllowThreads(__tstate);
14260 if (PyErr_Occurred()) SWIG_fail;
14261 }
14262 {
14263 #if wxUSE_UNICODE
14264 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14265 #else
14266 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14267 #endif
14268 }
14269 return resultobj;
14270 fail:
14271 return NULL;
14272 }
14273
14274
14275 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14276 PyObject *resultobj;
14277 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14278 wxString *result;
14279 PyObject * obj0 = 0 ;
14280 char *kwnames[] = {
14281 (char *) "self", NULL
14282 };
14283
14284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14286 if (SWIG_arg_fail(1)) SWIG_fail;
14287 {
14288 PyThreadState* __tstate = wxPyBeginAllowThreads();
14289 {
14290 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14291 result = (wxString *) &_result_ref;
14292 }
14293
14294 wxPyEndAllowThreads(__tstate);
14295 if (PyErr_Occurred()) SWIG_fail;
14296 }
14297 {
14298 #if wxUSE_UNICODE
14299 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14300 #else
14301 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14302 #endif
14303 }
14304 return resultobj;
14305 fail:
14306 return NULL;
14307 }
14308
14309
14310 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14311 PyObject *resultobj;
14312 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14313 wxArrayString *result;
14314 PyObject * obj0 = 0 ;
14315 char *kwnames[] = {
14316 (char *) "self", NULL
14317 };
14318
14319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14321 if (SWIG_arg_fail(1)) SWIG_fail;
14322 {
14323 PyThreadState* __tstate = wxPyBeginAllowThreads();
14324 {
14325 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14326 result = (wxArrayString *) &_result_ref;
14327 }
14328
14329 wxPyEndAllowThreads(__tstate);
14330 if (PyErr_Occurred()) SWIG_fail;
14331 }
14332 {
14333 resultobj = wxArrayString2PyList_helper(*result);
14334 }
14335 return resultobj;
14336 fail:
14337 return NULL;
14338 }
14339
14340
14341 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14342 PyObject *resultobj;
14343 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14344 int result;
14345 PyObject * obj0 = 0 ;
14346 char *kwnames[] = {
14347 (char *) "self", NULL
14348 };
14349
14350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14352 if (SWIG_arg_fail(1)) SWIG_fail;
14353 {
14354 PyThreadState* __tstate = wxPyBeginAllowThreads();
14355 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14356
14357 wxPyEndAllowThreads(__tstate);
14358 if (PyErr_Occurred()) SWIG_fail;
14359 }
14360 {
14361 resultobj = SWIG_From_int((int)(result));
14362 }
14363 return resultobj;
14364 fail:
14365 return NULL;
14366 }
14367
14368
14369 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14370 PyObject *resultobj;
14371 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14372 wxString *result;
14373 PyObject * obj0 = 0 ;
14374 char *kwnames[] = {
14375 (char *) "self", NULL
14376 };
14377
14378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14380 if (SWIG_arg_fail(1)) SWIG_fail;
14381 {
14382 PyThreadState* __tstate = wxPyBeginAllowThreads();
14383 {
14384 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14385 result = (wxString *) &_result_ref;
14386 }
14387
14388 wxPyEndAllowThreads(__tstate);
14389 if (PyErr_Occurred()) SWIG_fail;
14390 }
14391 {
14392 #if wxUSE_UNICODE
14393 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14394 #else
14395 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14396 #endif
14397 }
14398 return resultobj;
14399 fail:
14400 return NULL;
14401 }
14402
14403
14404 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14405 PyObject *resultobj;
14406 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14407 int result;
14408 PyObject * obj0 = 0 ;
14409 char *kwnames[] = {
14410 (char *) "self", NULL
14411 };
14412
14413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14415 if (SWIG_arg_fail(1)) SWIG_fail;
14416 {
14417 PyThreadState* __tstate = wxPyBeginAllowThreads();
14418 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14419
14420 wxPyEndAllowThreads(__tstate);
14421 if (PyErr_Occurred()) SWIG_fail;
14422 }
14423 {
14424 resultobj = SWIG_From_int((int)(result));
14425 }
14426 return resultobj;
14427 fail:
14428 return NULL;
14429 }
14430
14431
14432 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14433 PyObject *obj;
14434 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14435 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14436 Py_INCREF(obj);
14437 return Py_BuildValue((char *)"");
14438 }
14439 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14440 PyObject *resultobj;
14441 wxFileTypeInfo *arg1 = 0 ;
14442 wxFileType *result;
14443 PyObject * obj0 = 0 ;
14444 char *kwnames[] = {
14445 (char *) "ftInfo", NULL
14446 };
14447
14448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14449 {
14450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14451 if (SWIG_arg_fail(1)) SWIG_fail;
14452 if (arg1 == NULL) {
14453 SWIG_null_ref("wxFileTypeInfo");
14454 }
14455 if (SWIG_arg_fail(1)) SWIG_fail;
14456 }
14457 {
14458 PyThreadState* __tstate = wxPyBeginAllowThreads();
14459 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14460
14461 wxPyEndAllowThreads(__tstate);
14462 if (PyErr_Occurred()) SWIG_fail;
14463 }
14464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14465 return resultobj;
14466 fail:
14467 return NULL;
14468 }
14469
14470
14471 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14472 PyObject *resultobj;
14473 wxFileType *arg1 = (wxFileType *) 0 ;
14474 PyObject * obj0 = 0 ;
14475 char *kwnames[] = {
14476 (char *) "self", NULL
14477 };
14478
14479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14481 if (SWIG_arg_fail(1)) SWIG_fail;
14482 {
14483 PyThreadState* __tstate = wxPyBeginAllowThreads();
14484 delete arg1;
14485
14486 wxPyEndAllowThreads(__tstate);
14487 if (PyErr_Occurred()) SWIG_fail;
14488 }
14489 Py_INCREF(Py_None); resultobj = Py_None;
14490 return resultobj;
14491 fail:
14492 return NULL;
14493 }
14494
14495
14496 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14497 PyObject *resultobj;
14498 wxFileType *arg1 = (wxFileType *) 0 ;
14499 PyObject *result;
14500 PyObject * obj0 = 0 ;
14501 char *kwnames[] = {
14502 (char *) "self", NULL
14503 };
14504
14505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14507 if (SWIG_arg_fail(1)) SWIG_fail;
14508 {
14509 PyThreadState* __tstate = wxPyBeginAllowThreads();
14510 result = (PyObject *)wxFileType_GetMimeType(arg1);
14511
14512 wxPyEndAllowThreads(__tstate);
14513 if (PyErr_Occurred()) SWIG_fail;
14514 }
14515 resultobj = result;
14516 return resultobj;
14517 fail:
14518 return NULL;
14519 }
14520
14521
14522 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14523 PyObject *resultobj;
14524 wxFileType *arg1 = (wxFileType *) 0 ;
14525 PyObject *result;
14526 PyObject * obj0 = 0 ;
14527 char *kwnames[] = {
14528 (char *) "self", NULL
14529 };
14530
14531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14533 if (SWIG_arg_fail(1)) SWIG_fail;
14534 {
14535 PyThreadState* __tstate = wxPyBeginAllowThreads();
14536 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14537
14538 wxPyEndAllowThreads(__tstate);
14539 if (PyErr_Occurred()) SWIG_fail;
14540 }
14541 resultobj = result;
14542 return resultobj;
14543 fail:
14544 return NULL;
14545 }
14546
14547
14548 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14549 PyObject *resultobj;
14550 wxFileType *arg1 = (wxFileType *) 0 ;
14551 PyObject *result;
14552 PyObject * obj0 = 0 ;
14553 char *kwnames[] = {
14554 (char *) "self", NULL
14555 };
14556
14557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14559 if (SWIG_arg_fail(1)) SWIG_fail;
14560 {
14561 PyThreadState* __tstate = wxPyBeginAllowThreads();
14562 result = (PyObject *)wxFileType_GetExtensions(arg1);
14563
14564 wxPyEndAllowThreads(__tstate);
14565 if (PyErr_Occurred()) SWIG_fail;
14566 }
14567 resultobj = result;
14568 return resultobj;
14569 fail:
14570 return NULL;
14571 }
14572
14573
14574 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14575 PyObject *resultobj;
14576 wxFileType *arg1 = (wxFileType *) 0 ;
14577 wxIcon *result;
14578 PyObject * obj0 = 0 ;
14579 char *kwnames[] = {
14580 (char *) "self", NULL
14581 };
14582
14583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14585 if (SWIG_arg_fail(1)) SWIG_fail;
14586 {
14587 PyThreadState* __tstate = wxPyBeginAllowThreads();
14588 result = (wxIcon *)wxFileType_GetIcon(arg1);
14589
14590 wxPyEndAllowThreads(__tstate);
14591 if (PyErr_Occurred()) SWIG_fail;
14592 }
14593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14594 return resultobj;
14595 fail:
14596 return NULL;
14597 }
14598
14599
14600 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14601 PyObject *resultobj;
14602 wxFileType *arg1 = (wxFileType *) 0 ;
14603 PyObject *result;
14604 PyObject * obj0 = 0 ;
14605 char *kwnames[] = {
14606 (char *) "self", NULL
14607 };
14608
14609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14611 if (SWIG_arg_fail(1)) SWIG_fail;
14612 {
14613 PyThreadState* __tstate = wxPyBeginAllowThreads();
14614 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14615
14616 wxPyEndAllowThreads(__tstate);
14617 if (PyErr_Occurred()) SWIG_fail;
14618 }
14619 resultobj = result;
14620 return resultobj;
14621 fail:
14622 return NULL;
14623 }
14624
14625
14626 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14627 PyObject *resultobj;
14628 wxFileType *arg1 = (wxFileType *) 0 ;
14629 PyObject *result;
14630 PyObject * obj0 = 0 ;
14631 char *kwnames[] = {
14632 (char *) "self", NULL
14633 };
14634
14635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14637 if (SWIG_arg_fail(1)) SWIG_fail;
14638 {
14639 PyThreadState* __tstate = wxPyBeginAllowThreads();
14640 result = (PyObject *)wxFileType_GetDescription(arg1);
14641
14642 wxPyEndAllowThreads(__tstate);
14643 if (PyErr_Occurred()) SWIG_fail;
14644 }
14645 resultobj = result;
14646 return resultobj;
14647 fail:
14648 return NULL;
14649 }
14650
14651
14652 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14653 PyObject *resultobj;
14654 wxFileType *arg1 = (wxFileType *) 0 ;
14655 wxString *arg2 = 0 ;
14656 wxString const &arg3_defvalue = wxPyEmptyString ;
14657 wxString *arg3 = (wxString *) &arg3_defvalue ;
14658 PyObject *result;
14659 bool temp2 = false ;
14660 bool temp3 = false ;
14661 PyObject * obj0 = 0 ;
14662 PyObject * obj1 = 0 ;
14663 PyObject * obj2 = 0 ;
14664 char *kwnames[] = {
14665 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14666 };
14667
14668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14670 if (SWIG_arg_fail(1)) SWIG_fail;
14671 {
14672 arg2 = wxString_in_helper(obj1);
14673 if (arg2 == NULL) SWIG_fail;
14674 temp2 = true;
14675 }
14676 if (obj2) {
14677 {
14678 arg3 = wxString_in_helper(obj2);
14679 if (arg3 == NULL) SWIG_fail;
14680 temp3 = true;
14681 }
14682 }
14683 {
14684 PyThreadState* __tstate = wxPyBeginAllowThreads();
14685 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14686
14687 wxPyEndAllowThreads(__tstate);
14688 if (PyErr_Occurred()) SWIG_fail;
14689 }
14690 resultobj = result;
14691 {
14692 if (temp2)
14693 delete arg2;
14694 }
14695 {
14696 if (temp3)
14697 delete arg3;
14698 }
14699 return resultobj;
14700 fail:
14701 {
14702 if (temp2)
14703 delete arg2;
14704 }
14705 {
14706 if (temp3)
14707 delete arg3;
14708 }
14709 return NULL;
14710 }
14711
14712
14713 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14714 PyObject *resultobj;
14715 wxFileType *arg1 = (wxFileType *) 0 ;
14716 wxString *arg2 = 0 ;
14717 wxString const &arg3_defvalue = wxPyEmptyString ;
14718 wxString *arg3 = (wxString *) &arg3_defvalue ;
14719 PyObject *result;
14720 bool temp2 = false ;
14721 bool temp3 = false ;
14722 PyObject * obj0 = 0 ;
14723 PyObject * obj1 = 0 ;
14724 PyObject * obj2 = 0 ;
14725 char *kwnames[] = {
14726 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14727 };
14728
14729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14731 if (SWIG_arg_fail(1)) SWIG_fail;
14732 {
14733 arg2 = wxString_in_helper(obj1);
14734 if (arg2 == NULL) SWIG_fail;
14735 temp2 = true;
14736 }
14737 if (obj2) {
14738 {
14739 arg3 = wxString_in_helper(obj2);
14740 if (arg3 == NULL) SWIG_fail;
14741 temp3 = true;
14742 }
14743 }
14744 {
14745 PyThreadState* __tstate = wxPyBeginAllowThreads();
14746 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14747
14748 wxPyEndAllowThreads(__tstate);
14749 if (PyErr_Occurred()) SWIG_fail;
14750 }
14751 resultobj = result;
14752 {
14753 if (temp2)
14754 delete arg2;
14755 }
14756 {
14757 if (temp3)
14758 delete arg3;
14759 }
14760 return resultobj;
14761 fail:
14762 {
14763 if (temp2)
14764 delete arg2;
14765 }
14766 {
14767 if (temp3)
14768 delete arg3;
14769 }
14770 return NULL;
14771 }
14772
14773
14774 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14775 PyObject *resultobj;
14776 wxFileType *arg1 = (wxFileType *) 0 ;
14777 wxString *arg2 = 0 ;
14778 wxString const &arg3_defvalue = wxPyEmptyString ;
14779 wxString *arg3 = (wxString *) &arg3_defvalue ;
14780 PyObject *result;
14781 bool temp2 = false ;
14782 bool temp3 = false ;
14783 PyObject * obj0 = 0 ;
14784 PyObject * obj1 = 0 ;
14785 PyObject * obj2 = 0 ;
14786 char *kwnames[] = {
14787 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14788 };
14789
14790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14792 if (SWIG_arg_fail(1)) SWIG_fail;
14793 {
14794 arg2 = wxString_in_helper(obj1);
14795 if (arg2 == NULL) SWIG_fail;
14796 temp2 = true;
14797 }
14798 if (obj2) {
14799 {
14800 arg3 = wxString_in_helper(obj2);
14801 if (arg3 == NULL) SWIG_fail;
14802 temp3 = true;
14803 }
14804 }
14805 {
14806 PyThreadState* __tstate = wxPyBeginAllowThreads();
14807 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14808
14809 wxPyEndAllowThreads(__tstate);
14810 if (PyErr_Occurred()) SWIG_fail;
14811 }
14812 resultobj = result;
14813 {
14814 if (temp2)
14815 delete arg2;
14816 }
14817 {
14818 if (temp3)
14819 delete arg3;
14820 }
14821 return resultobj;
14822 fail:
14823 {
14824 if (temp2)
14825 delete arg2;
14826 }
14827 {
14828 if (temp3)
14829 delete arg3;
14830 }
14831 return NULL;
14832 }
14833
14834
14835 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14836 PyObject *resultobj;
14837 wxFileType *arg1 = (wxFileType *) 0 ;
14838 wxString *arg2 = 0 ;
14839 wxString *arg3 = 0 ;
14840 bool arg4 = (bool) true ;
14841 bool result;
14842 bool temp2 = false ;
14843 bool temp3 = false ;
14844 PyObject * obj0 = 0 ;
14845 PyObject * obj1 = 0 ;
14846 PyObject * obj2 = 0 ;
14847 PyObject * obj3 = 0 ;
14848 char *kwnames[] = {
14849 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14850 };
14851
14852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14854 if (SWIG_arg_fail(1)) SWIG_fail;
14855 {
14856 arg2 = wxString_in_helper(obj1);
14857 if (arg2 == NULL) SWIG_fail;
14858 temp2 = true;
14859 }
14860 {
14861 arg3 = wxString_in_helper(obj2);
14862 if (arg3 == NULL) SWIG_fail;
14863 temp3 = true;
14864 }
14865 if (obj3) {
14866 {
14867 arg4 = (bool)(SWIG_As_bool(obj3));
14868 if (SWIG_arg_fail(4)) SWIG_fail;
14869 }
14870 }
14871 {
14872 PyThreadState* __tstate = wxPyBeginAllowThreads();
14873 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14874
14875 wxPyEndAllowThreads(__tstate);
14876 if (PyErr_Occurred()) SWIG_fail;
14877 }
14878 {
14879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14880 }
14881 {
14882 if (temp2)
14883 delete arg2;
14884 }
14885 {
14886 if (temp3)
14887 delete arg3;
14888 }
14889 return resultobj;
14890 fail:
14891 {
14892 if (temp2)
14893 delete arg2;
14894 }
14895 {
14896 if (temp3)
14897 delete arg3;
14898 }
14899 return NULL;
14900 }
14901
14902
14903 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14904 PyObject *resultobj;
14905 wxFileType *arg1 = (wxFileType *) 0 ;
14906 wxString const &arg2_defvalue = wxPyEmptyString ;
14907 wxString *arg2 = (wxString *) &arg2_defvalue ;
14908 int arg3 = (int) 0 ;
14909 bool result;
14910 bool temp2 = false ;
14911 PyObject * obj0 = 0 ;
14912 PyObject * obj1 = 0 ;
14913 PyObject * obj2 = 0 ;
14914 char *kwnames[] = {
14915 (char *) "self",(char *) "cmd",(char *) "index", NULL
14916 };
14917
14918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14920 if (SWIG_arg_fail(1)) SWIG_fail;
14921 if (obj1) {
14922 {
14923 arg2 = wxString_in_helper(obj1);
14924 if (arg2 == NULL) SWIG_fail;
14925 temp2 = true;
14926 }
14927 }
14928 if (obj2) {
14929 {
14930 arg3 = (int)(SWIG_As_int(obj2));
14931 if (SWIG_arg_fail(3)) SWIG_fail;
14932 }
14933 }
14934 {
14935 PyThreadState* __tstate = wxPyBeginAllowThreads();
14936 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14937
14938 wxPyEndAllowThreads(__tstate);
14939 if (PyErr_Occurred()) SWIG_fail;
14940 }
14941 {
14942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14943 }
14944 {
14945 if (temp2)
14946 delete arg2;
14947 }
14948 return resultobj;
14949 fail:
14950 {
14951 if (temp2)
14952 delete arg2;
14953 }
14954 return NULL;
14955 }
14956
14957
14958 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14959 PyObject *resultobj;
14960 wxFileType *arg1 = (wxFileType *) 0 ;
14961 bool result;
14962 PyObject * obj0 = 0 ;
14963 char *kwnames[] = {
14964 (char *) "self", NULL
14965 };
14966
14967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14969 if (SWIG_arg_fail(1)) SWIG_fail;
14970 {
14971 PyThreadState* __tstate = wxPyBeginAllowThreads();
14972 result = (bool)(arg1)->Unassociate();
14973
14974 wxPyEndAllowThreads(__tstate);
14975 if (PyErr_Occurred()) SWIG_fail;
14976 }
14977 {
14978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14979 }
14980 return resultobj;
14981 fail:
14982 return NULL;
14983 }
14984
14985
14986 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14987 PyObject *resultobj;
14988 wxString *arg1 = 0 ;
14989 wxString *arg2 = 0 ;
14990 wxString const &arg3_defvalue = wxPyEmptyString ;
14991 wxString *arg3 = (wxString *) &arg3_defvalue ;
14992 wxString result;
14993 bool temp1 = false ;
14994 bool temp2 = false ;
14995 bool temp3 = false ;
14996 PyObject * obj0 = 0 ;
14997 PyObject * obj1 = 0 ;
14998 PyObject * obj2 = 0 ;
14999 char *kwnames[] = {
15000 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
15001 };
15002
15003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
15004 {
15005 arg1 = wxString_in_helper(obj0);
15006 if (arg1 == NULL) SWIG_fail;
15007 temp1 = true;
15008 }
15009 {
15010 arg2 = wxString_in_helper(obj1);
15011 if (arg2 == NULL) SWIG_fail;
15012 temp2 = true;
15013 }
15014 if (obj2) {
15015 {
15016 arg3 = wxString_in_helper(obj2);
15017 if (arg3 == NULL) SWIG_fail;
15018 temp3 = true;
15019 }
15020 }
15021 {
15022 PyThreadState* __tstate = wxPyBeginAllowThreads();
15023 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15024
15025 wxPyEndAllowThreads(__tstate);
15026 if (PyErr_Occurred()) SWIG_fail;
15027 }
15028 {
15029 #if wxUSE_UNICODE
15030 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15031 #else
15032 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15033 #endif
15034 }
15035 {
15036 if (temp1)
15037 delete arg1;
15038 }
15039 {
15040 if (temp2)
15041 delete arg2;
15042 }
15043 {
15044 if (temp3)
15045 delete arg3;
15046 }
15047 return resultobj;
15048 fail:
15049 {
15050 if (temp1)
15051 delete arg1;
15052 }
15053 {
15054 if (temp2)
15055 delete arg2;
15056 }
15057 {
15058 if (temp3)
15059 delete arg3;
15060 }
15061 return NULL;
15062 }
15063
15064
15065 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
15066 PyObject *obj;
15067 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15068 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
15069 Py_INCREF(obj);
15070 return Py_BuildValue((char *)"");
15071 }
15072 static int _wrap_TheMimeTypesManager_set(PyObject *) {
15073 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
15074 return 1;
15075 }
15076
15077
15078 static PyObject *_wrap_TheMimeTypesManager_get(void) {
15079 PyObject *pyobj;
15080
15081 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
15082 return pyobj;
15083 }
15084
15085
15086 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
15087 PyObject *resultobj;
15088 wxString *arg1 = 0 ;
15089 wxString *arg2 = 0 ;
15090 bool result;
15091 bool temp1 = false ;
15092 bool temp2 = false ;
15093 PyObject * obj0 = 0 ;
15094 PyObject * obj1 = 0 ;
15095 char *kwnames[] = {
15096 (char *) "mimeType",(char *) "wildcard", NULL
15097 };
15098
15099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
15100 {
15101 arg1 = wxString_in_helper(obj0);
15102 if (arg1 == NULL) SWIG_fail;
15103 temp1 = true;
15104 }
15105 {
15106 arg2 = wxString_in_helper(obj1);
15107 if (arg2 == NULL) SWIG_fail;
15108 temp2 = true;
15109 }
15110 {
15111 PyThreadState* __tstate = wxPyBeginAllowThreads();
15112 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
15113
15114 wxPyEndAllowThreads(__tstate);
15115 if (PyErr_Occurred()) SWIG_fail;
15116 }
15117 {
15118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15119 }
15120 {
15121 if (temp1)
15122 delete arg1;
15123 }
15124 {
15125 if (temp2)
15126 delete arg2;
15127 }
15128 return resultobj;
15129 fail:
15130 {
15131 if (temp1)
15132 delete arg1;
15133 }
15134 {
15135 if (temp2)
15136 delete arg2;
15137 }
15138 return NULL;
15139 }
15140
15141
15142 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15143 PyObject *resultobj;
15144 wxMimeTypesManager *result;
15145 char *kwnames[] = {
15146 NULL
15147 };
15148
15149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15150 {
15151 PyThreadState* __tstate = wxPyBeginAllowThreads();
15152 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15153
15154 wxPyEndAllowThreads(__tstate);
15155 if (PyErr_Occurred()) SWIG_fail;
15156 }
15157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15158 return resultobj;
15159 fail:
15160 return NULL;
15161 }
15162
15163
15164 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15165 PyObject *resultobj;
15166 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15167 int arg2 = (int) wxMAILCAP_ALL ;
15168 wxString const &arg3_defvalue = wxPyEmptyString ;
15169 wxString *arg3 = (wxString *) &arg3_defvalue ;
15170 bool temp3 = false ;
15171 PyObject * obj0 = 0 ;
15172 PyObject * obj1 = 0 ;
15173 PyObject * obj2 = 0 ;
15174 char *kwnames[] = {
15175 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15176 };
15177
15178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15180 if (SWIG_arg_fail(1)) SWIG_fail;
15181 if (obj1) {
15182 {
15183 arg2 = (int)(SWIG_As_int(obj1));
15184 if (SWIG_arg_fail(2)) SWIG_fail;
15185 }
15186 }
15187 if (obj2) {
15188 {
15189 arg3 = wxString_in_helper(obj2);
15190 if (arg3 == NULL) SWIG_fail;
15191 temp3 = true;
15192 }
15193 }
15194 {
15195 PyThreadState* __tstate = wxPyBeginAllowThreads();
15196 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15197
15198 wxPyEndAllowThreads(__tstate);
15199 if (PyErr_Occurred()) SWIG_fail;
15200 }
15201 Py_INCREF(Py_None); resultobj = Py_None;
15202 {
15203 if (temp3)
15204 delete arg3;
15205 }
15206 return resultobj;
15207 fail:
15208 {
15209 if (temp3)
15210 delete arg3;
15211 }
15212 return NULL;
15213 }
15214
15215
15216 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15217 PyObject *resultobj;
15218 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15219 PyObject * obj0 = 0 ;
15220 char *kwnames[] = {
15221 (char *) "self", NULL
15222 };
15223
15224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15226 if (SWIG_arg_fail(1)) SWIG_fail;
15227 {
15228 PyThreadState* __tstate = wxPyBeginAllowThreads();
15229 (arg1)->ClearData();
15230
15231 wxPyEndAllowThreads(__tstate);
15232 if (PyErr_Occurred()) SWIG_fail;
15233 }
15234 Py_INCREF(Py_None); resultobj = Py_None;
15235 return resultobj;
15236 fail:
15237 return NULL;
15238 }
15239
15240
15241 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15242 PyObject *resultobj;
15243 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15244 wxString *arg2 = 0 ;
15245 wxFileType *result;
15246 bool temp2 = false ;
15247 PyObject * obj0 = 0 ;
15248 PyObject * obj1 = 0 ;
15249 char *kwnames[] = {
15250 (char *) "self",(char *) "ext", NULL
15251 };
15252
15253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15255 if (SWIG_arg_fail(1)) SWIG_fail;
15256 {
15257 arg2 = wxString_in_helper(obj1);
15258 if (arg2 == NULL) SWIG_fail;
15259 temp2 = true;
15260 }
15261 {
15262 PyThreadState* __tstate = wxPyBeginAllowThreads();
15263 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15264
15265 wxPyEndAllowThreads(__tstate);
15266 if (PyErr_Occurred()) SWIG_fail;
15267 }
15268 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15269 {
15270 if (temp2)
15271 delete arg2;
15272 }
15273 return resultobj;
15274 fail:
15275 {
15276 if (temp2)
15277 delete arg2;
15278 }
15279 return NULL;
15280 }
15281
15282
15283 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15284 PyObject *resultobj;
15285 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15286 wxString *arg2 = 0 ;
15287 wxFileType *result;
15288 bool temp2 = false ;
15289 PyObject * obj0 = 0 ;
15290 PyObject * obj1 = 0 ;
15291 char *kwnames[] = {
15292 (char *) "self",(char *) "mimeType", NULL
15293 };
15294
15295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15297 if (SWIG_arg_fail(1)) SWIG_fail;
15298 {
15299 arg2 = wxString_in_helper(obj1);
15300 if (arg2 == NULL) SWIG_fail;
15301 temp2 = true;
15302 }
15303 {
15304 PyThreadState* __tstate = wxPyBeginAllowThreads();
15305 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15306
15307 wxPyEndAllowThreads(__tstate);
15308 if (PyErr_Occurred()) SWIG_fail;
15309 }
15310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15311 {
15312 if (temp2)
15313 delete arg2;
15314 }
15315 return resultobj;
15316 fail:
15317 {
15318 if (temp2)
15319 delete arg2;
15320 }
15321 return NULL;
15322 }
15323
15324
15325 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15326 PyObject *resultobj;
15327 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15328 wxString *arg2 = 0 ;
15329 bool arg3 = (bool) false ;
15330 bool result;
15331 bool temp2 = false ;
15332 PyObject * obj0 = 0 ;
15333 PyObject * obj1 = 0 ;
15334 PyObject * obj2 = 0 ;
15335 char *kwnames[] = {
15336 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15337 };
15338
15339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15341 if (SWIG_arg_fail(1)) SWIG_fail;
15342 {
15343 arg2 = wxString_in_helper(obj1);
15344 if (arg2 == NULL) SWIG_fail;
15345 temp2 = true;
15346 }
15347 if (obj2) {
15348 {
15349 arg3 = (bool)(SWIG_As_bool(obj2));
15350 if (SWIG_arg_fail(3)) SWIG_fail;
15351 }
15352 }
15353 {
15354 PyThreadState* __tstate = wxPyBeginAllowThreads();
15355 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15356
15357 wxPyEndAllowThreads(__tstate);
15358 if (PyErr_Occurred()) SWIG_fail;
15359 }
15360 {
15361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15362 }
15363 {
15364 if (temp2)
15365 delete arg2;
15366 }
15367 return resultobj;
15368 fail:
15369 {
15370 if (temp2)
15371 delete arg2;
15372 }
15373 return NULL;
15374 }
15375
15376
15377 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15378 PyObject *resultobj;
15379 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15380 wxString *arg2 = 0 ;
15381 bool result;
15382 bool temp2 = false ;
15383 PyObject * obj0 = 0 ;
15384 PyObject * obj1 = 0 ;
15385 char *kwnames[] = {
15386 (char *) "self",(char *) "filename", NULL
15387 };
15388
15389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15391 if (SWIG_arg_fail(1)) SWIG_fail;
15392 {
15393 arg2 = wxString_in_helper(obj1);
15394 if (arg2 == NULL) SWIG_fail;
15395 temp2 = true;
15396 }
15397 {
15398 PyThreadState* __tstate = wxPyBeginAllowThreads();
15399 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15400
15401 wxPyEndAllowThreads(__tstate);
15402 if (PyErr_Occurred()) SWIG_fail;
15403 }
15404 {
15405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15406 }
15407 {
15408 if (temp2)
15409 delete arg2;
15410 }
15411 return resultobj;
15412 fail:
15413 {
15414 if (temp2)
15415 delete arg2;
15416 }
15417 return NULL;
15418 }
15419
15420
15421 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15422 PyObject *resultobj;
15423 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15424 PyObject *result;
15425 PyObject * obj0 = 0 ;
15426 char *kwnames[] = {
15427 (char *) "self", NULL
15428 };
15429
15430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15432 if (SWIG_arg_fail(1)) SWIG_fail;
15433 {
15434 PyThreadState* __tstate = wxPyBeginAllowThreads();
15435 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15436
15437 wxPyEndAllowThreads(__tstate);
15438 if (PyErr_Occurred()) SWIG_fail;
15439 }
15440 resultobj = result;
15441 return resultobj;
15442 fail:
15443 return NULL;
15444 }
15445
15446
15447 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15448 PyObject *resultobj;
15449 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15450 wxFileTypeInfo *arg2 = 0 ;
15451 PyObject * obj0 = 0 ;
15452 PyObject * obj1 = 0 ;
15453 char *kwnames[] = {
15454 (char *) "self",(char *) "ft", NULL
15455 };
15456
15457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15459 if (SWIG_arg_fail(1)) SWIG_fail;
15460 {
15461 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15462 if (SWIG_arg_fail(2)) SWIG_fail;
15463 if (arg2 == NULL) {
15464 SWIG_null_ref("wxFileTypeInfo");
15465 }
15466 if (SWIG_arg_fail(2)) SWIG_fail;
15467 }
15468 {
15469 PyThreadState* __tstate = wxPyBeginAllowThreads();
15470 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15471
15472 wxPyEndAllowThreads(__tstate);
15473 if (PyErr_Occurred()) SWIG_fail;
15474 }
15475 Py_INCREF(Py_None); resultobj = Py_None;
15476 return resultobj;
15477 fail:
15478 return NULL;
15479 }
15480
15481
15482 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15483 PyObject *resultobj;
15484 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15485 wxFileTypeInfo *arg2 = 0 ;
15486 wxFileType *result;
15487 PyObject * obj0 = 0 ;
15488 PyObject * obj1 = 0 ;
15489 char *kwnames[] = {
15490 (char *) "self",(char *) "ftInfo", NULL
15491 };
15492
15493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15495 if (SWIG_arg_fail(1)) SWIG_fail;
15496 {
15497 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15498 if (SWIG_arg_fail(2)) SWIG_fail;
15499 if (arg2 == NULL) {
15500 SWIG_null_ref("wxFileTypeInfo");
15501 }
15502 if (SWIG_arg_fail(2)) SWIG_fail;
15503 }
15504 {
15505 PyThreadState* __tstate = wxPyBeginAllowThreads();
15506 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15507
15508 wxPyEndAllowThreads(__tstate);
15509 if (PyErr_Occurred()) SWIG_fail;
15510 }
15511 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15512 return resultobj;
15513 fail:
15514 return NULL;
15515 }
15516
15517
15518 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15519 PyObject *resultobj;
15520 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15521 wxFileType *arg2 = (wxFileType *) 0 ;
15522 bool result;
15523 PyObject * obj0 = 0 ;
15524 PyObject * obj1 = 0 ;
15525 char *kwnames[] = {
15526 (char *) "self",(char *) "ft", NULL
15527 };
15528
15529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15531 if (SWIG_arg_fail(1)) SWIG_fail;
15532 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15533 if (SWIG_arg_fail(2)) SWIG_fail;
15534 {
15535 PyThreadState* __tstate = wxPyBeginAllowThreads();
15536 result = (bool)(arg1)->Unassociate(arg2);
15537
15538 wxPyEndAllowThreads(__tstate);
15539 if (PyErr_Occurred()) SWIG_fail;
15540 }
15541 {
15542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15543 }
15544 return resultobj;
15545 fail:
15546 return NULL;
15547 }
15548
15549
15550 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15551 PyObject *resultobj;
15552 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15553 PyObject * obj0 = 0 ;
15554 char *kwnames[] = {
15555 (char *) "self", NULL
15556 };
15557
15558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15560 if (SWIG_arg_fail(1)) SWIG_fail;
15561 {
15562 PyThreadState* __tstate = wxPyBeginAllowThreads();
15563 delete arg1;
15564
15565 wxPyEndAllowThreads(__tstate);
15566 if (PyErr_Occurred()) SWIG_fail;
15567 }
15568 Py_INCREF(Py_None); resultobj = Py_None;
15569 return resultobj;
15570 fail:
15571 return NULL;
15572 }
15573
15574
15575 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15576 PyObject *obj;
15577 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15578 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15579 Py_INCREF(obj);
15580 return Py_BuildValue((char *)"");
15581 }
15582 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15583 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15584 return 1;
15585 }
15586
15587
15588 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15589 PyObject *pyobj;
15590
15591 {
15592 #if wxUSE_UNICODE
15593 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15594 #else
15595 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15596 #endif
15597 }
15598 return pyobj;
15599 }
15600
15601
15602 static int _wrap_ART_MENU_set(PyObject *) {
15603 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15604 return 1;
15605 }
15606
15607
15608 static PyObject *_wrap_ART_MENU_get(void) {
15609 PyObject *pyobj;
15610
15611 {
15612 #if wxUSE_UNICODE
15613 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15614 #else
15615 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15616 #endif
15617 }
15618 return pyobj;
15619 }
15620
15621
15622 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15623 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15624 return 1;
15625 }
15626
15627
15628 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15629 PyObject *pyobj;
15630
15631 {
15632 #if wxUSE_UNICODE
15633 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15634 #else
15635 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15636 #endif
15637 }
15638 return pyobj;
15639 }
15640
15641
15642 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15643 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15644 return 1;
15645 }
15646
15647
15648 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15649 PyObject *pyobj;
15650
15651 {
15652 #if wxUSE_UNICODE
15653 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15654 #else
15655 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15656 #endif
15657 }
15658 return pyobj;
15659 }
15660
15661
15662 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15663 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15664 return 1;
15665 }
15666
15667
15668 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15669 PyObject *pyobj;
15670
15671 {
15672 #if wxUSE_UNICODE
15673 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15674 #else
15675 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15676 #endif
15677 }
15678 return pyobj;
15679 }
15680
15681
15682 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15683 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15684 return 1;
15685 }
15686
15687
15688 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15689 PyObject *pyobj;
15690
15691 {
15692 #if wxUSE_UNICODE
15693 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15694 #else
15695 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15696 #endif
15697 }
15698 return pyobj;
15699 }
15700
15701
15702 static int _wrap_ART_BUTTON_set(PyObject *) {
15703 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15704 return 1;
15705 }
15706
15707
15708 static PyObject *_wrap_ART_BUTTON_get(void) {
15709 PyObject *pyobj;
15710
15711 {
15712 #if wxUSE_UNICODE
15713 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15714 #else
15715 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15716 #endif
15717 }
15718 return pyobj;
15719 }
15720
15721
15722 static int _wrap_ART_OTHER_set(PyObject *) {
15723 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15724 return 1;
15725 }
15726
15727
15728 static PyObject *_wrap_ART_OTHER_get(void) {
15729 PyObject *pyobj;
15730
15731 {
15732 #if wxUSE_UNICODE
15733 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15734 #else
15735 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15736 #endif
15737 }
15738 return pyobj;
15739 }
15740
15741
15742 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15743 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15744 return 1;
15745 }
15746
15747
15748 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15749 PyObject *pyobj;
15750
15751 {
15752 #if wxUSE_UNICODE
15753 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15754 #else
15755 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15756 #endif
15757 }
15758 return pyobj;
15759 }
15760
15761
15762 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15763 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15764 return 1;
15765 }
15766
15767
15768 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15769 PyObject *pyobj;
15770
15771 {
15772 #if wxUSE_UNICODE
15773 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15774 #else
15775 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15776 #endif
15777 }
15778 return pyobj;
15779 }
15780
15781
15782 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15783 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15784 return 1;
15785 }
15786
15787
15788 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15789 PyObject *pyobj;
15790
15791 {
15792 #if wxUSE_UNICODE
15793 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15794 #else
15795 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15796 #endif
15797 }
15798 return pyobj;
15799 }
15800
15801
15802 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15803 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15804 return 1;
15805 }
15806
15807
15808 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15809 PyObject *pyobj;
15810
15811 {
15812 #if wxUSE_UNICODE
15813 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15814 #else
15815 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15816 #endif
15817 }
15818 return pyobj;
15819 }
15820
15821
15822 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15823 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15824 return 1;
15825 }
15826
15827
15828 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15829 PyObject *pyobj;
15830
15831 {
15832 #if wxUSE_UNICODE
15833 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15834 #else
15835 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15836 #endif
15837 }
15838 return pyobj;
15839 }
15840
15841
15842 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15843 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15844 return 1;
15845 }
15846
15847
15848 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15849 PyObject *pyobj;
15850
15851 {
15852 #if wxUSE_UNICODE
15853 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15854 #else
15855 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15856 #endif
15857 }
15858 return pyobj;
15859 }
15860
15861
15862 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15863 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15864 return 1;
15865 }
15866
15867
15868 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15869 PyObject *pyobj;
15870
15871 {
15872 #if wxUSE_UNICODE
15873 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15874 #else
15875 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15876 #endif
15877 }
15878 return pyobj;
15879 }
15880
15881
15882 static int _wrap_ART_GO_BACK_set(PyObject *) {
15883 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15884 return 1;
15885 }
15886
15887
15888 static PyObject *_wrap_ART_GO_BACK_get(void) {
15889 PyObject *pyobj;
15890
15891 {
15892 #if wxUSE_UNICODE
15893 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15894 #else
15895 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15896 #endif
15897 }
15898 return pyobj;
15899 }
15900
15901
15902 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15903 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15904 return 1;
15905 }
15906
15907
15908 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15909 PyObject *pyobj;
15910
15911 {
15912 #if wxUSE_UNICODE
15913 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15914 #else
15915 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15916 #endif
15917 }
15918 return pyobj;
15919 }
15920
15921
15922 static int _wrap_ART_GO_UP_set(PyObject *) {
15923 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15924 return 1;
15925 }
15926
15927
15928 static PyObject *_wrap_ART_GO_UP_get(void) {
15929 PyObject *pyobj;
15930
15931 {
15932 #if wxUSE_UNICODE
15933 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15934 #else
15935 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15936 #endif
15937 }
15938 return pyobj;
15939 }
15940
15941
15942 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15943 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15944 return 1;
15945 }
15946
15947
15948 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15949 PyObject *pyobj;
15950
15951 {
15952 #if wxUSE_UNICODE
15953 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15954 #else
15955 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15956 #endif
15957 }
15958 return pyobj;
15959 }
15960
15961
15962 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15963 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15964 return 1;
15965 }
15966
15967
15968 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15969 PyObject *pyobj;
15970
15971 {
15972 #if wxUSE_UNICODE
15973 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15974 #else
15975 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15976 #endif
15977 }
15978 return pyobj;
15979 }
15980
15981
15982 static int _wrap_ART_GO_HOME_set(PyObject *) {
15983 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15984 return 1;
15985 }
15986
15987
15988 static PyObject *_wrap_ART_GO_HOME_get(void) {
15989 PyObject *pyobj;
15990
15991 {
15992 #if wxUSE_UNICODE
15993 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15994 #else
15995 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15996 #endif
15997 }
15998 return pyobj;
15999 }
16000
16001
16002 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
16003 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
16004 return 1;
16005 }
16006
16007
16008 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
16009 PyObject *pyobj;
16010
16011 {
16012 #if wxUSE_UNICODE
16013 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
16014 #else
16015 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
16016 #endif
16017 }
16018 return pyobj;
16019 }
16020
16021
16022 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
16023 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
16024 return 1;
16025 }
16026
16027
16028 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
16029 PyObject *pyobj;
16030
16031 {
16032 #if wxUSE_UNICODE
16033 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
16034 #else
16035 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
16036 #endif
16037 }
16038 return pyobj;
16039 }
16040
16041
16042 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
16043 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
16044 return 1;
16045 }
16046
16047
16048 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
16049 PyObject *pyobj;
16050
16051 {
16052 #if wxUSE_UNICODE
16053 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
16054 #else
16055 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
16056 #endif
16057 }
16058 return pyobj;
16059 }
16060
16061
16062 static int _wrap_ART_PRINT_set(PyObject *) {
16063 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
16064 return 1;
16065 }
16066
16067
16068 static PyObject *_wrap_ART_PRINT_get(void) {
16069 PyObject *pyobj;
16070
16071 {
16072 #if wxUSE_UNICODE
16073 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16074 #else
16075 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16076 #endif
16077 }
16078 return pyobj;
16079 }
16080
16081
16082 static int _wrap_ART_HELP_set(PyObject *) {
16083 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
16084 return 1;
16085 }
16086
16087
16088 static PyObject *_wrap_ART_HELP_get(void) {
16089 PyObject *pyobj;
16090
16091 {
16092 #if wxUSE_UNICODE
16093 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16094 #else
16095 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16096 #endif
16097 }
16098 return pyobj;
16099 }
16100
16101
16102 static int _wrap_ART_TIP_set(PyObject *) {
16103 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
16104 return 1;
16105 }
16106
16107
16108 static PyObject *_wrap_ART_TIP_get(void) {
16109 PyObject *pyobj;
16110
16111 {
16112 #if wxUSE_UNICODE
16113 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16114 #else
16115 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16116 #endif
16117 }
16118 return pyobj;
16119 }
16120
16121
16122 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16123 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16124 return 1;
16125 }
16126
16127
16128 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16129 PyObject *pyobj;
16130
16131 {
16132 #if wxUSE_UNICODE
16133 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16134 #else
16135 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16136 #endif
16137 }
16138 return pyobj;
16139 }
16140
16141
16142 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16143 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16144 return 1;
16145 }
16146
16147
16148 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16149 PyObject *pyobj;
16150
16151 {
16152 #if wxUSE_UNICODE
16153 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16154 #else
16155 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16156 #endif
16157 }
16158 return pyobj;
16159 }
16160
16161
16162 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16163 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16164 return 1;
16165 }
16166
16167
16168 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16169 PyObject *pyobj;
16170
16171 {
16172 #if wxUSE_UNICODE
16173 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16174 #else
16175 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16176 #endif
16177 }
16178 return pyobj;
16179 }
16180
16181
16182 static int _wrap_ART_HARDDISK_set(PyObject *) {
16183 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16184 return 1;
16185 }
16186
16187
16188 static PyObject *_wrap_ART_HARDDISK_get(void) {
16189 PyObject *pyobj;
16190
16191 {
16192 #if wxUSE_UNICODE
16193 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16194 #else
16195 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16196 #endif
16197 }
16198 return pyobj;
16199 }
16200
16201
16202 static int _wrap_ART_FLOPPY_set(PyObject *) {
16203 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16204 return 1;
16205 }
16206
16207
16208 static PyObject *_wrap_ART_FLOPPY_get(void) {
16209 PyObject *pyobj;
16210
16211 {
16212 #if wxUSE_UNICODE
16213 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16214 #else
16215 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16216 #endif
16217 }
16218 return pyobj;
16219 }
16220
16221
16222 static int _wrap_ART_CDROM_set(PyObject *) {
16223 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16224 return 1;
16225 }
16226
16227
16228 static PyObject *_wrap_ART_CDROM_get(void) {
16229 PyObject *pyobj;
16230
16231 {
16232 #if wxUSE_UNICODE
16233 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16234 #else
16235 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16236 #endif
16237 }
16238 return pyobj;
16239 }
16240
16241
16242 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16243 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16244 return 1;
16245 }
16246
16247
16248 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16249 PyObject *pyobj;
16250
16251 {
16252 #if wxUSE_UNICODE
16253 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16254 #else
16255 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16256 #endif
16257 }
16258 return pyobj;
16259 }
16260
16261
16262 static int _wrap_ART_FOLDER_set(PyObject *) {
16263 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16264 return 1;
16265 }
16266
16267
16268 static PyObject *_wrap_ART_FOLDER_get(void) {
16269 PyObject *pyobj;
16270
16271 {
16272 #if wxUSE_UNICODE
16273 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16274 #else
16275 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16276 #endif
16277 }
16278 return pyobj;
16279 }
16280
16281
16282 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16283 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16284 return 1;
16285 }
16286
16287
16288 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16289 PyObject *pyobj;
16290
16291 {
16292 #if wxUSE_UNICODE
16293 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16294 #else
16295 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16296 #endif
16297 }
16298 return pyobj;
16299 }
16300
16301
16302 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16303 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16304 return 1;
16305 }
16306
16307
16308 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16309 PyObject *pyobj;
16310
16311 {
16312 #if wxUSE_UNICODE
16313 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16314 #else
16315 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16316 #endif
16317 }
16318 return pyobj;
16319 }
16320
16321
16322 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16323 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16324 return 1;
16325 }
16326
16327
16328 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16329 PyObject *pyobj;
16330
16331 {
16332 #if wxUSE_UNICODE
16333 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16334 #else
16335 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16336 #endif
16337 }
16338 return pyobj;
16339 }
16340
16341
16342 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16343 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16344 return 1;
16345 }
16346
16347
16348 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16349 PyObject *pyobj;
16350
16351 {
16352 #if wxUSE_UNICODE
16353 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16354 #else
16355 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16356 #endif
16357 }
16358 return pyobj;
16359 }
16360
16361
16362 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16363 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16364 return 1;
16365 }
16366
16367
16368 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16369 PyObject *pyobj;
16370
16371 {
16372 #if wxUSE_UNICODE
16373 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16374 #else
16375 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16376 #endif
16377 }
16378 return pyobj;
16379 }
16380
16381
16382 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16383 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16384 return 1;
16385 }
16386
16387
16388 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16389 PyObject *pyobj;
16390
16391 {
16392 #if wxUSE_UNICODE
16393 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16394 #else
16395 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16396 #endif
16397 }
16398 return pyobj;
16399 }
16400
16401
16402 static int _wrap_ART_ERROR_set(PyObject *) {
16403 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16404 return 1;
16405 }
16406
16407
16408 static PyObject *_wrap_ART_ERROR_get(void) {
16409 PyObject *pyobj;
16410
16411 {
16412 #if wxUSE_UNICODE
16413 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16414 #else
16415 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16416 #endif
16417 }
16418 return pyobj;
16419 }
16420
16421
16422 static int _wrap_ART_QUESTION_set(PyObject *) {
16423 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16424 return 1;
16425 }
16426
16427
16428 static PyObject *_wrap_ART_QUESTION_get(void) {
16429 PyObject *pyobj;
16430
16431 {
16432 #if wxUSE_UNICODE
16433 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16434 #else
16435 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16436 #endif
16437 }
16438 return pyobj;
16439 }
16440
16441
16442 static int _wrap_ART_WARNING_set(PyObject *) {
16443 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16444 return 1;
16445 }
16446
16447
16448 static PyObject *_wrap_ART_WARNING_get(void) {
16449 PyObject *pyobj;
16450
16451 {
16452 #if wxUSE_UNICODE
16453 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16454 #else
16455 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16456 #endif
16457 }
16458 return pyobj;
16459 }
16460
16461
16462 static int _wrap_ART_INFORMATION_set(PyObject *) {
16463 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16464 return 1;
16465 }
16466
16467
16468 static PyObject *_wrap_ART_INFORMATION_get(void) {
16469 PyObject *pyobj;
16470
16471 {
16472 #if wxUSE_UNICODE
16473 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16474 #else
16475 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16476 #endif
16477 }
16478 return pyobj;
16479 }
16480
16481
16482 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16483 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16484 return 1;
16485 }
16486
16487
16488 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16489 PyObject *pyobj;
16490
16491 {
16492 #if wxUSE_UNICODE
16493 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16494 #else
16495 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16496 #endif
16497 }
16498 return pyobj;
16499 }
16500
16501
16502 static int _wrap_ART_COPY_set(PyObject *) {
16503 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16504 return 1;
16505 }
16506
16507
16508 static PyObject *_wrap_ART_COPY_get(void) {
16509 PyObject *pyobj;
16510
16511 {
16512 #if wxUSE_UNICODE
16513 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16514 #else
16515 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16516 #endif
16517 }
16518 return pyobj;
16519 }
16520
16521
16522 static int _wrap_ART_CUT_set(PyObject *) {
16523 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16524 return 1;
16525 }
16526
16527
16528 static PyObject *_wrap_ART_CUT_get(void) {
16529 PyObject *pyobj;
16530
16531 {
16532 #if wxUSE_UNICODE
16533 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16534 #else
16535 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16536 #endif
16537 }
16538 return pyobj;
16539 }
16540
16541
16542 static int _wrap_ART_PASTE_set(PyObject *) {
16543 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16544 return 1;
16545 }
16546
16547
16548 static PyObject *_wrap_ART_PASTE_get(void) {
16549 PyObject *pyobj;
16550
16551 {
16552 #if wxUSE_UNICODE
16553 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16554 #else
16555 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16556 #endif
16557 }
16558 return pyobj;
16559 }
16560
16561
16562 static int _wrap_ART_DELETE_set(PyObject *) {
16563 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16564 return 1;
16565 }
16566
16567
16568 static PyObject *_wrap_ART_DELETE_get(void) {
16569 PyObject *pyobj;
16570
16571 {
16572 #if wxUSE_UNICODE
16573 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16574 #else
16575 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16576 #endif
16577 }
16578 return pyobj;
16579 }
16580
16581
16582 static int _wrap_ART_NEW_set(PyObject *) {
16583 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW is read-only.");
16584 return 1;
16585 }
16586
16587
16588 static PyObject *_wrap_ART_NEW_get(void) {
16589 PyObject *pyobj;
16590
16591 {
16592 #if wxUSE_UNICODE
16593 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
16594 #else
16595 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
16596 #endif
16597 }
16598 return pyobj;
16599 }
16600
16601
16602 static int _wrap_ART_UNDO_set(PyObject *) {
16603 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16604 return 1;
16605 }
16606
16607
16608 static PyObject *_wrap_ART_UNDO_get(void) {
16609 PyObject *pyobj;
16610
16611 {
16612 #if wxUSE_UNICODE
16613 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16614 #else
16615 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16616 #endif
16617 }
16618 return pyobj;
16619 }
16620
16621
16622 static int _wrap_ART_REDO_set(PyObject *) {
16623 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16624 return 1;
16625 }
16626
16627
16628 static PyObject *_wrap_ART_REDO_get(void) {
16629 PyObject *pyobj;
16630
16631 {
16632 #if wxUSE_UNICODE
16633 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16634 #else
16635 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16636 #endif
16637 }
16638 return pyobj;
16639 }
16640
16641
16642 static int _wrap_ART_QUIT_set(PyObject *) {
16643 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16644 return 1;
16645 }
16646
16647
16648 static PyObject *_wrap_ART_QUIT_get(void) {
16649 PyObject *pyobj;
16650
16651 {
16652 #if wxUSE_UNICODE
16653 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16654 #else
16655 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16656 #endif
16657 }
16658 return pyobj;
16659 }
16660
16661
16662 static int _wrap_ART_FIND_set(PyObject *) {
16663 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16664 return 1;
16665 }
16666
16667
16668 static PyObject *_wrap_ART_FIND_get(void) {
16669 PyObject *pyobj;
16670
16671 {
16672 #if wxUSE_UNICODE
16673 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16674 #else
16675 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16676 #endif
16677 }
16678 return pyobj;
16679 }
16680
16681
16682 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16683 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16684 return 1;
16685 }
16686
16687
16688 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16689 PyObject *pyobj;
16690
16691 {
16692 #if wxUSE_UNICODE
16693 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16694 #else
16695 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16696 #endif
16697 }
16698 return pyobj;
16699 }
16700
16701
16702 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16703 PyObject *resultobj;
16704 wxPyArtProvider *result;
16705 char *kwnames[] = {
16706 NULL
16707 };
16708
16709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16710 {
16711 if (!wxPyCheckForApp()) SWIG_fail;
16712 PyThreadState* __tstate = wxPyBeginAllowThreads();
16713 result = (wxPyArtProvider *)new wxPyArtProvider();
16714
16715 wxPyEndAllowThreads(__tstate);
16716 if (PyErr_Occurred()) SWIG_fail;
16717 }
16718 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16719 return resultobj;
16720 fail:
16721 return NULL;
16722 }
16723
16724
16725 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16726 PyObject *resultobj;
16727 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16728 PyObject *arg2 = (PyObject *) 0 ;
16729 PyObject *arg3 = (PyObject *) 0 ;
16730 PyObject * obj0 = 0 ;
16731 PyObject * obj1 = 0 ;
16732 PyObject * obj2 = 0 ;
16733 char *kwnames[] = {
16734 (char *) "self",(char *) "self",(char *) "_class", NULL
16735 };
16736
16737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16739 if (SWIG_arg_fail(1)) SWIG_fail;
16740 arg2 = obj1;
16741 arg3 = obj2;
16742 {
16743 PyThreadState* __tstate = wxPyBeginAllowThreads();
16744 (arg1)->_setCallbackInfo(arg2,arg3);
16745
16746 wxPyEndAllowThreads(__tstate);
16747 if (PyErr_Occurred()) SWIG_fail;
16748 }
16749 Py_INCREF(Py_None); resultobj = Py_None;
16750 return resultobj;
16751 fail:
16752 return NULL;
16753 }
16754
16755
16756 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16757 PyObject *resultobj;
16758 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16759 PyObject * obj0 = 0 ;
16760 char *kwnames[] = {
16761 (char *) "provider", NULL
16762 };
16763
16764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16766 if (SWIG_arg_fail(1)) SWIG_fail;
16767 {
16768 PyThreadState* __tstate = wxPyBeginAllowThreads();
16769 wxPyArtProvider::PushProvider(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_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16782 PyObject *resultobj;
16783 bool result;
16784 char *kwnames[] = {
16785 NULL
16786 };
16787
16788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16789 {
16790 PyThreadState* __tstate = wxPyBeginAllowThreads();
16791 result = (bool)wxPyArtProvider::PopProvider();
16792
16793 wxPyEndAllowThreads(__tstate);
16794 if (PyErr_Occurred()) SWIG_fail;
16795 }
16796 {
16797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16798 }
16799 return resultobj;
16800 fail:
16801 return NULL;
16802 }
16803
16804
16805 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16806 PyObject *resultobj;
16807 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16808 bool result;
16809 PyObject * obj0 = 0 ;
16810 char *kwnames[] = {
16811 (char *) "provider", NULL
16812 };
16813
16814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16816 if (SWIG_arg_fail(1)) SWIG_fail;
16817 {
16818 PyThreadState* __tstate = wxPyBeginAllowThreads();
16819 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16820
16821 wxPyEndAllowThreads(__tstate);
16822 if (PyErr_Occurred()) SWIG_fail;
16823 }
16824 {
16825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16826 }
16827 return resultobj;
16828 fail:
16829 return NULL;
16830 }
16831
16832
16833 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16834 PyObject *resultobj;
16835 wxString *arg1 = 0 ;
16836 wxString const &arg2_defvalue = wxPyART_OTHER ;
16837 wxString *arg2 = (wxString *) &arg2_defvalue ;
16838 wxSize const &arg3_defvalue = wxDefaultSize ;
16839 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16840 wxBitmap result;
16841 bool temp1 = false ;
16842 bool temp2 = false ;
16843 wxSize temp3 ;
16844 PyObject * obj0 = 0 ;
16845 PyObject * obj1 = 0 ;
16846 PyObject * obj2 = 0 ;
16847 char *kwnames[] = {
16848 (char *) "id",(char *) "client",(char *) "size", NULL
16849 };
16850
16851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16852 {
16853 arg1 = wxString_in_helper(obj0);
16854 if (arg1 == NULL) SWIG_fail;
16855 temp1 = true;
16856 }
16857 if (obj1) {
16858 {
16859 arg2 = wxString_in_helper(obj1);
16860 if (arg2 == NULL) SWIG_fail;
16861 temp2 = true;
16862 }
16863 }
16864 if (obj2) {
16865 {
16866 arg3 = &temp3;
16867 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16868 }
16869 }
16870 {
16871 if (!wxPyCheckForApp()) SWIG_fail;
16872 PyThreadState* __tstate = wxPyBeginAllowThreads();
16873 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16874
16875 wxPyEndAllowThreads(__tstate);
16876 if (PyErr_Occurred()) SWIG_fail;
16877 }
16878 {
16879 wxBitmap * resultptr;
16880 resultptr = new wxBitmap((wxBitmap &)(result));
16881 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16882 }
16883 {
16884 if (temp1)
16885 delete arg1;
16886 }
16887 {
16888 if (temp2)
16889 delete arg2;
16890 }
16891 return resultobj;
16892 fail:
16893 {
16894 if (temp1)
16895 delete arg1;
16896 }
16897 {
16898 if (temp2)
16899 delete arg2;
16900 }
16901 return NULL;
16902 }
16903
16904
16905 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16906 PyObject *resultobj;
16907 wxString *arg1 = 0 ;
16908 wxString const &arg2_defvalue = wxPyART_OTHER ;
16909 wxString *arg2 = (wxString *) &arg2_defvalue ;
16910 wxSize const &arg3_defvalue = wxDefaultSize ;
16911 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16912 wxIcon result;
16913 bool temp1 = false ;
16914 bool temp2 = false ;
16915 wxSize temp3 ;
16916 PyObject * obj0 = 0 ;
16917 PyObject * obj1 = 0 ;
16918 PyObject * obj2 = 0 ;
16919 char *kwnames[] = {
16920 (char *) "id",(char *) "client",(char *) "size", NULL
16921 };
16922
16923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16924 {
16925 arg1 = wxString_in_helper(obj0);
16926 if (arg1 == NULL) SWIG_fail;
16927 temp1 = true;
16928 }
16929 if (obj1) {
16930 {
16931 arg2 = wxString_in_helper(obj1);
16932 if (arg2 == NULL) SWIG_fail;
16933 temp2 = true;
16934 }
16935 }
16936 if (obj2) {
16937 {
16938 arg3 = &temp3;
16939 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16940 }
16941 }
16942 {
16943 if (!wxPyCheckForApp()) SWIG_fail;
16944 PyThreadState* __tstate = wxPyBeginAllowThreads();
16945 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16946
16947 wxPyEndAllowThreads(__tstate);
16948 if (PyErr_Occurred()) SWIG_fail;
16949 }
16950 {
16951 wxIcon * resultptr;
16952 resultptr = new wxIcon((wxIcon &)(result));
16953 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16954 }
16955 {
16956 if (temp1)
16957 delete arg1;
16958 }
16959 {
16960 if (temp2)
16961 delete arg2;
16962 }
16963 return resultobj;
16964 fail:
16965 {
16966 if (temp1)
16967 delete arg1;
16968 }
16969 {
16970 if (temp2)
16971 delete arg2;
16972 }
16973 return NULL;
16974 }
16975
16976
16977 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16978 PyObject *resultobj;
16979 wxString *arg1 = 0 ;
16980 bool arg2 = (bool) false ;
16981 wxSize result;
16982 bool temp1 = false ;
16983 PyObject * obj0 = 0 ;
16984 PyObject * obj1 = 0 ;
16985 char *kwnames[] = {
16986 (char *) "client",(char *) "platform_dependent", NULL
16987 };
16988
16989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16990 {
16991 arg1 = wxString_in_helper(obj0);
16992 if (arg1 == NULL) SWIG_fail;
16993 temp1 = true;
16994 }
16995 if (obj1) {
16996 {
16997 arg2 = (bool)(SWIG_As_bool(obj1));
16998 if (SWIG_arg_fail(2)) SWIG_fail;
16999 }
17000 }
17001 {
17002 PyThreadState* __tstate = wxPyBeginAllowThreads();
17003 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
17004
17005 wxPyEndAllowThreads(__tstate);
17006 if (PyErr_Occurred()) SWIG_fail;
17007 }
17008 {
17009 wxSize * resultptr;
17010 resultptr = new wxSize((wxSize &)(result));
17011 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
17012 }
17013 {
17014 if (temp1)
17015 delete arg1;
17016 }
17017 return resultobj;
17018 fail:
17019 {
17020 if (temp1)
17021 delete arg1;
17022 }
17023 return NULL;
17024 }
17025
17026
17027 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
17028 PyObject *resultobj;
17029 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17030 PyObject * obj0 = 0 ;
17031 char *kwnames[] = {
17032 (char *) "self", NULL
17033 };
17034
17035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
17036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17037 if (SWIG_arg_fail(1)) SWIG_fail;
17038 {
17039 PyThreadState* __tstate = wxPyBeginAllowThreads();
17040 wxPyArtProvider_Destroy(arg1);
17041
17042 wxPyEndAllowThreads(__tstate);
17043 if (PyErr_Occurred()) SWIG_fail;
17044 }
17045 Py_INCREF(Py_None); resultobj = Py_None;
17046 return resultobj;
17047 fail:
17048 return NULL;
17049 }
17050
17051
17052 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
17053 PyObject *obj;
17054 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17055 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
17056 Py_INCREF(obj);
17057 return Py_BuildValue((char *)"");
17058 }
17059 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
17060 PyObject *resultobj;
17061 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17062 PyObject * obj0 = 0 ;
17063 char *kwnames[] = {
17064 (char *) "self", NULL
17065 };
17066
17067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
17068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17069 if (SWIG_arg_fail(1)) SWIG_fail;
17070 {
17071 PyThreadState* __tstate = wxPyBeginAllowThreads();
17072 delete arg1;
17073
17074 wxPyEndAllowThreads(__tstate);
17075 if (PyErr_Occurred()) SWIG_fail;
17076 }
17077 Py_INCREF(Py_None); resultobj = Py_None;
17078 return resultobj;
17079 fail:
17080 return NULL;
17081 }
17082
17083
17084 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
17085 PyObject *resultobj;
17086 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17087 wxConfigBase *result;
17088 PyObject * obj0 = 0 ;
17089 char *kwnames[] = {
17090 (char *) "config", NULL
17091 };
17092
17093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
17094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
17095 if (SWIG_arg_fail(1)) SWIG_fail;
17096 {
17097 PyThreadState* __tstate = wxPyBeginAllowThreads();
17098 result = (wxConfigBase *)wxConfigBase::Set(arg1);
17099
17100 wxPyEndAllowThreads(__tstate);
17101 if (PyErr_Occurred()) SWIG_fail;
17102 }
17103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17104 return resultobj;
17105 fail:
17106 return NULL;
17107 }
17108
17109
17110 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
17111 PyObject *resultobj;
17112 bool arg1 = (bool) true ;
17113 wxConfigBase *result;
17114 PyObject * obj0 = 0 ;
17115 char *kwnames[] = {
17116 (char *) "createOnDemand", NULL
17117 };
17118
17119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
17120 if (obj0) {
17121 {
17122 arg1 = (bool)(SWIG_As_bool(obj0));
17123 if (SWIG_arg_fail(1)) SWIG_fail;
17124 }
17125 }
17126 {
17127 PyThreadState* __tstate = wxPyBeginAllowThreads();
17128 result = (wxConfigBase *)wxConfigBase::Get(arg1);
17129
17130 wxPyEndAllowThreads(__tstate);
17131 if (PyErr_Occurred()) SWIG_fail;
17132 }
17133 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17134 return resultobj;
17135 fail:
17136 return NULL;
17137 }
17138
17139
17140 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17141 PyObject *resultobj;
17142 wxConfigBase *result;
17143 char *kwnames[] = {
17144 NULL
17145 };
17146
17147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
17148 {
17149 PyThreadState* __tstate = wxPyBeginAllowThreads();
17150 result = (wxConfigBase *)wxConfigBase::Create();
17151
17152 wxPyEndAllowThreads(__tstate);
17153 if (PyErr_Occurred()) SWIG_fail;
17154 }
17155 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17156 return resultobj;
17157 fail:
17158 return NULL;
17159 }
17160
17161
17162 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17163 PyObject *resultobj;
17164 char *kwnames[] = {
17165 NULL
17166 };
17167
17168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17169 {
17170 PyThreadState* __tstate = wxPyBeginAllowThreads();
17171 wxConfigBase::DontCreateOnDemand();
17172
17173 wxPyEndAllowThreads(__tstate);
17174 if (PyErr_Occurred()) SWIG_fail;
17175 }
17176 Py_INCREF(Py_None); resultobj = Py_None;
17177 return resultobj;
17178 fail:
17179 return NULL;
17180 }
17181
17182
17183 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17184 PyObject *resultobj;
17185 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17186 wxString *arg2 = 0 ;
17187 bool temp2 = false ;
17188 PyObject * obj0 = 0 ;
17189 PyObject * obj1 = 0 ;
17190 char *kwnames[] = {
17191 (char *) "self",(char *) "path", NULL
17192 };
17193
17194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17196 if (SWIG_arg_fail(1)) SWIG_fail;
17197 {
17198 arg2 = wxString_in_helper(obj1);
17199 if (arg2 == NULL) SWIG_fail;
17200 temp2 = true;
17201 }
17202 {
17203 PyThreadState* __tstate = wxPyBeginAllowThreads();
17204 (arg1)->SetPath((wxString const &)*arg2);
17205
17206 wxPyEndAllowThreads(__tstate);
17207 if (PyErr_Occurred()) SWIG_fail;
17208 }
17209 Py_INCREF(Py_None); resultobj = Py_None;
17210 {
17211 if (temp2)
17212 delete arg2;
17213 }
17214 return resultobj;
17215 fail:
17216 {
17217 if (temp2)
17218 delete arg2;
17219 }
17220 return NULL;
17221 }
17222
17223
17224 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17225 PyObject *resultobj;
17226 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17227 wxString *result;
17228 PyObject * obj0 = 0 ;
17229 char *kwnames[] = {
17230 (char *) "self", NULL
17231 };
17232
17233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17235 if (SWIG_arg_fail(1)) SWIG_fail;
17236 {
17237 PyThreadState* __tstate = wxPyBeginAllowThreads();
17238 {
17239 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17240 result = (wxString *) &_result_ref;
17241 }
17242
17243 wxPyEndAllowThreads(__tstate);
17244 if (PyErr_Occurred()) SWIG_fail;
17245 }
17246 {
17247 #if wxUSE_UNICODE
17248 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17249 #else
17250 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17251 #endif
17252 }
17253 return resultobj;
17254 fail:
17255 return NULL;
17256 }
17257
17258
17259 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17260 PyObject *resultobj;
17261 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17262 PyObject *result;
17263 PyObject * obj0 = 0 ;
17264 char *kwnames[] = {
17265 (char *) "self", NULL
17266 };
17267
17268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17270 if (SWIG_arg_fail(1)) SWIG_fail;
17271 {
17272 PyThreadState* __tstate = wxPyBeginAllowThreads();
17273 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17274
17275 wxPyEndAllowThreads(__tstate);
17276 if (PyErr_Occurred()) SWIG_fail;
17277 }
17278 resultobj = result;
17279 return resultobj;
17280 fail:
17281 return NULL;
17282 }
17283
17284
17285 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17286 PyObject *resultobj;
17287 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17288 long arg2 ;
17289 PyObject *result;
17290 PyObject * obj0 = 0 ;
17291 PyObject * obj1 = 0 ;
17292 char *kwnames[] = {
17293 (char *) "self",(char *) "index", NULL
17294 };
17295
17296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17298 if (SWIG_arg_fail(1)) SWIG_fail;
17299 {
17300 arg2 = (long)(SWIG_As_long(obj1));
17301 if (SWIG_arg_fail(2)) SWIG_fail;
17302 }
17303 {
17304 PyThreadState* __tstate = wxPyBeginAllowThreads();
17305 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17306
17307 wxPyEndAllowThreads(__tstate);
17308 if (PyErr_Occurred()) SWIG_fail;
17309 }
17310 resultobj = result;
17311 return resultobj;
17312 fail:
17313 return NULL;
17314 }
17315
17316
17317 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17318 PyObject *resultobj;
17319 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17320 PyObject *result;
17321 PyObject * obj0 = 0 ;
17322 char *kwnames[] = {
17323 (char *) "self", NULL
17324 };
17325
17326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17328 if (SWIG_arg_fail(1)) SWIG_fail;
17329 {
17330 PyThreadState* __tstate = wxPyBeginAllowThreads();
17331 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17332
17333 wxPyEndAllowThreads(__tstate);
17334 if (PyErr_Occurred()) SWIG_fail;
17335 }
17336 resultobj = result;
17337 return resultobj;
17338 fail:
17339 return NULL;
17340 }
17341
17342
17343 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17344 PyObject *resultobj;
17345 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17346 long arg2 ;
17347 PyObject *result;
17348 PyObject * obj0 = 0 ;
17349 PyObject * obj1 = 0 ;
17350 char *kwnames[] = {
17351 (char *) "self",(char *) "index", NULL
17352 };
17353
17354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17356 if (SWIG_arg_fail(1)) SWIG_fail;
17357 {
17358 arg2 = (long)(SWIG_As_long(obj1));
17359 if (SWIG_arg_fail(2)) SWIG_fail;
17360 }
17361 {
17362 PyThreadState* __tstate = wxPyBeginAllowThreads();
17363 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17364
17365 wxPyEndAllowThreads(__tstate);
17366 if (PyErr_Occurred()) SWIG_fail;
17367 }
17368 resultobj = result;
17369 return resultobj;
17370 fail:
17371 return NULL;
17372 }
17373
17374
17375 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17376 PyObject *resultobj;
17377 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17378 bool arg2 = (bool) false ;
17379 size_t result;
17380 PyObject * obj0 = 0 ;
17381 PyObject * obj1 = 0 ;
17382 char *kwnames[] = {
17383 (char *) "self",(char *) "recursive", NULL
17384 };
17385
17386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17388 if (SWIG_arg_fail(1)) SWIG_fail;
17389 if (obj1) {
17390 {
17391 arg2 = (bool)(SWIG_As_bool(obj1));
17392 if (SWIG_arg_fail(2)) SWIG_fail;
17393 }
17394 }
17395 {
17396 PyThreadState* __tstate = wxPyBeginAllowThreads();
17397 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17398
17399 wxPyEndAllowThreads(__tstate);
17400 if (PyErr_Occurred()) SWIG_fail;
17401 }
17402 {
17403 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17404 }
17405 return resultobj;
17406 fail:
17407 return NULL;
17408 }
17409
17410
17411 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17412 PyObject *resultobj;
17413 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17414 bool arg2 = (bool) false ;
17415 size_t result;
17416 PyObject * obj0 = 0 ;
17417 PyObject * obj1 = 0 ;
17418 char *kwnames[] = {
17419 (char *) "self",(char *) "recursive", NULL
17420 };
17421
17422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17424 if (SWIG_arg_fail(1)) SWIG_fail;
17425 if (obj1) {
17426 {
17427 arg2 = (bool)(SWIG_As_bool(obj1));
17428 if (SWIG_arg_fail(2)) SWIG_fail;
17429 }
17430 }
17431 {
17432 PyThreadState* __tstate = wxPyBeginAllowThreads();
17433 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17434
17435 wxPyEndAllowThreads(__tstate);
17436 if (PyErr_Occurred()) SWIG_fail;
17437 }
17438 {
17439 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17440 }
17441 return resultobj;
17442 fail:
17443 return NULL;
17444 }
17445
17446
17447 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17448 PyObject *resultobj;
17449 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17450 wxString *arg2 = 0 ;
17451 bool result;
17452 bool temp2 = false ;
17453 PyObject * obj0 = 0 ;
17454 PyObject * obj1 = 0 ;
17455 char *kwnames[] = {
17456 (char *) "self",(char *) "name", NULL
17457 };
17458
17459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17461 if (SWIG_arg_fail(1)) SWIG_fail;
17462 {
17463 arg2 = wxString_in_helper(obj1);
17464 if (arg2 == NULL) SWIG_fail;
17465 temp2 = true;
17466 }
17467 {
17468 PyThreadState* __tstate = wxPyBeginAllowThreads();
17469 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17470
17471 wxPyEndAllowThreads(__tstate);
17472 if (PyErr_Occurred()) SWIG_fail;
17473 }
17474 {
17475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17476 }
17477 {
17478 if (temp2)
17479 delete arg2;
17480 }
17481 return resultobj;
17482 fail:
17483 {
17484 if (temp2)
17485 delete arg2;
17486 }
17487 return NULL;
17488 }
17489
17490
17491 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17492 PyObject *resultobj;
17493 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17494 wxString *arg2 = 0 ;
17495 bool result;
17496 bool temp2 = false ;
17497 PyObject * obj0 = 0 ;
17498 PyObject * obj1 = 0 ;
17499 char *kwnames[] = {
17500 (char *) "self",(char *) "name", NULL
17501 };
17502
17503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) 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 {
17512 PyThreadState* __tstate = wxPyBeginAllowThreads();
17513 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17514
17515 wxPyEndAllowThreads(__tstate);
17516 if (PyErr_Occurred()) SWIG_fail;
17517 }
17518 {
17519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17520 }
17521 {
17522 if (temp2)
17523 delete arg2;
17524 }
17525 return resultobj;
17526 fail:
17527 {
17528 if (temp2)
17529 delete arg2;
17530 }
17531 return NULL;
17532 }
17533
17534
17535 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17536 PyObject *resultobj;
17537 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17538 wxString *arg2 = 0 ;
17539 bool result;
17540 bool temp2 = false ;
17541 PyObject * obj0 = 0 ;
17542 PyObject * obj1 = 0 ;
17543 char *kwnames[] = {
17544 (char *) "self",(char *) "name", NULL
17545 };
17546
17547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17549 if (SWIG_arg_fail(1)) SWIG_fail;
17550 {
17551 arg2 = wxString_in_helper(obj1);
17552 if (arg2 == NULL) SWIG_fail;
17553 temp2 = true;
17554 }
17555 {
17556 PyThreadState* __tstate = wxPyBeginAllowThreads();
17557 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17558
17559 wxPyEndAllowThreads(__tstate);
17560 if (PyErr_Occurred()) SWIG_fail;
17561 }
17562 {
17563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17564 }
17565 {
17566 if (temp2)
17567 delete arg2;
17568 }
17569 return resultobj;
17570 fail:
17571 {
17572 if (temp2)
17573 delete arg2;
17574 }
17575 return NULL;
17576 }
17577
17578
17579 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17580 PyObject *resultobj;
17581 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17582 wxString *arg2 = 0 ;
17583 wxConfigBase::EntryType result;
17584 bool temp2 = false ;
17585 PyObject * obj0 = 0 ;
17586 PyObject * obj1 = 0 ;
17587 char *kwnames[] = {
17588 (char *) "self",(char *) "name", NULL
17589 };
17590
17591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17593 if (SWIG_arg_fail(1)) SWIG_fail;
17594 {
17595 arg2 = wxString_in_helper(obj1);
17596 if (arg2 == NULL) SWIG_fail;
17597 temp2 = true;
17598 }
17599 {
17600 PyThreadState* __tstate = wxPyBeginAllowThreads();
17601 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17602
17603 wxPyEndAllowThreads(__tstate);
17604 if (PyErr_Occurred()) SWIG_fail;
17605 }
17606 resultobj = SWIG_From_int((result));
17607 {
17608 if (temp2)
17609 delete arg2;
17610 }
17611 return resultobj;
17612 fail:
17613 {
17614 if (temp2)
17615 delete arg2;
17616 }
17617 return NULL;
17618 }
17619
17620
17621 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17622 PyObject *resultobj;
17623 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17624 wxString *arg2 = 0 ;
17625 wxString const &arg3_defvalue = wxPyEmptyString ;
17626 wxString *arg3 = (wxString *) &arg3_defvalue ;
17627 wxString result;
17628 bool temp2 = false ;
17629 bool temp3 = false ;
17630 PyObject * obj0 = 0 ;
17631 PyObject * obj1 = 0 ;
17632 PyObject * obj2 = 0 ;
17633 char *kwnames[] = {
17634 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17635 };
17636
17637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17639 if (SWIG_arg_fail(1)) SWIG_fail;
17640 {
17641 arg2 = wxString_in_helper(obj1);
17642 if (arg2 == NULL) SWIG_fail;
17643 temp2 = true;
17644 }
17645 if (obj2) {
17646 {
17647 arg3 = wxString_in_helper(obj2);
17648 if (arg3 == NULL) SWIG_fail;
17649 temp3 = true;
17650 }
17651 }
17652 {
17653 PyThreadState* __tstate = wxPyBeginAllowThreads();
17654 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17655
17656 wxPyEndAllowThreads(__tstate);
17657 if (PyErr_Occurred()) SWIG_fail;
17658 }
17659 {
17660 #if wxUSE_UNICODE
17661 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17662 #else
17663 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17664 #endif
17665 }
17666 {
17667 if (temp2)
17668 delete arg2;
17669 }
17670 {
17671 if (temp3)
17672 delete arg3;
17673 }
17674 return resultobj;
17675 fail:
17676 {
17677 if (temp2)
17678 delete arg2;
17679 }
17680 {
17681 if (temp3)
17682 delete arg3;
17683 }
17684 return NULL;
17685 }
17686
17687
17688 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17689 PyObject *resultobj;
17690 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17691 wxString *arg2 = 0 ;
17692 long arg3 = (long) 0 ;
17693 long result;
17694 bool temp2 = false ;
17695 PyObject * obj0 = 0 ;
17696 PyObject * obj1 = 0 ;
17697 PyObject * obj2 = 0 ;
17698 char *kwnames[] = {
17699 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17700 };
17701
17702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17704 if (SWIG_arg_fail(1)) SWIG_fail;
17705 {
17706 arg2 = wxString_in_helper(obj1);
17707 if (arg2 == NULL) SWIG_fail;
17708 temp2 = true;
17709 }
17710 if (obj2) {
17711 {
17712 arg3 = (long)(SWIG_As_long(obj2));
17713 if (SWIG_arg_fail(3)) SWIG_fail;
17714 }
17715 }
17716 {
17717 PyThreadState* __tstate = wxPyBeginAllowThreads();
17718 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17719
17720 wxPyEndAllowThreads(__tstate);
17721 if (PyErr_Occurred()) SWIG_fail;
17722 }
17723 {
17724 resultobj = SWIG_From_long((long)(result));
17725 }
17726 {
17727 if (temp2)
17728 delete arg2;
17729 }
17730 return resultobj;
17731 fail:
17732 {
17733 if (temp2)
17734 delete arg2;
17735 }
17736 return NULL;
17737 }
17738
17739
17740 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17741 PyObject *resultobj;
17742 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17743 wxString *arg2 = 0 ;
17744 double arg3 = (double) 0.0 ;
17745 double result;
17746 bool temp2 = false ;
17747 PyObject * obj0 = 0 ;
17748 PyObject * obj1 = 0 ;
17749 PyObject * obj2 = 0 ;
17750 char *kwnames[] = {
17751 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17752 };
17753
17754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17756 if (SWIG_arg_fail(1)) SWIG_fail;
17757 {
17758 arg2 = wxString_in_helper(obj1);
17759 if (arg2 == NULL) SWIG_fail;
17760 temp2 = true;
17761 }
17762 if (obj2) {
17763 {
17764 arg3 = (double)(SWIG_As_double(obj2));
17765 if (SWIG_arg_fail(3)) SWIG_fail;
17766 }
17767 }
17768 {
17769 PyThreadState* __tstate = wxPyBeginAllowThreads();
17770 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17771
17772 wxPyEndAllowThreads(__tstate);
17773 if (PyErr_Occurred()) SWIG_fail;
17774 }
17775 {
17776 resultobj = SWIG_From_double((double)(result));
17777 }
17778 {
17779 if (temp2)
17780 delete arg2;
17781 }
17782 return resultobj;
17783 fail:
17784 {
17785 if (temp2)
17786 delete arg2;
17787 }
17788 return NULL;
17789 }
17790
17791
17792 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17793 PyObject *resultobj;
17794 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17795 wxString *arg2 = 0 ;
17796 bool arg3 = (bool) false ;
17797 bool result;
17798 bool temp2 = false ;
17799 PyObject * obj0 = 0 ;
17800 PyObject * obj1 = 0 ;
17801 PyObject * obj2 = 0 ;
17802 char *kwnames[] = {
17803 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17804 };
17805
17806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17808 if (SWIG_arg_fail(1)) SWIG_fail;
17809 {
17810 arg2 = wxString_in_helper(obj1);
17811 if (arg2 == NULL) SWIG_fail;
17812 temp2 = true;
17813 }
17814 if (obj2) {
17815 {
17816 arg3 = (bool)(SWIG_As_bool(obj2));
17817 if (SWIG_arg_fail(3)) SWIG_fail;
17818 }
17819 }
17820 {
17821 PyThreadState* __tstate = wxPyBeginAllowThreads();
17822 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17823
17824 wxPyEndAllowThreads(__tstate);
17825 if (PyErr_Occurred()) SWIG_fail;
17826 }
17827 {
17828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17829 }
17830 {
17831 if (temp2)
17832 delete arg2;
17833 }
17834 return resultobj;
17835 fail:
17836 {
17837 if (temp2)
17838 delete arg2;
17839 }
17840 return NULL;
17841 }
17842
17843
17844 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17845 PyObject *resultobj;
17846 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17847 wxString *arg2 = 0 ;
17848 wxString *arg3 = 0 ;
17849 bool result;
17850 bool temp2 = false ;
17851 bool temp3 = false ;
17852 PyObject * obj0 = 0 ;
17853 PyObject * obj1 = 0 ;
17854 PyObject * obj2 = 0 ;
17855 char *kwnames[] = {
17856 (char *) "self",(char *) "key",(char *) "value", NULL
17857 };
17858
17859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17861 if (SWIG_arg_fail(1)) SWIG_fail;
17862 {
17863 arg2 = wxString_in_helper(obj1);
17864 if (arg2 == NULL) SWIG_fail;
17865 temp2 = true;
17866 }
17867 {
17868 arg3 = wxString_in_helper(obj2);
17869 if (arg3 == NULL) SWIG_fail;
17870 temp3 = true;
17871 }
17872 {
17873 PyThreadState* __tstate = wxPyBeginAllowThreads();
17874 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17875
17876 wxPyEndAllowThreads(__tstate);
17877 if (PyErr_Occurred()) SWIG_fail;
17878 }
17879 {
17880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17881 }
17882 {
17883 if (temp2)
17884 delete arg2;
17885 }
17886 {
17887 if (temp3)
17888 delete arg3;
17889 }
17890 return resultobj;
17891 fail:
17892 {
17893 if (temp2)
17894 delete arg2;
17895 }
17896 {
17897 if (temp3)
17898 delete arg3;
17899 }
17900 return NULL;
17901 }
17902
17903
17904 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17905 PyObject *resultobj;
17906 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17907 wxString *arg2 = 0 ;
17908 long arg3 ;
17909 bool result;
17910 bool temp2 = false ;
17911 PyObject * obj0 = 0 ;
17912 PyObject * obj1 = 0 ;
17913 PyObject * obj2 = 0 ;
17914 char *kwnames[] = {
17915 (char *) "self",(char *) "key",(char *) "value", NULL
17916 };
17917
17918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17920 if (SWIG_arg_fail(1)) SWIG_fail;
17921 {
17922 arg2 = wxString_in_helper(obj1);
17923 if (arg2 == NULL) SWIG_fail;
17924 temp2 = true;
17925 }
17926 {
17927 arg3 = (long)(SWIG_As_long(obj2));
17928 if (SWIG_arg_fail(3)) SWIG_fail;
17929 }
17930 {
17931 PyThreadState* __tstate = wxPyBeginAllowThreads();
17932 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17933
17934 wxPyEndAllowThreads(__tstate);
17935 if (PyErr_Occurred()) SWIG_fail;
17936 }
17937 {
17938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17939 }
17940 {
17941 if (temp2)
17942 delete arg2;
17943 }
17944 return resultobj;
17945 fail:
17946 {
17947 if (temp2)
17948 delete arg2;
17949 }
17950 return NULL;
17951 }
17952
17953
17954 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17955 PyObject *resultobj;
17956 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17957 wxString *arg2 = 0 ;
17958 double arg3 ;
17959 bool result;
17960 bool temp2 = false ;
17961 PyObject * obj0 = 0 ;
17962 PyObject * obj1 = 0 ;
17963 PyObject * obj2 = 0 ;
17964 char *kwnames[] = {
17965 (char *) "self",(char *) "key",(char *) "value", NULL
17966 };
17967
17968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17970 if (SWIG_arg_fail(1)) SWIG_fail;
17971 {
17972 arg2 = wxString_in_helper(obj1);
17973 if (arg2 == NULL) SWIG_fail;
17974 temp2 = true;
17975 }
17976 {
17977 arg3 = (double)(SWIG_As_double(obj2));
17978 if (SWIG_arg_fail(3)) SWIG_fail;
17979 }
17980 {
17981 PyThreadState* __tstate = wxPyBeginAllowThreads();
17982 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17983
17984 wxPyEndAllowThreads(__tstate);
17985 if (PyErr_Occurred()) SWIG_fail;
17986 }
17987 {
17988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17989 }
17990 {
17991 if (temp2)
17992 delete arg2;
17993 }
17994 return resultobj;
17995 fail:
17996 {
17997 if (temp2)
17998 delete arg2;
17999 }
18000 return NULL;
18001 }
18002
18003
18004 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
18005 PyObject *resultobj;
18006 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18007 wxString *arg2 = 0 ;
18008 bool arg3 ;
18009 bool result;
18010 bool temp2 = false ;
18011 PyObject * obj0 = 0 ;
18012 PyObject * obj1 = 0 ;
18013 PyObject * obj2 = 0 ;
18014 char *kwnames[] = {
18015 (char *) "self",(char *) "key",(char *) "value", NULL
18016 };
18017
18018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
18019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18020 if (SWIG_arg_fail(1)) SWIG_fail;
18021 {
18022 arg2 = wxString_in_helper(obj1);
18023 if (arg2 == NULL) SWIG_fail;
18024 temp2 = true;
18025 }
18026 {
18027 arg3 = (bool)(SWIG_As_bool(obj2));
18028 if (SWIG_arg_fail(3)) SWIG_fail;
18029 }
18030 {
18031 PyThreadState* __tstate = wxPyBeginAllowThreads();
18032 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
18033
18034 wxPyEndAllowThreads(__tstate);
18035 if (PyErr_Occurred()) SWIG_fail;
18036 }
18037 {
18038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18039 }
18040 {
18041 if (temp2)
18042 delete arg2;
18043 }
18044 return resultobj;
18045 fail:
18046 {
18047 if (temp2)
18048 delete arg2;
18049 }
18050 return NULL;
18051 }
18052
18053
18054 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
18055 PyObject *resultobj;
18056 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18057 bool arg2 = (bool) false ;
18058 bool result;
18059 PyObject * obj0 = 0 ;
18060 PyObject * obj1 = 0 ;
18061 char *kwnames[] = {
18062 (char *) "self",(char *) "currentOnly", NULL
18063 };
18064
18065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
18066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18067 if (SWIG_arg_fail(1)) SWIG_fail;
18068 if (obj1) {
18069 {
18070 arg2 = (bool)(SWIG_As_bool(obj1));
18071 if (SWIG_arg_fail(2)) SWIG_fail;
18072 }
18073 }
18074 {
18075 PyThreadState* __tstate = wxPyBeginAllowThreads();
18076 result = (bool)(arg1)->Flush(arg2);
18077
18078 wxPyEndAllowThreads(__tstate);
18079 if (PyErr_Occurred()) SWIG_fail;
18080 }
18081 {
18082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18083 }
18084 return resultobj;
18085 fail:
18086 return NULL;
18087 }
18088
18089
18090 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18091 PyObject *resultobj;
18092 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18093 wxString *arg2 = 0 ;
18094 wxString *arg3 = 0 ;
18095 bool result;
18096 bool temp2 = false ;
18097 bool temp3 = false ;
18098 PyObject * obj0 = 0 ;
18099 PyObject * obj1 = 0 ;
18100 PyObject * obj2 = 0 ;
18101 char *kwnames[] = {
18102 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18103 };
18104
18105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18107 if (SWIG_arg_fail(1)) SWIG_fail;
18108 {
18109 arg2 = wxString_in_helper(obj1);
18110 if (arg2 == NULL) SWIG_fail;
18111 temp2 = true;
18112 }
18113 {
18114 arg3 = wxString_in_helper(obj2);
18115 if (arg3 == NULL) SWIG_fail;
18116 temp3 = true;
18117 }
18118 {
18119 PyThreadState* __tstate = wxPyBeginAllowThreads();
18120 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
18121
18122 wxPyEndAllowThreads(__tstate);
18123 if (PyErr_Occurred()) SWIG_fail;
18124 }
18125 {
18126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18127 }
18128 {
18129 if (temp2)
18130 delete arg2;
18131 }
18132 {
18133 if (temp3)
18134 delete arg3;
18135 }
18136 return resultobj;
18137 fail:
18138 {
18139 if (temp2)
18140 delete arg2;
18141 }
18142 {
18143 if (temp3)
18144 delete arg3;
18145 }
18146 return NULL;
18147 }
18148
18149
18150 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18151 PyObject *resultobj;
18152 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18153 wxString *arg2 = 0 ;
18154 wxString *arg3 = 0 ;
18155 bool result;
18156 bool temp2 = false ;
18157 bool temp3 = false ;
18158 PyObject * obj0 = 0 ;
18159 PyObject * obj1 = 0 ;
18160 PyObject * obj2 = 0 ;
18161 char *kwnames[] = {
18162 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18163 };
18164
18165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) 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 arg3 = wxString_in_helper(obj2);
18175 if (arg3 == NULL) SWIG_fail;
18176 temp3 = true;
18177 }
18178 {
18179 PyThreadState* __tstate = wxPyBeginAllowThreads();
18180 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18181
18182 wxPyEndAllowThreads(__tstate);
18183 if (PyErr_Occurred()) SWIG_fail;
18184 }
18185 {
18186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18187 }
18188 {
18189 if (temp2)
18190 delete arg2;
18191 }
18192 {
18193 if (temp3)
18194 delete arg3;
18195 }
18196 return resultobj;
18197 fail:
18198 {
18199 if (temp2)
18200 delete arg2;
18201 }
18202 {
18203 if (temp3)
18204 delete arg3;
18205 }
18206 return NULL;
18207 }
18208
18209
18210 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18211 PyObject *resultobj;
18212 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18213 wxString *arg2 = 0 ;
18214 bool arg3 = (bool) true ;
18215 bool result;
18216 bool temp2 = false ;
18217 PyObject * obj0 = 0 ;
18218 PyObject * obj1 = 0 ;
18219 PyObject * obj2 = 0 ;
18220 char *kwnames[] = {
18221 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18222 };
18223
18224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18226 if (SWIG_arg_fail(1)) SWIG_fail;
18227 {
18228 arg2 = wxString_in_helper(obj1);
18229 if (arg2 == NULL) SWIG_fail;
18230 temp2 = true;
18231 }
18232 if (obj2) {
18233 {
18234 arg3 = (bool)(SWIG_As_bool(obj2));
18235 if (SWIG_arg_fail(3)) SWIG_fail;
18236 }
18237 }
18238 {
18239 PyThreadState* __tstate = wxPyBeginAllowThreads();
18240 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18241
18242 wxPyEndAllowThreads(__tstate);
18243 if (PyErr_Occurred()) SWIG_fail;
18244 }
18245 {
18246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18247 }
18248 {
18249 if (temp2)
18250 delete arg2;
18251 }
18252 return resultobj;
18253 fail:
18254 {
18255 if (temp2)
18256 delete arg2;
18257 }
18258 return NULL;
18259 }
18260
18261
18262 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18263 PyObject *resultobj;
18264 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18265 wxString *arg2 = 0 ;
18266 bool result;
18267 bool temp2 = false ;
18268 PyObject * obj0 = 0 ;
18269 PyObject * obj1 = 0 ;
18270 char *kwnames[] = {
18271 (char *) "self",(char *) "key", NULL
18272 };
18273
18274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18276 if (SWIG_arg_fail(1)) SWIG_fail;
18277 {
18278 arg2 = wxString_in_helper(obj1);
18279 if (arg2 == NULL) SWIG_fail;
18280 temp2 = true;
18281 }
18282 {
18283 PyThreadState* __tstate = wxPyBeginAllowThreads();
18284 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18285
18286 wxPyEndAllowThreads(__tstate);
18287 if (PyErr_Occurred()) SWIG_fail;
18288 }
18289 {
18290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18291 }
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_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18307 PyObject *resultobj;
18308 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18309 bool result;
18310 PyObject * obj0 = 0 ;
18311 char *kwnames[] = {
18312 (char *) "self", NULL
18313 };
18314
18315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18317 if (SWIG_arg_fail(1)) SWIG_fail;
18318 {
18319 PyThreadState* __tstate = wxPyBeginAllowThreads();
18320 result = (bool)(arg1)->DeleteAll();
18321
18322 wxPyEndAllowThreads(__tstate);
18323 if (PyErr_Occurred()) SWIG_fail;
18324 }
18325 {
18326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18327 }
18328 return resultobj;
18329 fail:
18330 return NULL;
18331 }
18332
18333
18334 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18335 PyObject *resultobj;
18336 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18337 bool arg2 = (bool) true ;
18338 PyObject * obj0 = 0 ;
18339 PyObject * obj1 = 0 ;
18340 char *kwnames[] = {
18341 (char *) "self",(char *) "doIt", NULL
18342 };
18343
18344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18346 if (SWIG_arg_fail(1)) SWIG_fail;
18347 if (obj1) {
18348 {
18349 arg2 = (bool)(SWIG_As_bool(obj1));
18350 if (SWIG_arg_fail(2)) SWIG_fail;
18351 }
18352 }
18353 {
18354 PyThreadState* __tstate = wxPyBeginAllowThreads();
18355 (arg1)->SetExpandEnvVars(arg2);
18356
18357 wxPyEndAllowThreads(__tstate);
18358 if (PyErr_Occurred()) SWIG_fail;
18359 }
18360 Py_INCREF(Py_None); resultobj = Py_None;
18361 return resultobj;
18362 fail:
18363 return NULL;
18364 }
18365
18366
18367 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18368 PyObject *resultobj;
18369 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18370 bool result;
18371 PyObject * obj0 = 0 ;
18372 char *kwnames[] = {
18373 (char *) "self", NULL
18374 };
18375
18376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18378 if (SWIG_arg_fail(1)) SWIG_fail;
18379 {
18380 PyThreadState* __tstate = wxPyBeginAllowThreads();
18381 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18382
18383 wxPyEndAllowThreads(__tstate);
18384 if (PyErr_Occurred()) SWIG_fail;
18385 }
18386 {
18387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18388 }
18389 return resultobj;
18390 fail:
18391 return NULL;
18392 }
18393
18394
18395 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18396 PyObject *resultobj;
18397 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18398 bool arg2 = (bool) true ;
18399 PyObject * obj0 = 0 ;
18400 PyObject * obj1 = 0 ;
18401 char *kwnames[] = {
18402 (char *) "self",(char *) "doIt", NULL
18403 };
18404
18405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18407 if (SWIG_arg_fail(1)) SWIG_fail;
18408 if (obj1) {
18409 {
18410 arg2 = (bool)(SWIG_As_bool(obj1));
18411 if (SWIG_arg_fail(2)) SWIG_fail;
18412 }
18413 }
18414 {
18415 PyThreadState* __tstate = wxPyBeginAllowThreads();
18416 (arg1)->SetRecordDefaults(arg2);
18417
18418 wxPyEndAllowThreads(__tstate);
18419 if (PyErr_Occurred()) SWIG_fail;
18420 }
18421 Py_INCREF(Py_None); resultobj = Py_None;
18422 return resultobj;
18423 fail:
18424 return NULL;
18425 }
18426
18427
18428 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18429 PyObject *resultobj;
18430 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18431 bool result;
18432 PyObject * obj0 = 0 ;
18433 char *kwnames[] = {
18434 (char *) "self", NULL
18435 };
18436
18437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18439 if (SWIG_arg_fail(1)) SWIG_fail;
18440 {
18441 PyThreadState* __tstate = wxPyBeginAllowThreads();
18442 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18443
18444 wxPyEndAllowThreads(__tstate);
18445 if (PyErr_Occurred()) SWIG_fail;
18446 }
18447 {
18448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18449 }
18450 return resultobj;
18451 fail:
18452 return NULL;
18453 }
18454
18455
18456 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18457 PyObject *resultobj;
18458 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18459 wxString *arg2 = 0 ;
18460 wxString result;
18461 bool temp2 = false ;
18462 PyObject * obj0 = 0 ;
18463 PyObject * obj1 = 0 ;
18464 char *kwnames[] = {
18465 (char *) "self",(char *) "str", NULL
18466 };
18467
18468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18470 if (SWIG_arg_fail(1)) SWIG_fail;
18471 {
18472 arg2 = wxString_in_helper(obj1);
18473 if (arg2 == NULL) SWIG_fail;
18474 temp2 = true;
18475 }
18476 {
18477 PyThreadState* __tstate = wxPyBeginAllowThreads();
18478 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18479
18480 wxPyEndAllowThreads(__tstate);
18481 if (PyErr_Occurred()) SWIG_fail;
18482 }
18483 {
18484 #if wxUSE_UNICODE
18485 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18486 #else
18487 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18488 #endif
18489 }
18490 {
18491 if (temp2)
18492 delete arg2;
18493 }
18494 return resultobj;
18495 fail:
18496 {
18497 if (temp2)
18498 delete arg2;
18499 }
18500 return NULL;
18501 }
18502
18503
18504 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18505 PyObject *resultobj;
18506 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18507 wxString result;
18508 PyObject * obj0 = 0 ;
18509 char *kwnames[] = {
18510 (char *) "self", NULL
18511 };
18512
18513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18515 if (SWIG_arg_fail(1)) SWIG_fail;
18516 {
18517 PyThreadState* __tstate = wxPyBeginAllowThreads();
18518 result = ((wxConfigBase const *)arg1)->GetAppName();
18519
18520 wxPyEndAllowThreads(__tstate);
18521 if (PyErr_Occurred()) SWIG_fail;
18522 }
18523 {
18524 #if wxUSE_UNICODE
18525 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18526 #else
18527 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18528 #endif
18529 }
18530 return resultobj;
18531 fail:
18532 return NULL;
18533 }
18534
18535
18536 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18537 PyObject *resultobj;
18538 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18539 wxString result;
18540 PyObject * obj0 = 0 ;
18541 char *kwnames[] = {
18542 (char *) "self", NULL
18543 };
18544
18545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18547 if (SWIG_arg_fail(1)) SWIG_fail;
18548 {
18549 PyThreadState* __tstate = wxPyBeginAllowThreads();
18550 result = ((wxConfigBase const *)arg1)->GetVendorName();
18551
18552 wxPyEndAllowThreads(__tstate);
18553 if (PyErr_Occurred()) SWIG_fail;
18554 }
18555 {
18556 #if wxUSE_UNICODE
18557 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18558 #else
18559 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18560 #endif
18561 }
18562 return resultobj;
18563 fail:
18564 return NULL;
18565 }
18566
18567
18568 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18569 PyObject *resultobj;
18570 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18571 wxString *arg2 = 0 ;
18572 bool temp2 = false ;
18573 PyObject * obj0 = 0 ;
18574 PyObject * obj1 = 0 ;
18575 char *kwnames[] = {
18576 (char *) "self",(char *) "appName", NULL
18577 };
18578
18579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18581 if (SWIG_arg_fail(1)) SWIG_fail;
18582 {
18583 arg2 = wxString_in_helper(obj1);
18584 if (arg2 == NULL) SWIG_fail;
18585 temp2 = true;
18586 }
18587 {
18588 PyThreadState* __tstate = wxPyBeginAllowThreads();
18589 (arg1)->SetAppName((wxString const &)*arg2);
18590
18591 wxPyEndAllowThreads(__tstate);
18592 if (PyErr_Occurred()) SWIG_fail;
18593 }
18594 Py_INCREF(Py_None); resultobj = Py_None;
18595 {
18596 if (temp2)
18597 delete arg2;
18598 }
18599 return resultobj;
18600 fail:
18601 {
18602 if (temp2)
18603 delete arg2;
18604 }
18605 return NULL;
18606 }
18607
18608
18609 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18610 PyObject *resultobj;
18611 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18612 wxString *arg2 = 0 ;
18613 bool temp2 = false ;
18614 PyObject * obj0 = 0 ;
18615 PyObject * obj1 = 0 ;
18616 char *kwnames[] = {
18617 (char *) "self",(char *) "vendorName", NULL
18618 };
18619
18620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18622 if (SWIG_arg_fail(1)) SWIG_fail;
18623 {
18624 arg2 = wxString_in_helper(obj1);
18625 if (arg2 == NULL) SWIG_fail;
18626 temp2 = true;
18627 }
18628 {
18629 PyThreadState* __tstate = wxPyBeginAllowThreads();
18630 (arg1)->SetVendorName((wxString const &)*arg2);
18631
18632 wxPyEndAllowThreads(__tstate);
18633 if (PyErr_Occurred()) SWIG_fail;
18634 }
18635 Py_INCREF(Py_None); resultobj = Py_None;
18636 {
18637 if (temp2)
18638 delete arg2;
18639 }
18640 return resultobj;
18641 fail:
18642 {
18643 if (temp2)
18644 delete arg2;
18645 }
18646 return NULL;
18647 }
18648
18649
18650 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18651 PyObject *resultobj;
18652 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18653 long arg2 ;
18654 PyObject * obj0 = 0 ;
18655 PyObject * obj1 = 0 ;
18656 char *kwnames[] = {
18657 (char *) "self",(char *) "style", NULL
18658 };
18659
18660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18662 if (SWIG_arg_fail(1)) SWIG_fail;
18663 {
18664 arg2 = (long)(SWIG_As_long(obj1));
18665 if (SWIG_arg_fail(2)) SWIG_fail;
18666 }
18667 {
18668 PyThreadState* __tstate = wxPyBeginAllowThreads();
18669 (arg1)->SetStyle(arg2);
18670
18671 wxPyEndAllowThreads(__tstate);
18672 if (PyErr_Occurred()) SWIG_fail;
18673 }
18674 Py_INCREF(Py_None); resultobj = Py_None;
18675 return resultobj;
18676 fail:
18677 return NULL;
18678 }
18679
18680
18681 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18682 PyObject *resultobj;
18683 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18684 long result;
18685 PyObject * obj0 = 0 ;
18686 char *kwnames[] = {
18687 (char *) "self", NULL
18688 };
18689
18690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18692 if (SWIG_arg_fail(1)) SWIG_fail;
18693 {
18694 PyThreadState* __tstate = wxPyBeginAllowThreads();
18695 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18696
18697 wxPyEndAllowThreads(__tstate);
18698 if (PyErr_Occurred()) SWIG_fail;
18699 }
18700 {
18701 resultobj = SWIG_From_long((long)(result));
18702 }
18703 return resultobj;
18704 fail:
18705 return NULL;
18706 }
18707
18708
18709 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18710 PyObject *obj;
18711 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18712 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18713 Py_INCREF(obj);
18714 return Py_BuildValue((char *)"");
18715 }
18716 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18717 PyObject *resultobj;
18718 wxString const &arg1_defvalue = wxPyEmptyString ;
18719 wxString *arg1 = (wxString *) &arg1_defvalue ;
18720 wxString const &arg2_defvalue = wxPyEmptyString ;
18721 wxString *arg2 = (wxString *) &arg2_defvalue ;
18722 wxString const &arg3_defvalue = wxPyEmptyString ;
18723 wxString *arg3 = (wxString *) &arg3_defvalue ;
18724 wxString const &arg4_defvalue = wxPyEmptyString ;
18725 wxString *arg4 = (wxString *) &arg4_defvalue ;
18726 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18727 wxConfig *result;
18728 bool temp1 = false ;
18729 bool temp2 = false ;
18730 bool temp3 = false ;
18731 bool temp4 = false ;
18732 PyObject * obj0 = 0 ;
18733 PyObject * obj1 = 0 ;
18734 PyObject * obj2 = 0 ;
18735 PyObject * obj3 = 0 ;
18736 PyObject * obj4 = 0 ;
18737 char *kwnames[] = {
18738 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18739 };
18740
18741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18742 if (obj0) {
18743 {
18744 arg1 = wxString_in_helper(obj0);
18745 if (arg1 == NULL) SWIG_fail;
18746 temp1 = true;
18747 }
18748 }
18749 if (obj1) {
18750 {
18751 arg2 = wxString_in_helper(obj1);
18752 if (arg2 == NULL) SWIG_fail;
18753 temp2 = true;
18754 }
18755 }
18756 if (obj2) {
18757 {
18758 arg3 = wxString_in_helper(obj2);
18759 if (arg3 == NULL) SWIG_fail;
18760 temp3 = true;
18761 }
18762 }
18763 if (obj3) {
18764 {
18765 arg4 = wxString_in_helper(obj3);
18766 if (arg4 == NULL) SWIG_fail;
18767 temp4 = true;
18768 }
18769 }
18770 if (obj4) {
18771 {
18772 arg5 = (long)(SWIG_As_long(obj4));
18773 if (SWIG_arg_fail(5)) SWIG_fail;
18774 }
18775 }
18776 {
18777 PyThreadState* __tstate = wxPyBeginAllowThreads();
18778 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18779
18780 wxPyEndAllowThreads(__tstate);
18781 if (PyErr_Occurred()) SWIG_fail;
18782 }
18783 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18784 {
18785 if (temp1)
18786 delete arg1;
18787 }
18788 {
18789 if (temp2)
18790 delete arg2;
18791 }
18792 {
18793 if (temp3)
18794 delete arg3;
18795 }
18796 {
18797 if (temp4)
18798 delete arg4;
18799 }
18800 return resultobj;
18801 fail:
18802 {
18803 if (temp1)
18804 delete arg1;
18805 }
18806 {
18807 if (temp2)
18808 delete arg2;
18809 }
18810 {
18811 if (temp3)
18812 delete arg3;
18813 }
18814 {
18815 if (temp4)
18816 delete arg4;
18817 }
18818 return NULL;
18819 }
18820
18821
18822 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18823 PyObject *resultobj;
18824 wxConfig *arg1 = (wxConfig *) 0 ;
18825 PyObject * obj0 = 0 ;
18826 char *kwnames[] = {
18827 (char *) "self", NULL
18828 };
18829
18830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18832 if (SWIG_arg_fail(1)) SWIG_fail;
18833 {
18834 PyThreadState* __tstate = wxPyBeginAllowThreads();
18835 delete arg1;
18836
18837 wxPyEndAllowThreads(__tstate);
18838 if (PyErr_Occurred()) SWIG_fail;
18839 }
18840 Py_INCREF(Py_None); resultobj = Py_None;
18841 return resultobj;
18842 fail:
18843 return NULL;
18844 }
18845
18846
18847 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18848 PyObject *obj;
18849 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18850 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18851 Py_INCREF(obj);
18852 return Py_BuildValue((char *)"");
18853 }
18854 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18855 PyObject *resultobj;
18856 wxString const &arg1_defvalue = wxPyEmptyString ;
18857 wxString *arg1 = (wxString *) &arg1_defvalue ;
18858 wxString const &arg2_defvalue = wxPyEmptyString ;
18859 wxString *arg2 = (wxString *) &arg2_defvalue ;
18860 wxString const &arg3_defvalue = wxPyEmptyString ;
18861 wxString *arg3 = (wxString *) &arg3_defvalue ;
18862 wxString const &arg4_defvalue = wxPyEmptyString ;
18863 wxString *arg4 = (wxString *) &arg4_defvalue ;
18864 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18865 wxFileConfig *result;
18866 bool temp1 = false ;
18867 bool temp2 = false ;
18868 bool temp3 = false ;
18869 bool temp4 = false ;
18870 PyObject * obj0 = 0 ;
18871 PyObject * obj1 = 0 ;
18872 PyObject * obj2 = 0 ;
18873 PyObject * obj3 = 0 ;
18874 PyObject * obj4 = 0 ;
18875 char *kwnames[] = {
18876 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18877 };
18878
18879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18880 if (obj0) {
18881 {
18882 arg1 = wxString_in_helper(obj0);
18883 if (arg1 == NULL) SWIG_fail;
18884 temp1 = true;
18885 }
18886 }
18887 if (obj1) {
18888 {
18889 arg2 = wxString_in_helper(obj1);
18890 if (arg2 == NULL) SWIG_fail;
18891 temp2 = true;
18892 }
18893 }
18894 if (obj2) {
18895 {
18896 arg3 = wxString_in_helper(obj2);
18897 if (arg3 == NULL) SWIG_fail;
18898 temp3 = true;
18899 }
18900 }
18901 if (obj3) {
18902 {
18903 arg4 = wxString_in_helper(obj3);
18904 if (arg4 == NULL) SWIG_fail;
18905 temp4 = true;
18906 }
18907 }
18908 if (obj4) {
18909 {
18910 arg5 = (long)(SWIG_As_long(obj4));
18911 if (SWIG_arg_fail(5)) SWIG_fail;
18912 }
18913 }
18914 {
18915 PyThreadState* __tstate = wxPyBeginAllowThreads();
18916 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18917
18918 wxPyEndAllowThreads(__tstate);
18919 if (PyErr_Occurred()) SWIG_fail;
18920 }
18921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18922 {
18923 if (temp1)
18924 delete arg1;
18925 }
18926 {
18927 if (temp2)
18928 delete arg2;
18929 }
18930 {
18931 if (temp3)
18932 delete arg3;
18933 }
18934 {
18935 if (temp4)
18936 delete arg4;
18937 }
18938 return resultobj;
18939 fail:
18940 {
18941 if (temp1)
18942 delete arg1;
18943 }
18944 {
18945 if (temp2)
18946 delete arg2;
18947 }
18948 {
18949 if (temp3)
18950 delete arg3;
18951 }
18952 {
18953 if (temp4)
18954 delete arg4;
18955 }
18956 return NULL;
18957 }
18958
18959
18960 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18961 PyObject *resultobj;
18962 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18963 PyObject * obj0 = 0 ;
18964 char *kwnames[] = {
18965 (char *) "self", NULL
18966 };
18967
18968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18970 if (SWIG_arg_fail(1)) SWIG_fail;
18971 {
18972 PyThreadState* __tstate = wxPyBeginAllowThreads();
18973 delete arg1;
18974
18975 wxPyEndAllowThreads(__tstate);
18976 if (PyErr_Occurred()) SWIG_fail;
18977 }
18978 Py_INCREF(Py_None); resultobj = Py_None;
18979 return resultobj;
18980 fail:
18981 return NULL;
18982 }
18983
18984
18985 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18986 PyObject *obj;
18987 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18988 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18989 Py_INCREF(obj);
18990 return Py_BuildValue((char *)"");
18991 }
18992 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18993 PyObject *resultobj;
18994 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18995 wxString *arg2 = 0 ;
18996 wxConfigPathChanger *result;
18997 bool temp2 = false ;
18998 PyObject * obj0 = 0 ;
18999 PyObject * obj1 = 0 ;
19000 char *kwnames[] = {
19001 (char *) "config",(char *) "entry", NULL
19002 };
19003
19004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
19005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19006 if (SWIG_arg_fail(1)) SWIG_fail;
19007 {
19008 arg2 = wxString_in_helper(obj1);
19009 if (arg2 == NULL) SWIG_fail;
19010 temp2 = true;
19011 }
19012 {
19013 PyThreadState* __tstate = wxPyBeginAllowThreads();
19014 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
19015
19016 wxPyEndAllowThreads(__tstate);
19017 if (PyErr_Occurred()) SWIG_fail;
19018 }
19019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
19020 {
19021 if (temp2)
19022 delete arg2;
19023 }
19024 return resultobj;
19025 fail:
19026 {
19027 if (temp2)
19028 delete arg2;
19029 }
19030 return NULL;
19031 }
19032
19033
19034 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
19035 PyObject *resultobj;
19036 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
19037 PyObject * obj0 = 0 ;
19038 char *kwnames[] = {
19039 (char *) "self", NULL
19040 };
19041
19042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
19043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
19044 if (SWIG_arg_fail(1)) SWIG_fail;
19045 {
19046 PyThreadState* __tstate = wxPyBeginAllowThreads();
19047 delete arg1;
19048
19049 wxPyEndAllowThreads(__tstate);
19050 if (PyErr_Occurred()) SWIG_fail;
19051 }
19052 Py_INCREF(Py_None); resultobj = Py_None;
19053 return resultobj;
19054 fail:
19055 return NULL;
19056 }
19057
19058
19059 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
19060 PyObject *resultobj;
19061 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
19062 wxString *result;
19063 PyObject * obj0 = 0 ;
19064 char *kwnames[] = {
19065 (char *) "self", NULL
19066 };
19067
19068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
19069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
19070 if (SWIG_arg_fail(1)) SWIG_fail;
19071 {
19072 PyThreadState* __tstate = wxPyBeginAllowThreads();
19073 {
19074 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
19075 result = (wxString *) &_result_ref;
19076 }
19077
19078 wxPyEndAllowThreads(__tstate);
19079 if (PyErr_Occurred()) SWIG_fail;
19080 }
19081 {
19082 #if wxUSE_UNICODE
19083 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19084 #else
19085 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19086 #endif
19087 }
19088 return resultobj;
19089 fail:
19090 return NULL;
19091 }
19092
19093
19094 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
19095 PyObject *obj;
19096 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19097 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
19098 Py_INCREF(obj);
19099 return Py_BuildValue((char *)"");
19100 }
19101 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19102 PyObject *resultobj;
19103 wxString *arg1 = 0 ;
19104 wxString result;
19105 bool temp1 = false ;
19106 PyObject * obj0 = 0 ;
19107 char *kwnames[] = {
19108 (char *) "sz", NULL
19109 };
19110
19111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
19112 {
19113 arg1 = wxString_in_helper(obj0);
19114 if (arg1 == NULL) SWIG_fail;
19115 temp1 = true;
19116 }
19117 {
19118 PyThreadState* __tstate = wxPyBeginAllowThreads();
19119 result = wxExpandEnvVars((wxString const &)*arg1);
19120
19121 wxPyEndAllowThreads(__tstate);
19122 if (PyErr_Occurred()) SWIG_fail;
19123 }
19124 {
19125 #if wxUSE_UNICODE
19126 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19127 #else
19128 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19129 #endif
19130 }
19131 {
19132 if (temp1)
19133 delete arg1;
19134 }
19135 return resultobj;
19136 fail:
19137 {
19138 if (temp1)
19139 delete arg1;
19140 }
19141 return NULL;
19142 }
19143
19144
19145 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
19146 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
19147 return 1;
19148 }
19149
19150
19151 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
19152 PyObject *pyobj;
19153
19154 {
19155 #if wxUSE_UNICODE
19156 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19157 #else
19158 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19159 #endif
19160 }
19161 return pyobj;
19162 }
19163
19164
19165 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19166 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19167 return 1;
19168 }
19169
19170
19171 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19172 PyObject *pyobj;
19173
19174 {
19175 #if wxUSE_UNICODE
19176 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19177 #else
19178 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19179 #endif
19180 }
19181 return pyobj;
19182 }
19183
19184
19185 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19186 PyObject *resultobj;
19187 wxDateTime::Country arg1 ;
19188 PyObject * obj0 = 0 ;
19189 char *kwnames[] = {
19190 (char *) "country", NULL
19191 };
19192
19193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19194 {
19195 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19196 if (SWIG_arg_fail(1)) SWIG_fail;
19197 }
19198 {
19199 PyThreadState* __tstate = wxPyBeginAllowThreads();
19200 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19201
19202 wxPyEndAllowThreads(__tstate);
19203 if (PyErr_Occurred()) SWIG_fail;
19204 }
19205 Py_INCREF(Py_None); resultobj = Py_None;
19206 return resultobj;
19207 fail:
19208 return NULL;
19209 }
19210
19211
19212 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19213 PyObject *resultobj;
19214 wxDateTime::Country result;
19215 char *kwnames[] = {
19216 NULL
19217 };
19218
19219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19220 {
19221 PyThreadState* __tstate = wxPyBeginAllowThreads();
19222 result = (wxDateTime::Country)wxDateTime::GetCountry();
19223
19224 wxPyEndAllowThreads(__tstate);
19225 if (PyErr_Occurred()) SWIG_fail;
19226 }
19227 resultobj = SWIG_From_int((result));
19228 return resultobj;
19229 fail:
19230 return NULL;
19231 }
19232
19233
19234 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19235 PyObject *resultobj;
19236 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19237 bool result;
19238 PyObject * obj0 = 0 ;
19239 char *kwnames[] = {
19240 (char *) "country", NULL
19241 };
19242
19243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19244 if (obj0) {
19245 {
19246 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19247 if (SWIG_arg_fail(1)) SWIG_fail;
19248 }
19249 }
19250 {
19251 PyThreadState* __tstate = wxPyBeginAllowThreads();
19252 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19253
19254 wxPyEndAllowThreads(__tstate);
19255 if (PyErr_Occurred()) SWIG_fail;
19256 }
19257 {
19258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19259 }
19260 return resultobj;
19261 fail:
19262 return NULL;
19263 }
19264
19265
19266 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19267 PyObject *resultobj;
19268 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19269 int result;
19270 PyObject * obj0 = 0 ;
19271 char *kwnames[] = {
19272 (char *) "cal", NULL
19273 };
19274
19275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19276 if (obj0) {
19277 {
19278 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19279 if (SWIG_arg_fail(1)) SWIG_fail;
19280 }
19281 }
19282 {
19283 PyThreadState* __tstate = wxPyBeginAllowThreads();
19284 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19285
19286 wxPyEndAllowThreads(__tstate);
19287 if (PyErr_Occurred()) SWIG_fail;
19288 }
19289 {
19290 resultobj = SWIG_From_int((int)(result));
19291 }
19292 return resultobj;
19293 fail:
19294 return NULL;
19295 }
19296
19297
19298 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19299 PyObject *resultobj;
19300 int arg1 ;
19301 int result;
19302 PyObject * obj0 = 0 ;
19303 char *kwnames[] = {
19304 (char *) "year", NULL
19305 };
19306
19307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19308 {
19309 arg1 = (int)(SWIG_As_int(obj0));
19310 if (SWIG_arg_fail(1)) SWIG_fail;
19311 }
19312 {
19313 PyThreadState* __tstate = wxPyBeginAllowThreads();
19314 result = (int)wxDateTime::ConvertYearToBC(arg1);
19315
19316 wxPyEndAllowThreads(__tstate);
19317 if (PyErr_Occurred()) SWIG_fail;
19318 }
19319 {
19320 resultobj = SWIG_From_int((int)(result));
19321 }
19322 return resultobj;
19323 fail:
19324 return NULL;
19325 }
19326
19327
19328 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19329 PyObject *resultobj;
19330 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19331 wxDateTime::Month result;
19332 PyObject * obj0 = 0 ;
19333 char *kwnames[] = {
19334 (char *) "cal", NULL
19335 };
19336
19337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19338 if (obj0) {
19339 {
19340 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19341 if (SWIG_arg_fail(1)) SWIG_fail;
19342 }
19343 }
19344 {
19345 PyThreadState* __tstate = wxPyBeginAllowThreads();
19346 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19347
19348 wxPyEndAllowThreads(__tstate);
19349 if (PyErr_Occurred()) SWIG_fail;
19350 }
19351 resultobj = SWIG_From_int((result));
19352 return resultobj;
19353 fail:
19354 return NULL;
19355 }
19356
19357
19358 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19359 PyObject *resultobj;
19360 int arg1 = (int) wxDateTime::Inv_Year ;
19361 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19362 bool result;
19363 PyObject * obj0 = 0 ;
19364 PyObject * obj1 = 0 ;
19365 char *kwnames[] = {
19366 (char *) "year",(char *) "cal", NULL
19367 };
19368
19369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19370 if (obj0) {
19371 {
19372 arg1 = (int)(SWIG_As_int(obj0));
19373 if (SWIG_arg_fail(1)) SWIG_fail;
19374 }
19375 }
19376 if (obj1) {
19377 {
19378 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19379 if (SWIG_arg_fail(2)) SWIG_fail;
19380 }
19381 }
19382 {
19383 PyThreadState* __tstate = wxPyBeginAllowThreads();
19384 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19385
19386 wxPyEndAllowThreads(__tstate);
19387 if (PyErr_Occurred()) SWIG_fail;
19388 }
19389 {
19390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19391 }
19392 return resultobj;
19393 fail:
19394 return NULL;
19395 }
19396
19397
19398 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19399 PyObject *resultobj;
19400 int arg1 = (int) wxDateTime::Inv_Year ;
19401 int result;
19402 PyObject * obj0 = 0 ;
19403 char *kwnames[] = {
19404 (char *) "year", NULL
19405 };
19406
19407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19408 if (obj0) {
19409 {
19410 arg1 = (int)(SWIG_As_int(obj0));
19411 if (SWIG_arg_fail(1)) SWIG_fail;
19412 }
19413 }
19414 {
19415 PyThreadState* __tstate = wxPyBeginAllowThreads();
19416 result = (int)wxDateTime::GetCentury(arg1);
19417
19418 wxPyEndAllowThreads(__tstate);
19419 if (PyErr_Occurred()) SWIG_fail;
19420 }
19421 {
19422 resultobj = SWIG_From_int((int)(result));
19423 }
19424 return resultobj;
19425 fail:
19426 return NULL;
19427 }
19428
19429
19430 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19431 PyObject *resultobj;
19432 int arg1 ;
19433 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19434 int result;
19435 PyObject * obj0 = 0 ;
19436 PyObject * obj1 = 0 ;
19437 char *kwnames[] = {
19438 (char *) "year",(char *) "cal", NULL
19439 };
19440
19441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19442 {
19443 arg1 = (int)(SWIG_As_int(obj0));
19444 if (SWIG_arg_fail(1)) SWIG_fail;
19445 }
19446 if (obj1) {
19447 {
19448 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19449 if (SWIG_arg_fail(2)) SWIG_fail;
19450 }
19451 }
19452 {
19453 PyThreadState* __tstate = wxPyBeginAllowThreads();
19454 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19455
19456 wxPyEndAllowThreads(__tstate);
19457 if (PyErr_Occurred()) SWIG_fail;
19458 }
19459 {
19460 resultobj = SWIG_From_int((int)(result));
19461 }
19462 return resultobj;
19463 fail:
19464 return NULL;
19465 }
19466
19467
19468 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19469 PyObject *resultobj;
19470 wxDateTime::Month arg1 ;
19471 int arg2 = (int) wxDateTime::Inv_Year ;
19472 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19473 int result;
19474 PyObject * obj0 = 0 ;
19475 PyObject * obj1 = 0 ;
19476 PyObject * obj2 = 0 ;
19477 char *kwnames[] = {
19478 (char *) "month",(char *) "year",(char *) "cal", NULL
19479 };
19480
19481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19482 {
19483 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19484 if (SWIG_arg_fail(1)) SWIG_fail;
19485 }
19486 if (obj1) {
19487 {
19488 arg2 = (int)(SWIG_As_int(obj1));
19489 if (SWIG_arg_fail(2)) SWIG_fail;
19490 }
19491 }
19492 if (obj2) {
19493 {
19494 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19495 if (SWIG_arg_fail(3)) SWIG_fail;
19496 }
19497 }
19498 {
19499 PyThreadState* __tstate = wxPyBeginAllowThreads();
19500 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19501
19502 wxPyEndAllowThreads(__tstate);
19503 if (PyErr_Occurred()) SWIG_fail;
19504 }
19505 {
19506 resultobj = SWIG_From_int((int)(result));
19507 }
19508 return resultobj;
19509 fail:
19510 return NULL;
19511 }
19512
19513
19514 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19515 PyObject *resultobj;
19516 wxDateTime::Month arg1 ;
19517 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19518 wxString result;
19519 PyObject * obj0 = 0 ;
19520 PyObject * obj1 = 0 ;
19521 char *kwnames[] = {
19522 (char *) "month",(char *) "flags", NULL
19523 };
19524
19525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19526 {
19527 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19528 if (SWIG_arg_fail(1)) SWIG_fail;
19529 }
19530 if (obj1) {
19531 {
19532 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19533 if (SWIG_arg_fail(2)) SWIG_fail;
19534 }
19535 }
19536 {
19537 PyThreadState* __tstate = wxPyBeginAllowThreads();
19538 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19539
19540 wxPyEndAllowThreads(__tstate);
19541 if (PyErr_Occurred()) SWIG_fail;
19542 }
19543 {
19544 #if wxUSE_UNICODE
19545 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19546 #else
19547 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19548 #endif
19549 }
19550 return resultobj;
19551 fail:
19552 return NULL;
19553 }
19554
19555
19556 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19557 PyObject *resultobj;
19558 wxDateTime::WeekDay arg1 ;
19559 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19560 wxString result;
19561 PyObject * obj0 = 0 ;
19562 PyObject * obj1 = 0 ;
19563 char *kwnames[] = {
19564 (char *) "weekday",(char *) "flags", NULL
19565 };
19566
19567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19568 {
19569 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19570 if (SWIG_arg_fail(1)) SWIG_fail;
19571 }
19572 if (obj1) {
19573 {
19574 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19575 if (SWIG_arg_fail(2)) SWIG_fail;
19576 }
19577 }
19578 {
19579 PyThreadState* __tstate = wxPyBeginAllowThreads();
19580 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19581
19582 wxPyEndAllowThreads(__tstate);
19583 if (PyErr_Occurred()) SWIG_fail;
19584 }
19585 {
19586 #if wxUSE_UNICODE
19587 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19588 #else
19589 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19590 #endif
19591 }
19592 return resultobj;
19593 fail:
19594 return NULL;
19595 }
19596
19597
19598 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19599 PyObject *resultobj;
19600 PyObject *result;
19601 char *kwnames[] = {
19602 NULL
19603 };
19604
19605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19606 {
19607 PyThreadState* __tstate = wxPyBeginAllowThreads();
19608 result = (PyObject *)DateTime_GetAmPmStrings();
19609
19610 wxPyEndAllowThreads(__tstate);
19611 if (PyErr_Occurred()) SWIG_fail;
19612 }
19613 resultobj = result;
19614 return resultobj;
19615 fail:
19616 return NULL;
19617 }
19618
19619
19620 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19621 PyObject *resultobj;
19622 int arg1 = (int) wxDateTime::Inv_Year ;
19623 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19624 bool result;
19625 PyObject * obj0 = 0 ;
19626 PyObject * obj1 = 0 ;
19627 char *kwnames[] = {
19628 (char *) "year",(char *) "country", NULL
19629 };
19630
19631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19632 if (obj0) {
19633 {
19634 arg1 = (int)(SWIG_As_int(obj0));
19635 if (SWIG_arg_fail(1)) SWIG_fail;
19636 }
19637 }
19638 if (obj1) {
19639 {
19640 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19641 if (SWIG_arg_fail(2)) SWIG_fail;
19642 }
19643 }
19644 {
19645 PyThreadState* __tstate = wxPyBeginAllowThreads();
19646 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19647
19648 wxPyEndAllowThreads(__tstate);
19649 if (PyErr_Occurred()) SWIG_fail;
19650 }
19651 {
19652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19653 }
19654 return resultobj;
19655 fail:
19656 return NULL;
19657 }
19658
19659
19660 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19661 PyObject *resultobj;
19662 int arg1 = (int) wxDateTime::Inv_Year ;
19663 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19664 wxDateTime result;
19665 PyObject * obj0 = 0 ;
19666 PyObject * obj1 = 0 ;
19667 char *kwnames[] = {
19668 (char *) "year",(char *) "country", NULL
19669 };
19670
19671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19672 if (obj0) {
19673 {
19674 arg1 = (int)(SWIG_As_int(obj0));
19675 if (SWIG_arg_fail(1)) SWIG_fail;
19676 }
19677 }
19678 if (obj1) {
19679 {
19680 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19681 if (SWIG_arg_fail(2)) SWIG_fail;
19682 }
19683 }
19684 {
19685 PyThreadState* __tstate = wxPyBeginAllowThreads();
19686 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19687
19688 wxPyEndAllowThreads(__tstate);
19689 if (PyErr_Occurred()) SWIG_fail;
19690 }
19691 {
19692 wxDateTime * resultptr;
19693 resultptr = new wxDateTime((wxDateTime &)(result));
19694 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19695 }
19696 return resultobj;
19697 fail:
19698 return NULL;
19699 }
19700
19701
19702 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19703 PyObject *resultobj;
19704 int arg1 = (int) wxDateTime::Inv_Year ;
19705 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19706 wxDateTime result;
19707 PyObject * obj0 = 0 ;
19708 PyObject * obj1 = 0 ;
19709 char *kwnames[] = {
19710 (char *) "year",(char *) "country", NULL
19711 };
19712
19713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19714 if (obj0) {
19715 {
19716 arg1 = (int)(SWIG_As_int(obj0));
19717 if (SWIG_arg_fail(1)) SWIG_fail;
19718 }
19719 }
19720 if (obj1) {
19721 {
19722 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19723 if (SWIG_arg_fail(2)) SWIG_fail;
19724 }
19725 }
19726 {
19727 PyThreadState* __tstate = wxPyBeginAllowThreads();
19728 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19729
19730 wxPyEndAllowThreads(__tstate);
19731 if (PyErr_Occurred()) SWIG_fail;
19732 }
19733 {
19734 wxDateTime * resultptr;
19735 resultptr = new wxDateTime((wxDateTime &)(result));
19736 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19737 }
19738 return resultobj;
19739 fail:
19740 return NULL;
19741 }
19742
19743
19744 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19745 PyObject *resultobj;
19746 wxDateTime result;
19747 char *kwnames[] = {
19748 NULL
19749 };
19750
19751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19752 {
19753 PyThreadState* __tstate = wxPyBeginAllowThreads();
19754 result = wxDateTime::Now();
19755
19756 wxPyEndAllowThreads(__tstate);
19757 if (PyErr_Occurred()) SWIG_fail;
19758 }
19759 {
19760 wxDateTime * resultptr;
19761 resultptr = new wxDateTime((wxDateTime &)(result));
19762 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19763 }
19764 return resultobj;
19765 fail:
19766 return NULL;
19767 }
19768
19769
19770 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19771 PyObject *resultobj;
19772 wxDateTime result;
19773 char *kwnames[] = {
19774 NULL
19775 };
19776
19777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19778 {
19779 PyThreadState* __tstate = wxPyBeginAllowThreads();
19780 result = wxDateTime::UNow();
19781
19782 wxPyEndAllowThreads(__tstate);
19783 if (PyErr_Occurred()) SWIG_fail;
19784 }
19785 {
19786 wxDateTime * resultptr;
19787 resultptr = new wxDateTime((wxDateTime &)(result));
19788 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19789 }
19790 return resultobj;
19791 fail:
19792 return NULL;
19793 }
19794
19795
19796 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19797 PyObject *resultobj;
19798 wxDateTime result;
19799 char *kwnames[] = {
19800 NULL
19801 };
19802
19803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19804 {
19805 PyThreadState* __tstate = wxPyBeginAllowThreads();
19806 result = wxDateTime::Today();
19807
19808 wxPyEndAllowThreads(__tstate);
19809 if (PyErr_Occurred()) SWIG_fail;
19810 }
19811 {
19812 wxDateTime * resultptr;
19813 resultptr = new wxDateTime((wxDateTime &)(result));
19814 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19815 }
19816 return resultobj;
19817 fail:
19818 return NULL;
19819 }
19820
19821
19822 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19823 PyObject *resultobj;
19824 wxDateTime *result;
19825 char *kwnames[] = {
19826 NULL
19827 };
19828
19829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19830 {
19831 PyThreadState* __tstate = wxPyBeginAllowThreads();
19832 result = (wxDateTime *)new wxDateTime();
19833
19834 wxPyEndAllowThreads(__tstate);
19835 if (PyErr_Occurred()) SWIG_fail;
19836 }
19837 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19838 return resultobj;
19839 fail:
19840 return NULL;
19841 }
19842
19843
19844 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19845 PyObject *resultobj;
19846 time_t arg1 ;
19847 wxDateTime *result;
19848 PyObject * obj0 = 0 ;
19849 char *kwnames[] = {
19850 (char *) "timet", NULL
19851 };
19852
19853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19854 {
19855 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19856 if (SWIG_arg_fail(1)) SWIG_fail;
19857 }
19858 {
19859 PyThreadState* __tstate = wxPyBeginAllowThreads();
19860 result = (wxDateTime *)new wxDateTime(arg1);
19861
19862 wxPyEndAllowThreads(__tstate);
19863 if (PyErr_Occurred()) SWIG_fail;
19864 }
19865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19866 return resultobj;
19867 fail:
19868 return NULL;
19869 }
19870
19871
19872 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19873 PyObject *resultobj;
19874 double arg1 ;
19875 wxDateTime *result;
19876 PyObject * obj0 = 0 ;
19877 char *kwnames[] = {
19878 (char *) "jdn", NULL
19879 };
19880
19881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19882 {
19883 arg1 = (double)(SWIG_As_double(obj0));
19884 if (SWIG_arg_fail(1)) SWIG_fail;
19885 }
19886 {
19887 PyThreadState* __tstate = wxPyBeginAllowThreads();
19888 result = (wxDateTime *)new wxDateTime(arg1);
19889
19890 wxPyEndAllowThreads(__tstate);
19891 if (PyErr_Occurred()) SWIG_fail;
19892 }
19893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19894 return resultobj;
19895 fail:
19896 return NULL;
19897 }
19898
19899
19900 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19901 PyObject *resultobj;
19902 int arg1 ;
19903 int arg2 = (int) 0 ;
19904 int arg3 = (int) 0 ;
19905 int arg4 = (int) 0 ;
19906 wxDateTime *result;
19907 PyObject * obj0 = 0 ;
19908 PyObject * obj1 = 0 ;
19909 PyObject * obj2 = 0 ;
19910 PyObject * obj3 = 0 ;
19911 char *kwnames[] = {
19912 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19913 };
19914
19915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19916 {
19917 arg1 = (int)(SWIG_As_int(obj0));
19918 if (SWIG_arg_fail(1)) SWIG_fail;
19919 }
19920 if (obj1) {
19921 {
19922 arg2 = (int)(SWIG_As_int(obj1));
19923 if (SWIG_arg_fail(2)) SWIG_fail;
19924 }
19925 }
19926 if (obj2) {
19927 {
19928 arg3 = (int)(SWIG_As_int(obj2));
19929 if (SWIG_arg_fail(3)) SWIG_fail;
19930 }
19931 }
19932 if (obj3) {
19933 {
19934 arg4 = (int)(SWIG_As_int(obj3));
19935 if (SWIG_arg_fail(4)) SWIG_fail;
19936 }
19937 }
19938 {
19939 PyThreadState* __tstate = wxPyBeginAllowThreads();
19940 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19941
19942 wxPyEndAllowThreads(__tstate);
19943 if (PyErr_Occurred()) SWIG_fail;
19944 }
19945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19946 return resultobj;
19947 fail:
19948 return NULL;
19949 }
19950
19951
19952 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19953 PyObject *resultobj;
19954 int arg1 ;
19955 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19956 int arg3 = (int) wxDateTime::Inv_Year ;
19957 int arg4 = (int) 0 ;
19958 int arg5 = (int) 0 ;
19959 int arg6 = (int) 0 ;
19960 int arg7 = (int) 0 ;
19961 wxDateTime *result;
19962 PyObject * obj0 = 0 ;
19963 PyObject * obj1 = 0 ;
19964 PyObject * obj2 = 0 ;
19965 PyObject * obj3 = 0 ;
19966 PyObject * obj4 = 0 ;
19967 PyObject * obj5 = 0 ;
19968 PyObject * obj6 = 0 ;
19969 char *kwnames[] = {
19970 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19971 };
19972
19973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19974 {
19975 arg1 = (int)(SWIG_As_int(obj0));
19976 if (SWIG_arg_fail(1)) SWIG_fail;
19977 }
19978 if (obj1) {
19979 {
19980 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19981 if (SWIG_arg_fail(2)) SWIG_fail;
19982 }
19983 }
19984 if (obj2) {
19985 {
19986 arg3 = (int)(SWIG_As_int(obj2));
19987 if (SWIG_arg_fail(3)) SWIG_fail;
19988 }
19989 }
19990 if (obj3) {
19991 {
19992 arg4 = (int)(SWIG_As_int(obj3));
19993 if (SWIG_arg_fail(4)) SWIG_fail;
19994 }
19995 }
19996 if (obj4) {
19997 {
19998 arg5 = (int)(SWIG_As_int(obj4));
19999 if (SWIG_arg_fail(5)) SWIG_fail;
20000 }
20001 }
20002 if (obj5) {
20003 {
20004 arg6 = (int)(SWIG_As_int(obj5));
20005 if (SWIG_arg_fail(6)) SWIG_fail;
20006 }
20007 }
20008 if (obj6) {
20009 {
20010 arg7 = (int)(SWIG_As_int(obj6));
20011 if (SWIG_arg_fail(7)) SWIG_fail;
20012 }
20013 }
20014 {
20015 PyThreadState* __tstate = wxPyBeginAllowThreads();
20016 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
20017
20018 wxPyEndAllowThreads(__tstate);
20019 if (PyErr_Occurred()) SWIG_fail;
20020 }
20021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20022 return resultobj;
20023 fail:
20024 return NULL;
20025 }
20026
20027
20028 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20029 PyObject *resultobj;
20030 wxDateTime *arg1 = (wxDateTime *) 0 ;
20031 PyObject * obj0 = 0 ;
20032 char *kwnames[] = {
20033 (char *) "self", NULL
20034 };
20035
20036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
20037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20038 if (SWIG_arg_fail(1)) SWIG_fail;
20039 {
20040 PyThreadState* __tstate = wxPyBeginAllowThreads();
20041 delete arg1;
20042
20043 wxPyEndAllowThreads(__tstate);
20044 if (PyErr_Occurred()) SWIG_fail;
20045 }
20046 Py_INCREF(Py_None); resultobj = Py_None;
20047 return resultobj;
20048 fail:
20049 return NULL;
20050 }
20051
20052
20053 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
20054 PyObject *resultobj;
20055 wxDateTime *arg1 = (wxDateTime *) 0 ;
20056 wxDateTime *result;
20057 PyObject * obj0 = 0 ;
20058 char *kwnames[] = {
20059 (char *) "self", NULL
20060 };
20061
20062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
20067 {
20068 wxDateTime &_result_ref = (arg1)->SetToCurrent();
20069 result = (wxDateTime *) &_result_ref;
20070 }
20071
20072 wxPyEndAllowThreads(__tstate);
20073 if (PyErr_Occurred()) SWIG_fail;
20074 }
20075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20076 return resultobj;
20077 fail:
20078 return NULL;
20079 }
20080
20081
20082 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
20083 PyObject *resultobj;
20084 wxDateTime *arg1 = (wxDateTime *) 0 ;
20085 time_t arg2 ;
20086 wxDateTime *result;
20087 PyObject * obj0 = 0 ;
20088 PyObject * obj1 = 0 ;
20089 char *kwnames[] = {
20090 (char *) "self",(char *) "timet", NULL
20091 };
20092
20093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
20094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20095 if (SWIG_arg_fail(1)) SWIG_fail;
20096 {
20097 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
20098 if (SWIG_arg_fail(2)) SWIG_fail;
20099 }
20100 {
20101 PyThreadState* __tstate = wxPyBeginAllowThreads();
20102 {
20103 wxDateTime &_result_ref = (arg1)->Set(arg2);
20104 result = (wxDateTime *) &_result_ref;
20105 }
20106
20107 wxPyEndAllowThreads(__tstate);
20108 if (PyErr_Occurred()) SWIG_fail;
20109 }
20110 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20111 return resultobj;
20112 fail:
20113 return NULL;
20114 }
20115
20116
20117 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20118 PyObject *resultobj;
20119 wxDateTime *arg1 = (wxDateTime *) 0 ;
20120 double arg2 ;
20121 wxDateTime *result;
20122 PyObject * obj0 = 0 ;
20123 PyObject * obj1 = 0 ;
20124 char *kwnames[] = {
20125 (char *) "self",(char *) "jdn", NULL
20126 };
20127
20128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
20129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20130 if (SWIG_arg_fail(1)) SWIG_fail;
20131 {
20132 arg2 = (double)(SWIG_As_double(obj1));
20133 if (SWIG_arg_fail(2)) SWIG_fail;
20134 }
20135 {
20136 PyThreadState* __tstate = wxPyBeginAllowThreads();
20137 {
20138 wxDateTime &_result_ref = (arg1)->Set(arg2);
20139 result = (wxDateTime *) &_result_ref;
20140 }
20141
20142 wxPyEndAllowThreads(__tstate);
20143 if (PyErr_Occurred()) SWIG_fail;
20144 }
20145 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20146 return resultobj;
20147 fail:
20148 return NULL;
20149 }
20150
20151
20152 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20153 PyObject *resultobj;
20154 wxDateTime *arg1 = (wxDateTime *) 0 ;
20155 int arg2 ;
20156 int arg3 = (int) 0 ;
20157 int arg4 = (int) 0 ;
20158 int arg5 = (int) 0 ;
20159 wxDateTime *result;
20160 PyObject * obj0 = 0 ;
20161 PyObject * obj1 = 0 ;
20162 PyObject * obj2 = 0 ;
20163 PyObject * obj3 = 0 ;
20164 PyObject * obj4 = 0 ;
20165 char *kwnames[] = {
20166 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20167 };
20168
20169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20171 if (SWIG_arg_fail(1)) SWIG_fail;
20172 {
20173 arg2 = (int)(SWIG_As_int(obj1));
20174 if (SWIG_arg_fail(2)) SWIG_fail;
20175 }
20176 if (obj2) {
20177 {
20178 arg3 = (int)(SWIG_As_int(obj2));
20179 if (SWIG_arg_fail(3)) SWIG_fail;
20180 }
20181 }
20182 if (obj3) {
20183 {
20184 arg4 = (int)(SWIG_As_int(obj3));
20185 if (SWIG_arg_fail(4)) SWIG_fail;
20186 }
20187 }
20188 if (obj4) {
20189 {
20190 arg5 = (int)(SWIG_As_int(obj4));
20191 if (SWIG_arg_fail(5)) SWIG_fail;
20192 }
20193 }
20194 {
20195 PyThreadState* __tstate = wxPyBeginAllowThreads();
20196 {
20197 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20198 result = (wxDateTime *) &_result_ref;
20199 }
20200
20201 wxPyEndAllowThreads(__tstate);
20202 if (PyErr_Occurred()) SWIG_fail;
20203 }
20204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20205 return resultobj;
20206 fail:
20207 return NULL;
20208 }
20209
20210
20211 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20212 PyObject *resultobj;
20213 wxDateTime *arg1 = (wxDateTime *) 0 ;
20214 int arg2 ;
20215 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20216 int arg4 = (int) wxDateTime::Inv_Year ;
20217 int arg5 = (int) 0 ;
20218 int arg6 = (int) 0 ;
20219 int arg7 = (int) 0 ;
20220 int arg8 = (int) 0 ;
20221 wxDateTime *result;
20222 PyObject * obj0 = 0 ;
20223 PyObject * obj1 = 0 ;
20224 PyObject * obj2 = 0 ;
20225 PyObject * obj3 = 0 ;
20226 PyObject * obj4 = 0 ;
20227 PyObject * obj5 = 0 ;
20228 PyObject * obj6 = 0 ;
20229 PyObject * obj7 = 0 ;
20230 char *kwnames[] = {
20231 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20232 };
20233
20234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20236 if (SWIG_arg_fail(1)) SWIG_fail;
20237 {
20238 arg2 = (int)(SWIG_As_int(obj1));
20239 if (SWIG_arg_fail(2)) SWIG_fail;
20240 }
20241 if (obj2) {
20242 {
20243 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20244 if (SWIG_arg_fail(3)) SWIG_fail;
20245 }
20246 }
20247 if (obj3) {
20248 {
20249 arg4 = (int)(SWIG_As_int(obj3));
20250 if (SWIG_arg_fail(4)) SWIG_fail;
20251 }
20252 }
20253 if (obj4) {
20254 {
20255 arg5 = (int)(SWIG_As_int(obj4));
20256 if (SWIG_arg_fail(5)) SWIG_fail;
20257 }
20258 }
20259 if (obj5) {
20260 {
20261 arg6 = (int)(SWIG_As_int(obj5));
20262 if (SWIG_arg_fail(6)) SWIG_fail;
20263 }
20264 }
20265 if (obj6) {
20266 {
20267 arg7 = (int)(SWIG_As_int(obj6));
20268 if (SWIG_arg_fail(7)) SWIG_fail;
20269 }
20270 }
20271 if (obj7) {
20272 {
20273 arg8 = (int)(SWIG_As_int(obj7));
20274 if (SWIG_arg_fail(8)) SWIG_fail;
20275 }
20276 }
20277 {
20278 PyThreadState* __tstate = wxPyBeginAllowThreads();
20279 {
20280 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20281 result = (wxDateTime *) &_result_ref;
20282 }
20283
20284 wxPyEndAllowThreads(__tstate);
20285 if (PyErr_Occurred()) SWIG_fail;
20286 }
20287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20288 return resultobj;
20289 fail:
20290 return NULL;
20291 }
20292
20293
20294 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20295 PyObject *resultobj;
20296 wxDateTime *arg1 = (wxDateTime *) 0 ;
20297 wxDateTime *result;
20298 PyObject * obj0 = 0 ;
20299 char *kwnames[] = {
20300 (char *) "self", NULL
20301 };
20302
20303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20305 if (SWIG_arg_fail(1)) SWIG_fail;
20306 {
20307 PyThreadState* __tstate = wxPyBeginAllowThreads();
20308 {
20309 wxDateTime &_result_ref = (arg1)->ResetTime();
20310 result = (wxDateTime *) &_result_ref;
20311 }
20312
20313 wxPyEndAllowThreads(__tstate);
20314 if (PyErr_Occurred()) SWIG_fail;
20315 }
20316 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20317 return resultobj;
20318 fail:
20319 return NULL;
20320 }
20321
20322
20323 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20324 PyObject *resultobj;
20325 wxDateTime *arg1 = (wxDateTime *) 0 ;
20326 int arg2 ;
20327 wxDateTime *result;
20328 PyObject * obj0 = 0 ;
20329 PyObject * obj1 = 0 ;
20330 char *kwnames[] = {
20331 (char *) "self",(char *) "year", NULL
20332 };
20333
20334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20336 if (SWIG_arg_fail(1)) SWIG_fail;
20337 {
20338 arg2 = (int)(SWIG_As_int(obj1));
20339 if (SWIG_arg_fail(2)) SWIG_fail;
20340 }
20341 {
20342 PyThreadState* __tstate = wxPyBeginAllowThreads();
20343 {
20344 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20345 result = (wxDateTime *) &_result_ref;
20346 }
20347
20348 wxPyEndAllowThreads(__tstate);
20349 if (PyErr_Occurred()) SWIG_fail;
20350 }
20351 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20352 return resultobj;
20353 fail:
20354 return NULL;
20355 }
20356
20357
20358 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20359 PyObject *resultobj;
20360 wxDateTime *arg1 = (wxDateTime *) 0 ;
20361 wxDateTime::Month arg2 ;
20362 wxDateTime *result;
20363 PyObject * obj0 = 0 ;
20364 PyObject * obj1 = 0 ;
20365 char *kwnames[] = {
20366 (char *) "self",(char *) "month", NULL
20367 };
20368
20369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20371 if (SWIG_arg_fail(1)) SWIG_fail;
20372 {
20373 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20374 if (SWIG_arg_fail(2)) SWIG_fail;
20375 }
20376 {
20377 PyThreadState* __tstate = wxPyBeginAllowThreads();
20378 {
20379 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20380 result = (wxDateTime *) &_result_ref;
20381 }
20382
20383 wxPyEndAllowThreads(__tstate);
20384 if (PyErr_Occurred()) SWIG_fail;
20385 }
20386 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20387 return resultobj;
20388 fail:
20389 return NULL;
20390 }
20391
20392
20393 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20394 PyObject *resultobj;
20395 wxDateTime *arg1 = (wxDateTime *) 0 ;
20396 int arg2 ;
20397 wxDateTime *result;
20398 PyObject * obj0 = 0 ;
20399 PyObject * obj1 = 0 ;
20400 char *kwnames[] = {
20401 (char *) "self",(char *) "day", NULL
20402 };
20403
20404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20406 if (SWIG_arg_fail(1)) SWIG_fail;
20407 {
20408 arg2 = (int)(SWIG_As_int(obj1));
20409 if (SWIG_arg_fail(2)) SWIG_fail;
20410 }
20411 {
20412 PyThreadState* __tstate = wxPyBeginAllowThreads();
20413 {
20414 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20415 result = (wxDateTime *) &_result_ref;
20416 }
20417
20418 wxPyEndAllowThreads(__tstate);
20419 if (PyErr_Occurred()) SWIG_fail;
20420 }
20421 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20422 return resultobj;
20423 fail:
20424 return NULL;
20425 }
20426
20427
20428 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20429 PyObject *resultobj;
20430 wxDateTime *arg1 = (wxDateTime *) 0 ;
20431 int arg2 ;
20432 wxDateTime *result;
20433 PyObject * obj0 = 0 ;
20434 PyObject * obj1 = 0 ;
20435 char *kwnames[] = {
20436 (char *) "self",(char *) "hour", NULL
20437 };
20438
20439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20441 if (SWIG_arg_fail(1)) SWIG_fail;
20442 {
20443 arg2 = (int)(SWIG_As_int(obj1));
20444 if (SWIG_arg_fail(2)) SWIG_fail;
20445 }
20446 {
20447 PyThreadState* __tstate = wxPyBeginAllowThreads();
20448 {
20449 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20450 result = (wxDateTime *) &_result_ref;
20451 }
20452
20453 wxPyEndAllowThreads(__tstate);
20454 if (PyErr_Occurred()) SWIG_fail;
20455 }
20456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20457 return resultobj;
20458 fail:
20459 return NULL;
20460 }
20461
20462
20463 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20464 PyObject *resultobj;
20465 wxDateTime *arg1 = (wxDateTime *) 0 ;
20466 int arg2 ;
20467 wxDateTime *result;
20468 PyObject * obj0 = 0 ;
20469 PyObject * obj1 = 0 ;
20470 char *kwnames[] = {
20471 (char *) "self",(char *) "minute", NULL
20472 };
20473
20474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20476 if (SWIG_arg_fail(1)) SWIG_fail;
20477 {
20478 arg2 = (int)(SWIG_As_int(obj1));
20479 if (SWIG_arg_fail(2)) SWIG_fail;
20480 }
20481 {
20482 PyThreadState* __tstate = wxPyBeginAllowThreads();
20483 {
20484 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20485 result = (wxDateTime *) &_result_ref;
20486 }
20487
20488 wxPyEndAllowThreads(__tstate);
20489 if (PyErr_Occurred()) SWIG_fail;
20490 }
20491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20492 return resultobj;
20493 fail:
20494 return NULL;
20495 }
20496
20497
20498 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20499 PyObject *resultobj;
20500 wxDateTime *arg1 = (wxDateTime *) 0 ;
20501 int arg2 ;
20502 wxDateTime *result;
20503 PyObject * obj0 = 0 ;
20504 PyObject * obj1 = 0 ;
20505 char *kwnames[] = {
20506 (char *) "self",(char *) "second", NULL
20507 };
20508
20509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20511 if (SWIG_arg_fail(1)) SWIG_fail;
20512 {
20513 arg2 = (int)(SWIG_As_int(obj1));
20514 if (SWIG_arg_fail(2)) SWIG_fail;
20515 }
20516 {
20517 PyThreadState* __tstate = wxPyBeginAllowThreads();
20518 {
20519 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20520 result = (wxDateTime *) &_result_ref;
20521 }
20522
20523 wxPyEndAllowThreads(__tstate);
20524 if (PyErr_Occurred()) SWIG_fail;
20525 }
20526 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20527 return resultobj;
20528 fail:
20529 return NULL;
20530 }
20531
20532
20533 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20534 PyObject *resultobj;
20535 wxDateTime *arg1 = (wxDateTime *) 0 ;
20536 int arg2 ;
20537 wxDateTime *result;
20538 PyObject * obj0 = 0 ;
20539 PyObject * obj1 = 0 ;
20540 char *kwnames[] = {
20541 (char *) "self",(char *) "millisecond", NULL
20542 };
20543
20544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20546 if (SWIG_arg_fail(1)) SWIG_fail;
20547 {
20548 arg2 = (int)(SWIG_As_int(obj1));
20549 if (SWIG_arg_fail(2)) SWIG_fail;
20550 }
20551 {
20552 PyThreadState* __tstate = wxPyBeginAllowThreads();
20553 {
20554 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20555 result = (wxDateTime *) &_result_ref;
20556 }
20557
20558 wxPyEndAllowThreads(__tstate);
20559 if (PyErr_Occurred()) SWIG_fail;
20560 }
20561 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20562 return resultobj;
20563 fail:
20564 return NULL;
20565 }
20566
20567
20568 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20569 PyObject *resultobj;
20570 wxDateTime *arg1 = (wxDateTime *) 0 ;
20571 wxDateTime::WeekDay arg2 ;
20572 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20573 wxDateTime *result;
20574 PyObject * obj0 = 0 ;
20575 PyObject * obj1 = 0 ;
20576 PyObject * obj2 = 0 ;
20577 char *kwnames[] = {
20578 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20579 };
20580
20581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20583 if (SWIG_arg_fail(1)) SWIG_fail;
20584 {
20585 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20586 if (SWIG_arg_fail(2)) SWIG_fail;
20587 }
20588 if (obj2) {
20589 {
20590 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20591 if (SWIG_arg_fail(3)) SWIG_fail;
20592 }
20593 }
20594 {
20595 PyThreadState* __tstate = wxPyBeginAllowThreads();
20596 {
20597 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20598 result = (wxDateTime *) &_result_ref;
20599 }
20600
20601 wxPyEndAllowThreads(__tstate);
20602 if (PyErr_Occurred()) SWIG_fail;
20603 }
20604 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20605 return resultobj;
20606 fail:
20607 return NULL;
20608 }
20609
20610
20611 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20612 PyObject *resultobj;
20613 wxDateTime *arg1 = (wxDateTime *) 0 ;
20614 wxDateTime::WeekDay arg2 ;
20615 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20616 wxDateTime result;
20617 PyObject * obj0 = 0 ;
20618 PyObject * obj1 = 0 ;
20619 PyObject * obj2 = 0 ;
20620 char *kwnames[] = {
20621 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20622 };
20623
20624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20626 if (SWIG_arg_fail(1)) SWIG_fail;
20627 {
20628 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20629 if (SWIG_arg_fail(2)) SWIG_fail;
20630 }
20631 if (obj2) {
20632 {
20633 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20634 if (SWIG_arg_fail(3)) SWIG_fail;
20635 }
20636 }
20637 {
20638 PyThreadState* __tstate = wxPyBeginAllowThreads();
20639 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20640
20641 wxPyEndAllowThreads(__tstate);
20642 if (PyErr_Occurred()) SWIG_fail;
20643 }
20644 {
20645 wxDateTime * resultptr;
20646 resultptr = new wxDateTime((wxDateTime &)(result));
20647 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20648 }
20649 return resultobj;
20650 fail:
20651 return NULL;
20652 }
20653
20654
20655 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20656 PyObject *resultobj;
20657 wxDateTime *arg1 = (wxDateTime *) 0 ;
20658 wxDateTime::WeekDay arg2 ;
20659 wxDateTime *result;
20660 PyObject * obj0 = 0 ;
20661 PyObject * obj1 = 0 ;
20662 char *kwnames[] = {
20663 (char *) "self",(char *) "weekday", NULL
20664 };
20665
20666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20668 if (SWIG_arg_fail(1)) SWIG_fail;
20669 {
20670 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20671 if (SWIG_arg_fail(2)) SWIG_fail;
20672 }
20673 {
20674 PyThreadState* __tstate = wxPyBeginAllowThreads();
20675 {
20676 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20677 result = (wxDateTime *) &_result_ref;
20678 }
20679
20680 wxPyEndAllowThreads(__tstate);
20681 if (PyErr_Occurred()) SWIG_fail;
20682 }
20683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20684 return resultobj;
20685 fail:
20686 return NULL;
20687 }
20688
20689
20690 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20691 PyObject *resultobj;
20692 wxDateTime *arg1 = (wxDateTime *) 0 ;
20693 wxDateTime::WeekDay arg2 ;
20694 wxDateTime result;
20695 PyObject * obj0 = 0 ;
20696 PyObject * obj1 = 0 ;
20697 char *kwnames[] = {
20698 (char *) "self",(char *) "weekday", NULL
20699 };
20700
20701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20703 if (SWIG_arg_fail(1)) SWIG_fail;
20704 {
20705 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20706 if (SWIG_arg_fail(2)) SWIG_fail;
20707 }
20708 {
20709 PyThreadState* __tstate = wxPyBeginAllowThreads();
20710 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20711
20712 wxPyEndAllowThreads(__tstate);
20713 if (PyErr_Occurred()) SWIG_fail;
20714 }
20715 {
20716 wxDateTime * resultptr;
20717 resultptr = new wxDateTime((wxDateTime &)(result));
20718 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20719 }
20720 return resultobj;
20721 fail:
20722 return NULL;
20723 }
20724
20725
20726 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20727 PyObject *resultobj;
20728 wxDateTime *arg1 = (wxDateTime *) 0 ;
20729 wxDateTime::WeekDay arg2 ;
20730 wxDateTime *result;
20731 PyObject * obj0 = 0 ;
20732 PyObject * obj1 = 0 ;
20733 char *kwnames[] = {
20734 (char *) "self",(char *) "weekday", NULL
20735 };
20736
20737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20739 if (SWIG_arg_fail(1)) SWIG_fail;
20740 {
20741 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20742 if (SWIG_arg_fail(2)) SWIG_fail;
20743 }
20744 {
20745 PyThreadState* __tstate = wxPyBeginAllowThreads();
20746 {
20747 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20748 result = (wxDateTime *) &_result_ref;
20749 }
20750
20751 wxPyEndAllowThreads(__tstate);
20752 if (PyErr_Occurred()) SWIG_fail;
20753 }
20754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20755 return resultobj;
20756 fail:
20757 return NULL;
20758 }
20759
20760
20761 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20762 PyObject *resultobj;
20763 wxDateTime *arg1 = (wxDateTime *) 0 ;
20764 wxDateTime::WeekDay arg2 ;
20765 wxDateTime result;
20766 PyObject * obj0 = 0 ;
20767 PyObject * obj1 = 0 ;
20768 char *kwnames[] = {
20769 (char *) "self",(char *) "weekday", NULL
20770 };
20771
20772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20774 if (SWIG_arg_fail(1)) SWIG_fail;
20775 {
20776 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20777 if (SWIG_arg_fail(2)) SWIG_fail;
20778 }
20779 {
20780 PyThreadState* __tstate = wxPyBeginAllowThreads();
20781 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20782
20783 wxPyEndAllowThreads(__tstate);
20784 if (PyErr_Occurred()) SWIG_fail;
20785 }
20786 {
20787 wxDateTime * resultptr;
20788 resultptr = new wxDateTime((wxDateTime &)(result));
20789 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20790 }
20791 return resultobj;
20792 fail:
20793 return NULL;
20794 }
20795
20796
20797 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20798 PyObject *resultobj;
20799 wxDateTime *arg1 = (wxDateTime *) 0 ;
20800 wxDateTime::WeekDay arg2 ;
20801 int arg3 = (int) 1 ;
20802 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20803 int arg5 = (int) wxDateTime::Inv_Year ;
20804 bool result;
20805 PyObject * obj0 = 0 ;
20806 PyObject * obj1 = 0 ;
20807 PyObject * obj2 = 0 ;
20808 PyObject * obj3 = 0 ;
20809 PyObject * obj4 = 0 ;
20810 char *kwnames[] = {
20811 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20812 };
20813
20814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20816 if (SWIG_arg_fail(1)) SWIG_fail;
20817 {
20818 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20819 if (SWIG_arg_fail(2)) SWIG_fail;
20820 }
20821 if (obj2) {
20822 {
20823 arg3 = (int)(SWIG_As_int(obj2));
20824 if (SWIG_arg_fail(3)) SWIG_fail;
20825 }
20826 }
20827 if (obj3) {
20828 {
20829 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20830 if (SWIG_arg_fail(4)) SWIG_fail;
20831 }
20832 }
20833 if (obj4) {
20834 {
20835 arg5 = (int)(SWIG_As_int(obj4));
20836 if (SWIG_arg_fail(5)) SWIG_fail;
20837 }
20838 }
20839 {
20840 PyThreadState* __tstate = wxPyBeginAllowThreads();
20841 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20842
20843 wxPyEndAllowThreads(__tstate);
20844 if (PyErr_Occurred()) SWIG_fail;
20845 }
20846 {
20847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20848 }
20849 return resultobj;
20850 fail:
20851 return NULL;
20852 }
20853
20854
20855 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20856 PyObject *resultobj;
20857 wxDateTime *arg1 = (wxDateTime *) 0 ;
20858 wxDateTime::WeekDay arg2 ;
20859 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20860 int arg4 = (int) wxDateTime::Inv_Year ;
20861 bool result;
20862 PyObject * obj0 = 0 ;
20863 PyObject * obj1 = 0 ;
20864 PyObject * obj2 = 0 ;
20865 PyObject * obj3 = 0 ;
20866 char *kwnames[] = {
20867 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20868 };
20869
20870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20872 if (SWIG_arg_fail(1)) SWIG_fail;
20873 {
20874 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20875 if (SWIG_arg_fail(2)) SWIG_fail;
20876 }
20877 if (obj2) {
20878 {
20879 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20880 if (SWIG_arg_fail(3)) SWIG_fail;
20881 }
20882 }
20883 if (obj3) {
20884 {
20885 arg4 = (int)(SWIG_As_int(obj3));
20886 if (SWIG_arg_fail(4)) SWIG_fail;
20887 }
20888 }
20889 {
20890 PyThreadState* __tstate = wxPyBeginAllowThreads();
20891 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20892
20893 wxPyEndAllowThreads(__tstate);
20894 if (PyErr_Occurred()) SWIG_fail;
20895 }
20896 {
20897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20898 }
20899 return resultobj;
20900 fail:
20901 return NULL;
20902 }
20903
20904
20905 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20906 PyObject *resultobj;
20907 wxDateTime *arg1 = (wxDateTime *) 0 ;
20908 wxDateTime::WeekDay arg2 ;
20909 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20910 int arg4 = (int) wxDateTime::Inv_Year ;
20911 wxDateTime result;
20912 PyObject * obj0 = 0 ;
20913 PyObject * obj1 = 0 ;
20914 PyObject * obj2 = 0 ;
20915 PyObject * obj3 = 0 ;
20916 char *kwnames[] = {
20917 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20918 };
20919
20920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20922 if (SWIG_arg_fail(1)) SWIG_fail;
20923 {
20924 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20925 if (SWIG_arg_fail(2)) SWIG_fail;
20926 }
20927 if (obj2) {
20928 {
20929 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20930 if (SWIG_arg_fail(3)) SWIG_fail;
20931 }
20932 }
20933 if (obj3) {
20934 {
20935 arg4 = (int)(SWIG_As_int(obj3));
20936 if (SWIG_arg_fail(4)) SWIG_fail;
20937 }
20938 }
20939 {
20940 PyThreadState* __tstate = wxPyBeginAllowThreads();
20941 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20942
20943 wxPyEndAllowThreads(__tstate);
20944 if (PyErr_Occurred()) SWIG_fail;
20945 }
20946 {
20947 wxDateTime * resultptr;
20948 resultptr = new wxDateTime((wxDateTime &)(result));
20949 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20950 }
20951 return resultobj;
20952 fail:
20953 return NULL;
20954 }
20955
20956
20957 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20958 PyObject *resultobj;
20959 wxDateTime *arg1 = (wxDateTime *) 0 ;
20960 int arg2 ;
20961 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20962 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20963 bool result;
20964 PyObject * obj0 = 0 ;
20965 PyObject * obj1 = 0 ;
20966 PyObject * obj2 = 0 ;
20967 PyObject * obj3 = 0 ;
20968 char *kwnames[] = {
20969 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20970 };
20971
20972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20974 if (SWIG_arg_fail(1)) SWIG_fail;
20975 {
20976 arg2 = (int)(SWIG_As_int(obj1));
20977 if (SWIG_arg_fail(2)) SWIG_fail;
20978 }
20979 if (obj2) {
20980 {
20981 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20982 if (SWIG_arg_fail(3)) SWIG_fail;
20983 }
20984 }
20985 if (obj3) {
20986 {
20987 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20988 if (SWIG_arg_fail(4)) SWIG_fail;
20989 }
20990 }
20991 {
20992 PyThreadState* __tstate = wxPyBeginAllowThreads();
20993 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20994
20995 wxPyEndAllowThreads(__tstate);
20996 if (PyErr_Occurred()) SWIG_fail;
20997 }
20998 {
20999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21000 }
21001 return resultobj;
21002 fail:
21003 return NULL;
21004 }
21005
21006
21007 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21008 PyObject *resultobj;
21009 wxDateTime *arg1 = (wxDateTime *) 0 ;
21010 int arg2 ;
21011 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21012 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21013 wxDateTime result;
21014 PyObject * obj0 = 0 ;
21015 PyObject * obj1 = 0 ;
21016 PyObject * obj2 = 0 ;
21017 PyObject * obj3 = 0 ;
21018 char *kwnames[] = {
21019 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
21020 };
21021
21022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21024 if (SWIG_arg_fail(1)) SWIG_fail;
21025 {
21026 arg2 = (int)(SWIG_As_int(obj1));
21027 if (SWIG_arg_fail(2)) SWIG_fail;
21028 }
21029 if (obj2) {
21030 {
21031 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
21032 if (SWIG_arg_fail(3)) SWIG_fail;
21033 }
21034 }
21035 if (obj3) {
21036 {
21037 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
21038 if (SWIG_arg_fail(4)) SWIG_fail;
21039 }
21040 }
21041 {
21042 PyThreadState* __tstate = wxPyBeginAllowThreads();
21043 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
21044
21045 wxPyEndAllowThreads(__tstate);
21046 if (PyErr_Occurred()) SWIG_fail;
21047 }
21048 {
21049 wxDateTime * resultptr;
21050 resultptr = new wxDateTime((wxDateTime &)(result));
21051 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21052 }
21053 return resultobj;
21054 fail:
21055 return NULL;
21056 }
21057
21058
21059 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21060 PyObject *resultobj;
21061 int arg1 ;
21062 int arg2 ;
21063 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21064 wxDateTime result;
21065 PyObject * obj0 = 0 ;
21066 PyObject * obj1 = 0 ;
21067 PyObject * obj2 = 0 ;
21068 char *kwnames[] = {
21069 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
21070 };
21071
21072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21073 {
21074 arg1 = (int)(SWIG_As_int(obj0));
21075 if (SWIG_arg_fail(1)) SWIG_fail;
21076 }
21077 {
21078 arg2 = (int)(SWIG_As_int(obj1));
21079 if (SWIG_arg_fail(2)) SWIG_fail;
21080 }
21081 if (obj2) {
21082 {
21083 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
21084 if (SWIG_arg_fail(3)) SWIG_fail;
21085 }
21086 }
21087 {
21088 PyThreadState* __tstate = wxPyBeginAllowThreads();
21089 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
21090
21091 wxPyEndAllowThreads(__tstate);
21092 if (PyErr_Occurred()) SWIG_fail;
21093 }
21094 {
21095 wxDateTime * resultptr;
21096 resultptr = new wxDateTime((wxDateTime &)(result));
21097 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21098 }
21099 return resultobj;
21100 fail:
21101 return NULL;
21102 }
21103
21104
21105 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21106 PyObject *resultobj;
21107 wxDateTime *arg1 = (wxDateTime *) 0 ;
21108 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21109 int arg3 = (int) wxDateTime::Inv_Year ;
21110 wxDateTime *result;
21111 PyObject * obj0 = 0 ;
21112 PyObject * obj1 = 0 ;
21113 PyObject * obj2 = 0 ;
21114 char *kwnames[] = {
21115 (char *) "self",(char *) "month",(char *) "year", NULL
21116 };
21117
21118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21120 if (SWIG_arg_fail(1)) SWIG_fail;
21121 if (obj1) {
21122 {
21123 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21124 if (SWIG_arg_fail(2)) SWIG_fail;
21125 }
21126 }
21127 if (obj2) {
21128 {
21129 arg3 = (int)(SWIG_As_int(obj2));
21130 if (SWIG_arg_fail(3)) SWIG_fail;
21131 }
21132 }
21133 {
21134 PyThreadState* __tstate = wxPyBeginAllowThreads();
21135 {
21136 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
21137 result = (wxDateTime *) &_result_ref;
21138 }
21139
21140 wxPyEndAllowThreads(__tstate);
21141 if (PyErr_Occurred()) SWIG_fail;
21142 }
21143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21144 return resultobj;
21145 fail:
21146 return NULL;
21147 }
21148
21149
21150 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21151 PyObject *resultobj;
21152 wxDateTime *arg1 = (wxDateTime *) 0 ;
21153 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21154 int arg3 = (int) wxDateTime::Inv_Year ;
21155 wxDateTime result;
21156 PyObject * obj0 = 0 ;
21157 PyObject * obj1 = 0 ;
21158 PyObject * obj2 = 0 ;
21159 char *kwnames[] = {
21160 (char *) "self",(char *) "month",(char *) "year", NULL
21161 };
21162
21163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21165 if (SWIG_arg_fail(1)) SWIG_fail;
21166 if (obj1) {
21167 {
21168 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21169 if (SWIG_arg_fail(2)) SWIG_fail;
21170 }
21171 }
21172 if (obj2) {
21173 {
21174 arg3 = (int)(SWIG_As_int(obj2));
21175 if (SWIG_arg_fail(3)) SWIG_fail;
21176 }
21177 }
21178 {
21179 PyThreadState* __tstate = wxPyBeginAllowThreads();
21180 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
21181
21182 wxPyEndAllowThreads(__tstate);
21183 if (PyErr_Occurred()) SWIG_fail;
21184 }
21185 {
21186 wxDateTime * resultptr;
21187 resultptr = new wxDateTime((wxDateTime &)(result));
21188 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21189 }
21190 return resultobj;
21191 fail:
21192 return NULL;
21193 }
21194
21195
21196 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21197 PyObject *resultobj;
21198 wxDateTime *arg1 = (wxDateTime *) 0 ;
21199 int arg2 ;
21200 wxDateTime *result;
21201 PyObject * obj0 = 0 ;
21202 PyObject * obj1 = 0 ;
21203 char *kwnames[] = {
21204 (char *) "self",(char *) "yday", NULL
21205 };
21206
21207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21209 if (SWIG_arg_fail(1)) SWIG_fail;
21210 {
21211 arg2 = (int)(SWIG_As_int(obj1));
21212 if (SWIG_arg_fail(2)) SWIG_fail;
21213 }
21214 {
21215 PyThreadState* __tstate = wxPyBeginAllowThreads();
21216 {
21217 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21218 result = (wxDateTime *) &_result_ref;
21219 }
21220
21221 wxPyEndAllowThreads(__tstate);
21222 if (PyErr_Occurred()) SWIG_fail;
21223 }
21224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21225 return resultobj;
21226 fail:
21227 return NULL;
21228 }
21229
21230
21231 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21232 PyObject *resultobj;
21233 wxDateTime *arg1 = (wxDateTime *) 0 ;
21234 int arg2 ;
21235 wxDateTime result;
21236 PyObject * obj0 = 0 ;
21237 PyObject * obj1 = 0 ;
21238 char *kwnames[] = {
21239 (char *) "self",(char *) "yday", NULL
21240 };
21241
21242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21244 if (SWIG_arg_fail(1)) SWIG_fail;
21245 {
21246 arg2 = (int)(SWIG_As_int(obj1));
21247 if (SWIG_arg_fail(2)) SWIG_fail;
21248 }
21249 {
21250 PyThreadState* __tstate = wxPyBeginAllowThreads();
21251 result = (arg1)->GetYearDay(arg2);
21252
21253 wxPyEndAllowThreads(__tstate);
21254 if (PyErr_Occurred()) SWIG_fail;
21255 }
21256 {
21257 wxDateTime * resultptr;
21258 resultptr = new wxDateTime((wxDateTime &)(result));
21259 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21260 }
21261 return resultobj;
21262 fail:
21263 return NULL;
21264 }
21265
21266
21267 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21268 PyObject *resultobj;
21269 wxDateTime *arg1 = (wxDateTime *) 0 ;
21270 double result;
21271 PyObject * obj0 = 0 ;
21272 char *kwnames[] = {
21273 (char *) "self", NULL
21274 };
21275
21276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21278 if (SWIG_arg_fail(1)) SWIG_fail;
21279 {
21280 PyThreadState* __tstate = wxPyBeginAllowThreads();
21281 result = (double)(arg1)->GetJulianDayNumber();
21282
21283 wxPyEndAllowThreads(__tstate);
21284 if (PyErr_Occurred()) SWIG_fail;
21285 }
21286 {
21287 resultobj = SWIG_From_double((double)(result));
21288 }
21289 return resultobj;
21290 fail:
21291 return NULL;
21292 }
21293
21294
21295 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21296 PyObject *resultobj;
21297 wxDateTime *arg1 = (wxDateTime *) 0 ;
21298 double result;
21299 PyObject * obj0 = 0 ;
21300 char *kwnames[] = {
21301 (char *) "self", NULL
21302 };
21303
21304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21306 if (SWIG_arg_fail(1)) SWIG_fail;
21307 {
21308 PyThreadState* __tstate = wxPyBeginAllowThreads();
21309 result = (double)(arg1)->GetJDN();
21310
21311 wxPyEndAllowThreads(__tstate);
21312 if (PyErr_Occurred()) SWIG_fail;
21313 }
21314 {
21315 resultobj = SWIG_From_double((double)(result));
21316 }
21317 return resultobj;
21318 fail:
21319 return NULL;
21320 }
21321
21322
21323 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21324 PyObject *resultobj;
21325 wxDateTime *arg1 = (wxDateTime *) 0 ;
21326 double result;
21327 PyObject * obj0 = 0 ;
21328 char *kwnames[] = {
21329 (char *) "self", NULL
21330 };
21331
21332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21334 if (SWIG_arg_fail(1)) SWIG_fail;
21335 {
21336 PyThreadState* __tstate = wxPyBeginAllowThreads();
21337 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21338
21339 wxPyEndAllowThreads(__tstate);
21340 if (PyErr_Occurred()) SWIG_fail;
21341 }
21342 {
21343 resultobj = SWIG_From_double((double)(result));
21344 }
21345 return resultobj;
21346 fail:
21347 return NULL;
21348 }
21349
21350
21351 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21352 PyObject *resultobj;
21353 wxDateTime *arg1 = (wxDateTime *) 0 ;
21354 double result;
21355 PyObject * obj0 = 0 ;
21356 char *kwnames[] = {
21357 (char *) "self", NULL
21358 };
21359
21360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21362 if (SWIG_arg_fail(1)) SWIG_fail;
21363 {
21364 PyThreadState* __tstate = wxPyBeginAllowThreads();
21365 result = (double)(arg1)->GetMJD();
21366
21367 wxPyEndAllowThreads(__tstate);
21368 if (PyErr_Occurred()) SWIG_fail;
21369 }
21370 {
21371 resultobj = SWIG_From_double((double)(result));
21372 }
21373 return resultobj;
21374 fail:
21375 return NULL;
21376 }
21377
21378
21379 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21380 PyObject *resultobj;
21381 wxDateTime *arg1 = (wxDateTime *) 0 ;
21382 double result;
21383 PyObject * obj0 = 0 ;
21384 char *kwnames[] = {
21385 (char *) "self", NULL
21386 };
21387
21388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21390 if (SWIG_arg_fail(1)) SWIG_fail;
21391 {
21392 PyThreadState* __tstate = wxPyBeginAllowThreads();
21393 result = (double)(arg1)->GetRataDie();
21394
21395 wxPyEndAllowThreads(__tstate);
21396 if (PyErr_Occurred()) SWIG_fail;
21397 }
21398 {
21399 resultobj = SWIG_From_double((double)(result));
21400 }
21401 return resultobj;
21402 fail:
21403 return NULL;
21404 }
21405
21406
21407 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21408 PyObject *resultobj;
21409 wxDateTime *arg1 = (wxDateTime *) 0 ;
21410 wxDateTime::TimeZone *arg2 = 0 ;
21411 bool arg3 = (bool) false ;
21412 wxDateTime result;
21413 bool temp2 = false ;
21414 PyObject * obj0 = 0 ;
21415 PyObject * obj1 = 0 ;
21416 PyObject * obj2 = 0 ;
21417 char *kwnames[] = {
21418 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21419 };
21420
21421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21423 if (SWIG_arg_fail(1)) SWIG_fail;
21424 {
21425 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21426 temp2 = true;
21427 }
21428 if (obj2) {
21429 {
21430 arg3 = (bool)(SWIG_As_bool(obj2));
21431 if (SWIG_arg_fail(3)) SWIG_fail;
21432 }
21433 }
21434 {
21435 PyThreadState* __tstate = wxPyBeginAllowThreads();
21436 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21437
21438 wxPyEndAllowThreads(__tstate);
21439 if (PyErr_Occurred()) SWIG_fail;
21440 }
21441 {
21442 wxDateTime * resultptr;
21443 resultptr = new wxDateTime((wxDateTime &)(result));
21444 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21445 }
21446 {
21447 if (temp2) delete arg2;
21448 }
21449 return resultobj;
21450 fail:
21451 {
21452 if (temp2) delete arg2;
21453 }
21454 return NULL;
21455 }
21456
21457
21458 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21459 PyObject *resultobj;
21460 wxDateTime *arg1 = (wxDateTime *) 0 ;
21461 wxDateTime::TimeZone *arg2 = 0 ;
21462 bool arg3 = (bool) false ;
21463 wxDateTime *result;
21464 bool temp2 = false ;
21465 PyObject * obj0 = 0 ;
21466 PyObject * obj1 = 0 ;
21467 PyObject * obj2 = 0 ;
21468 char *kwnames[] = {
21469 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21470 };
21471
21472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21474 if (SWIG_arg_fail(1)) SWIG_fail;
21475 {
21476 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21477 temp2 = true;
21478 }
21479 if (obj2) {
21480 {
21481 arg3 = (bool)(SWIG_As_bool(obj2));
21482 if (SWIG_arg_fail(3)) SWIG_fail;
21483 }
21484 }
21485 {
21486 PyThreadState* __tstate = wxPyBeginAllowThreads();
21487 {
21488 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21489 result = (wxDateTime *) &_result_ref;
21490 }
21491
21492 wxPyEndAllowThreads(__tstate);
21493 if (PyErr_Occurred()) SWIG_fail;
21494 }
21495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21496 {
21497 if (temp2) delete arg2;
21498 }
21499 return resultobj;
21500 fail:
21501 {
21502 if (temp2) delete arg2;
21503 }
21504 return NULL;
21505 }
21506
21507
21508 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21509 PyObject *resultobj;
21510 wxDateTime *arg1 = (wxDateTime *) 0 ;
21511 bool arg2 = (bool) false ;
21512 wxDateTime result;
21513 PyObject * obj0 = 0 ;
21514 PyObject * obj1 = 0 ;
21515 char *kwnames[] = {
21516 (char *) "self",(char *) "noDST", NULL
21517 };
21518
21519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21521 if (SWIG_arg_fail(1)) SWIG_fail;
21522 if (obj1) {
21523 {
21524 arg2 = (bool)(SWIG_As_bool(obj1));
21525 if (SWIG_arg_fail(2)) SWIG_fail;
21526 }
21527 }
21528 {
21529 PyThreadState* __tstate = wxPyBeginAllowThreads();
21530 result = (arg1)->ToGMT(arg2);
21531
21532 wxPyEndAllowThreads(__tstate);
21533 if (PyErr_Occurred()) SWIG_fail;
21534 }
21535 {
21536 wxDateTime * resultptr;
21537 resultptr = new wxDateTime((wxDateTime &)(result));
21538 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21539 }
21540 return resultobj;
21541 fail:
21542 return NULL;
21543 }
21544
21545
21546 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21547 PyObject *resultobj;
21548 wxDateTime *arg1 = (wxDateTime *) 0 ;
21549 bool arg2 = (bool) false ;
21550 wxDateTime *result;
21551 PyObject * obj0 = 0 ;
21552 PyObject * obj1 = 0 ;
21553 char *kwnames[] = {
21554 (char *) "self",(char *) "noDST", NULL
21555 };
21556
21557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21559 if (SWIG_arg_fail(1)) SWIG_fail;
21560 if (obj1) {
21561 {
21562 arg2 = (bool)(SWIG_As_bool(obj1));
21563 if (SWIG_arg_fail(2)) SWIG_fail;
21564 }
21565 }
21566 {
21567 PyThreadState* __tstate = wxPyBeginAllowThreads();
21568 {
21569 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21570 result = (wxDateTime *) &_result_ref;
21571 }
21572
21573 wxPyEndAllowThreads(__tstate);
21574 if (PyErr_Occurred()) SWIG_fail;
21575 }
21576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21577 return resultobj;
21578 fail:
21579 return NULL;
21580 }
21581
21582
21583 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21584 PyObject *resultobj;
21585 wxDateTime *arg1 = (wxDateTime *) 0 ;
21586 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21587 int result;
21588 PyObject * obj0 = 0 ;
21589 PyObject * obj1 = 0 ;
21590 char *kwnames[] = {
21591 (char *) "self",(char *) "country", NULL
21592 };
21593
21594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21596 if (SWIG_arg_fail(1)) SWIG_fail;
21597 if (obj1) {
21598 {
21599 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21600 if (SWIG_arg_fail(2)) SWIG_fail;
21601 }
21602 }
21603 {
21604 PyThreadState* __tstate = wxPyBeginAllowThreads();
21605 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21606
21607 wxPyEndAllowThreads(__tstate);
21608 if (PyErr_Occurred()) SWIG_fail;
21609 }
21610 {
21611 resultobj = SWIG_From_int((int)(result));
21612 }
21613 return resultobj;
21614 fail:
21615 return NULL;
21616 }
21617
21618
21619 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21620 PyObject *resultobj;
21621 wxDateTime *arg1 = (wxDateTime *) 0 ;
21622 bool result;
21623 PyObject * obj0 = 0 ;
21624 char *kwnames[] = {
21625 (char *) "self", NULL
21626 };
21627
21628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21630 if (SWIG_arg_fail(1)) SWIG_fail;
21631 {
21632 PyThreadState* __tstate = wxPyBeginAllowThreads();
21633 result = (bool)((wxDateTime const *)arg1)->IsValid();
21634
21635 wxPyEndAllowThreads(__tstate);
21636 if (PyErr_Occurred()) SWIG_fail;
21637 }
21638 {
21639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21640 }
21641 return resultobj;
21642 fail:
21643 return NULL;
21644 }
21645
21646
21647 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21648 PyObject *resultobj;
21649 wxDateTime *arg1 = (wxDateTime *) 0 ;
21650 time_t result;
21651 PyObject * obj0 = 0 ;
21652 char *kwnames[] = {
21653 (char *) "self", NULL
21654 };
21655
21656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21658 if (SWIG_arg_fail(1)) SWIG_fail;
21659 {
21660 PyThreadState* __tstate = wxPyBeginAllowThreads();
21661 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21662
21663 wxPyEndAllowThreads(__tstate);
21664 if (PyErr_Occurred()) SWIG_fail;
21665 }
21666 {
21667 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21668 }
21669 return resultobj;
21670 fail:
21671 return NULL;
21672 }
21673
21674
21675 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21676 PyObject *resultobj;
21677 wxDateTime *arg1 = (wxDateTime *) 0 ;
21678 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21679 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21680 int result;
21681 bool temp2 = false ;
21682 PyObject * obj0 = 0 ;
21683 PyObject * obj1 = 0 ;
21684 char *kwnames[] = {
21685 (char *) "self",(char *) "tz", NULL
21686 };
21687
21688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21690 if (SWIG_arg_fail(1)) SWIG_fail;
21691 if (obj1) {
21692 {
21693 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21694 temp2 = true;
21695 }
21696 }
21697 {
21698 PyThreadState* __tstate = wxPyBeginAllowThreads();
21699 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21700
21701 wxPyEndAllowThreads(__tstate);
21702 if (PyErr_Occurred()) SWIG_fail;
21703 }
21704 {
21705 resultobj = SWIG_From_int((int)(result));
21706 }
21707 {
21708 if (temp2) delete arg2;
21709 }
21710 return resultobj;
21711 fail:
21712 {
21713 if (temp2) delete arg2;
21714 }
21715 return NULL;
21716 }
21717
21718
21719 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21720 PyObject *resultobj;
21721 wxDateTime *arg1 = (wxDateTime *) 0 ;
21722 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21723 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21724 wxDateTime::Month result;
21725 bool temp2 = false ;
21726 PyObject * obj0 = 0 ;
21727 PyObject * obj1 = 0 ;
21728 char *kwnames[] = {
21729 (char *) "self",(char *) "tz", NULL
21730 };
21731
21732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21734 if (SWIG_arg_fail(1)) SWIG_fail;
21735 if (obj1) {
21736 {
21737 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21738 temp2 = true;
21739 }
21740 }
21741 {
21742 PyThreadState* __tstate = wxPyBeginAllowThreads();
21743 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21744
21745 wxPyEndAllowThreads(__tstate);
21746 if (PyErr_Occurred()) SWIG_fail;
21747 }
21748 resultobj = SWIG_From_int((result));
21749 {
21750 if (temp2) delete arg2;
21751 }
21752 return resultobj;
21753 fail:
21754 {
21755 if (temp2) delete arg2;
21756 }
21757 return NULL;
21758 }
21759
21760
21761 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21762 PyObject *resultobj;
21763 wxDateTime *arg1 = (wxDateTime *) 0 ;
21764 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21765 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21766 int result;
21767 bool temp2 = false ;
21768 PyObject * obj0 = 0 ;
21769 PyObject * obj1 = 0 ;
21770 char *kwnames[] = {
21771 (char *) "self",(char *) "tz", NULL
21772 };
21773
21774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21776 if (SWIG_arg_fail(1)) SWIG_fail;
21777 if (obj1) {
21778 {
21779 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21780 temp2 = true;
21781 }
21782 }
21783 {
21784 PyThreadState* __tstate = wxPyBeginAllowThreads();
21785 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21786
21787 wxPyEndAllowThreads(__tstate);
21788 if (PyErr_Occurred()) SWIG_fail;
21789 }
21790 {
21791 resultobj = SWIG_From_int((int)(result));
21792 }
21793 {
21794 if (temp2) delete arg2;
21795 }
21796 return resultobj;
21797 fail:
21798 {
21799 if (temp2) delete arg2;
21800 }
21801 return NULL;
21802 }
21803
21804
21805 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21806 PyObject *resultobj;
21807 wxDateTime *arg1 = (wxDateTime *) 0 ;
21808 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21809 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21810 wxDateTime::WeekDay result;
21811 bool temp2 = false ;
21812 PyObject * obj0 = 0 ;
21813 PyObject * obj1 = 0 ;
21814 char *kwnames[] = {
21815 (char *) "self",(char *) "tz", NULL
21816 };
21817
21818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21820 if (SWIG_arg_fail(1)) SWIG_fail;
21821 if (obj1) {
21822 {
21823 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21824 temp2 = true;
21825 }
21826 }
21827 {
21828 PyThreadState* __tstate = wxPyBeginAllowThreads();
21829 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21830
21831 wxPyEndAllowThreads(__tstate);
21832 if (PyErr_Occurred()) SWIG_fail;
21833 }
21834 resultobj = SWIG_From_int((result));
21835 {
21836 if (temp2) delete arg2;
21837 }
21838 return resultobj;
21839 fail:
21840 {
21841 if (temp2) delete arg2;
21842 }
21843 return NULL;
21844 }
21845
21846
21847 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21848 PyObject *resultobj;
21849 wxDateTime *arg1 = (wxDateTime *) 0 ;
21850 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21851 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21852 int result;
21853 bool temp2 = false ;
21854 PyObject * obj0 = 0 ;
21855 PyObject * obj1 = 0 ;
21856 char *kwnames[] = {
21857 (char *) "self",(char *) "tz", NULL
21858 };
21859
21860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21862 if (SWIG_arg_fail(1)) SWIG_fail;
21863 if (obj1) {
21864 {
21865 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21866 temp2 = true;
21867 }
21868 }
21869 {
21870 PyThreadState* __tstate = wxPyBeginAllowThreads();
21871 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21872
21873 wxPyEndAllowThreads(__tstate);
21874 if (PyErr_Occurred()) SWIG_fail;
21875 }
21876 {
21877 resultobj = SWIG_From_int((int)(result));
21878 }
21879 {
21880 if (temp2) delete arg2;
21881 }
21882 return resultobj;
21883 fail:
21884 {
21885 if (temp2) delete arg2;
21886 }
21887 return NULL;
21888 }
21889
21890
21891 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21892 PyObject *resultobj;
21893 wxDateTime *arg1 = (wxDateTime *) 0 ;
21894 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21895 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21896 int result;
21897 bool temp2 = false ;
21898 PyObject * obj0 = 0 ;
21899 PyObject * obj1 = 0 ;
21900 char *kwnames[] = {
21901 (char *) "self",(char *) "tz", NULL
21902 };
21903
21904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21906 if (SWIG_arg_fail(1)) SWIG_fail;
21907 if (obj1) {
21908 {
21909 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21910 temp2 = true;
21911 }
21912 }
21913 {
21914 PyThreadState* __tstate = wxPyBeginAllowThreads();
21915 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21916
21917 wxPyEndAllowThreads(__tstate);
21918 if (PyErr_Occurred()) SWIG_fail;
21919 }
21920 {
21921 resultobj = SWIG_From_int((int)(result));
21922 }
21923 {
21924 if (temp2) delete arg2;
21925 }
21926 return resultobj;
21927 fail:
21928 {
21929 if (temp2) delete arg2;
21930 }
21931 return NULL;
21932 }
21933
21934
21935 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21936 PyObject *resultobj;
21937 wxDateTime *arg1 = (wxDateTime *) 0 ;
21938 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21939 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21940 int result;
21941 bool temp2 = false ;
21942 PyObject * obj0 = 0 ;
21943 PyObject * obj1 = 0 ;
21944 char *kwnames[] = {
21945 (char *) "self",(char *) "tz", NULL
21946 };
21947
21948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21950 if (SWIG_arg_fail(1)) SWIG_fail;
21951 if (obj1) {
21952 {
21953 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21954 temp2 = true;
21955 }
21956 }
21957 {
21958 PyThreadState* __tstate = wxPyBeginAllowThreads();
21959 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21960
21961 wxPyEndAllowThreads(__tstate);
21962 if (PyErr_Occurred()) SWIG_fail;
21963 }
21964 {
21965 resultobj = SWIG_From_int((int)(result));
21966 }
21967 {
21968 if (temp2) delete arg2;
21969 }
21970 return resultobj;
21971 fail:
21972 {
21973 if (temp2) delete arg2;
21974 }
21975 return NULL;
21976 }
21977
21978
21979 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21980 PyObject *resultobj;
21981 wxDateTime *arg1 = (wxDateTime *) 0 ;
21982 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21983 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21984 int result;
21985 bool temp2 = false ;
21986 PyObject * obj0 = 0 ;
21987 PyObject * obj1 = 0 ;
21988 char *kwnames[] = {
21989 (char *) "self",(char *) "tz", NULL
21990 };
21991
21992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21994 if (SWIG_arg_fail(1)) SWIG_fail;
21995 if (obj1) {
21996 {
21997 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21998 temp2 = true;
21999 }
22000 }
22001 {
22002 PyThreadState* __tstate = wxPyBeginAllowThreads();
22003 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
22004
22005 wxPyEndAllowThreads(__tstate);
22006 if (PyErr_Occurred()) SWIG_fail;
22007 }
22008 {
22009 resultobj = SWIG_From_int((int)(result));
22010 }
22011 {
22012 if (temp2) delete arg2;
22013 }
22014 return resultobj;
22015 fail:
22016 {
22017 if (temp2) delete arg2;
22018 }
22019 return NULL;
22020 }
22021
22022
22023 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
22024 PyObject *resultobj;
22025 wxDateTime *arg1 = (wxDateTime *) 0 ;
22026 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22027 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22028 int result;
22029 bool temp2 = false ;
22030 PyObject * obj0 = 0 ;
22031 PyObject * obj1 = 0 ;
22032 char *kwnames[] = {
22033 (char *) "self",(char *) "tz", NULL
22034 };
22035
22036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
22037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22038 if (SWIG_arg_fail(1)) SWIG_fail;
22039 if (obj1) {
22040 {
22041 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22042 temp2 = true;
22043 }
22044 }
22045 {
22046 PyThreadState* __tstate = wxPyBeginAllowThreads();
22047 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
22048
22049 wxPyEndAllowThreads(__tstate);
22050 if (PyErr_Occurred()) SWIG_fail;
22051 }
22052 {
22053 resultobj = SWIG_From_int((int)(result));
22054 }
22055 {
22056 if (temp2) delete arg2;
22057 }
22058 return resultobj;
22059 fail:
22060 {
22061 if (temp2) delete arg2;
22062 }
22063 return NULL;
22064 }
22065
22066
22067 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
22068 PyObject *resultobj;
22069 wxDateTime *arg1 = (wxDateTime *) 0 ;
22070 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
22071 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
22072 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
22073 int result;
22074 bool temp3 = false ;
22075 PyObject * obj0 = 0 ;
22076 PyObject * obj1 = 0 ;
22077 PyObject * obj2 = 0 ;
22078 char *kwnames[] = {
22079 (char *) "self",(char *) "flags",(char *) "tz", NULL
22080 };
22081
22082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
22083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22084 if (SWIG_arg_fail(1)) SWIG_fail;
22085 if (obj1) {
22086 {
22087 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
22088 if (SWIG_arg_fail(2)) SWIG_fail;
22089 }
22090 }
22091 if (obj2) {
22092 {
22093 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22094 temp3 = true;
22095 }
22096 }
22097 {
22098 PyThreadState* __tstate = wxPyBeginAllowThreads();
22099 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22100
22101 wxPyEndAllowThreads(__tstate);
22102 if (PyErr_Occurred()) SWIG_fail;
22103 }
22104 {
22105 resultobj = SWIG_From_int((int)(result));
22106 }
22107 {
22108 if (temp3) delete arg3;
22109 }
22110 return resultobj;
22111 fail:
22112 {
22113 if (temp3) delete arg3;
22114 }
22115 return NULL;
22116 }
22117
22118
22119 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
22120 PyObject *resultobj;
22121 wxDateTime *arg1 = (wxDateTime *) 0 ;
22122 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
22123 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
22124 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
22125 int result;
22126 bool temp3 = false ;
22127 PyObject * obj0 = 0 ;
22128 PyObject * obj1 = 0 ;
22129 PyObject * obj2 = 0 ;
22130 char *kwnames[] = {
22131 (char *) "self",(char *) "flags",(char *) "tz", NULL
22132 };
22133
22134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
22135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22136 if (SWIG_arg_fail(1)) SWIG_fail;
22137 if (obj1) {
22138 {
22139 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
22140 if (SWIG_arg_fail(2)) SWIG_fail;
22141 }
22142 }
22143 if (obj2) {
22144 {
22145 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22146 temp3 = true;
22147 }
22148 }
22149 {
22150 PyThreadState* __tstate = wxPyBeginAllowThreads();
22151 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22152
22153 wxPyEndAllowThreads(__tstate);
22154 if (PyErr_Occurred()) SWIG_fail;
22155 }
22156 {
22157 resultobj = SWIG_From_int((int)(result));
22158 }
22159 {
22160 if (temp3) delete arg3;
22161 }
22162 return resultobj;
22163 fail:
22164 {
22165 if (temp3) delete arg3;
22166 }
22167 return NULL;
22168 }
22169
22170
22171 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
22172 PyObject *resultobj;
22173 wxDateTime *arg1 = (wxDateTime *) 0 ;
22174 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22175 bool result;
22176 PyObject * obj0 = 0 ;
22177 PyObject * obj1 = 0 ;
22178 char *kwnames[] = {
22179 (char *) "self",(char *) "country", NULL
22180 };
22181
22182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22184 if (SWIG_arg_fail(1)) SWIG_fail;
22185 if (obj1) {
22186 {
22187 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22188 if (SWIG_arg_fail(2)) SWIG_fail;
22189 }
22190 }
22191 {
22192 PyThreadState* __tstate = wxPyBeginAllowThreads();
22193 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22194
22195 wxPyEndAllowThreads(__tstate);
22196 if (PyErr_Occurred()) SWIG_fail;
22197 }
22198 {
22199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22200 }
22201 return resultobj;
22202 fail:
22203 return NULL;
22204 }
22205
22206
22207 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22208 PyObject *resultobj;
22209 wxDateTime *arg1 = (wxDateTime *) 0 ;
22210 wxDateTime *arg2 = 0 ;
22211 bool result;
22212 PyObject * obj0 = 0 ;
22213 PyObject * obj1 = 0 ;
22214 char *kwnames[] = {
22215 (char *) "self",(char *) "datetime", NULL
22216 };
22217
22218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22220 if (SWIG_arg_fail(1)) SWIG_fail;
22221 {
22222 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22223 if (SWIG_arg_fail(2)) SWIG_fail;
22224 if (arg2 == NULL) {
22225 SWIG_null_ref("wxDateTime");
22226 }
22227 if (SWIG_arg_fail(2)) SWIG_fail;
22228 }
22229 {
22230 PyThreadState* __tstate = wxPyBeginAllowThreads();
22231 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22232
22233 wxPyEndAllowThreads(__tstate);
22234 if (PyErr_Occurred()) SWIG_fail;
22235 }
22236 {
22237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22238 }
22239 return resultobj;
22240 fail:
22241 return NULL;
22242 }
22243
22244
22245 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22246 PyObject *resultobj;
22247 wxDateTime *arg1 = (wxDateTime *) 0 ;
22248 wxDateTime *arg2 = 0 ;
22249 bool result;
22250 PyObject * obj0 = 0 ;
22251 PyObject * obj1 = 0 ;
22252 char *kwnames[] = {
22253 (char *) "self",(char *) "datetime", NULL
22254 };
22255
22256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22258 if (SWIG_arg_fail(1)) SWIG_fail;
22259 {
22260 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22261 if (SWIG_arg_fail(2)) SWIG_fail;
22262 if (arg2 == NULL) {
22263 SWIG_null_ref("wxDateTime");
22264 }
22265 if (SWIG_arg_fail(2)) SWIG_fail;
22266 }
22267 {
22268 PyThreadState* __tstate = wxPyBeginAllowThreads();
22269 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22270
22271 wxPyEndAllowThreads(__tstate);
22272 if (PyErr_Occurred()) SWIG_fail;
22273 }
22274 {
22275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22276 }
22277 return resultobj;
22278 fail:
22279 return NULL;
22280 }
22281
22282
22283 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22284 PyObject *resultobj;
22285 wxDateTime *arg1 = (wxDateTime *) 0 ;
22286 wxDateTime *arg2 = 0 ;
22287 bool result;
22288 PyObject * obj0 = 0 ;
22289 PyObject * obj1 = 0 ;
22290 char *kwnames[] = {
22291 (char *) "self",(char *) "datetime", NULL
22292 };
22293
22294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22296 if (SWIG_arg_fail(1)) SWIG_fail;
22297 {
22298 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22299 if (SWIG_arg_fail(2)) SWIG_fail;
22300 if (arg2 == NULL) {
22301 SWIG_null_ref("wxDateTime");
22302 }
22303 if (SWIG_arg_fail(2)) SWIG_fail;
22304 }
22305 {
22306 PyThreadState* __tstate = wxPyBeginAllowThreads();
22307 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22308
22309 wxPyEndAllowThreads(__tstate);
22310 if (PyErr_Occurred()) SWIG_fail;
22311 }
22312 {
22313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22314 }
22315 return resultobj;
22316 fail:
22317 return NULL;
22318 }
22319
22320
22321 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22322 PyObject *resultobj;
22323 wxDateTime *arg1 = (wxDateTime *) 0 ;
22324 wxDateTime *arg2 = 0 ;
22325 wxDateTime *arg3 = 0 ;
22326 bool result;
22327 PyObject * obj0 = 0 ;
22328 PyObject * obj1 = 0 ;
22329 PyObject * obj2 = 0 ;
22330 char *kwnames[] = {
22331 (char *) "self",(char *) "t1",(char *) "t2", NULL
22332 };
22333
22334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22336 if (SWIG_arg_fail(1)) SWIG_fail;
22337 {
22338 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22339 if (SWIG_arg_fail(2)) SWIG_fail;
22340 if (arg2 == NULL) {
22341 SWIG_null_ref("wxDateTime");
22342 }
22343 if (SWIG_arg_fail(2)) SWIG_fail;
22344 }
22345 {
22346 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22347 if (SWIG_arg_fail(3)) SWIG_fail;
22348 if (arg3 == NULL) {
22349 SWIG_null_ref("wxDateTime");
22350 }
22351 if (SWIG_arg_fail(3)) SWIG_fail;
22352 }
22353 {
22354 PyThreadState* __tstate = wxPyBeginAllowThreads();
22355 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22356
22357 wxPyEndAllowThreads(__tstate);
22358 if (PyErr_Occurred()) SWIG_fail;
22359 }
22360 {
22361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22362 }
22363 return resultobj;
22364 fail:
22365 return NULL;
22366 }
22367
22368
22369 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22370 PyObject *resultobj;
22371 wxDateTime *arg1 = (wxDateTime *) 0 ;
22372 wxDateTime *arg2 = 0 ;
22373 wxDateTime *arg3 = 0 ;
22374 bool result;
22375 PyObject * obj0 = 0 ;
22376 PyObject * obj1 = 0 ;
22377 PyObject * obj2 = 0 ;
22378 char *kwnames[] = {
22379 (char *) "self",(char *) "t1",(char *) "t2", NULL
22380 };
22381
22382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22384 if (SWIG_arg_fail(1)) SWIG_fail;
22385 {
22386 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22387 if (SWIG_arg_fail(2)) SWIG_fail;
22388 if (arg2 == NULL) {
22389 SWIG_null_ref("wxDateTime");
22390 }
22391 if (SWIG_arg_fail(2)) SWIG_fail;
22392 }
22393 {
22394 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22395 if (SWIG_arg_fail(3)) SWIG_fail;
22396 if (arg3 == NULL) {
22397 SWIG_null_ref("wxDateTime");
22398 }
22399 if (SWIG_arg_fail(3)) SWIG_fail;
22400 }
22401 {
22402 PyThreadState* __tstate = wxPyBeginAllowThreads();
22403 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22404
22405 wxPyEndAllowThreads(__tstate);
22406 if (PyErr_Occurred()) SWIG_fail;
22407 }
22408 {
22409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22410 }
22411 return resultobj;
22412 fail:
22413 return NULL;
22414 }
22415
22416
22417 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22418 PyObject *resultobj;
22419 wxDateTime *arg1 = (wxDateTime *) 0 ;
22420 wxDateTime *arg2 = 0 ;
22421 bool result;
22422 PyObject * obj0 = 0 ;
22423 PyObject * obj1 = 0 ;
22424 char *kwnames[] = {
22425 (char *) "self",(char *) "dt", NULL
22426 };
22427
22428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22430 if (SWIG_arg_fail(1)) SWIG_fail;
22431 {
22432 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22433 if (SWIG_arg_fail(2)) SWIG_fail;
22434 if (arg2 == NULL) {
22435 SWIG_null_ref("wxDateTime");
22436 }
22437 if (SWIG_arg_fail(2)) SWIG_fail;
22438 }
22439 {
22440 PyThreadState* __tstate = wxPyBeginAllowThreads();
22441 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22442
22443 wxPyEndAllowThreads(__tstate);
22444 if (PyErr_Occurred()) SWIG_fail;
22445 }
22446 {
22447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22448 }
22449 return resultobj;
22450 fail:
22451 return NULL;
22452 }
22453
22454
22455 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22456 PyObject *resultobj;
22457 wxDateTime *arg1 = (wxDateTime *) 0 ;
22458 wxDateTime *arg2 = 0 ;
22459 bool result;
22460 PyObject * obj0 = 0 ;
22461 PyObject * obj1 = 0 ;
22462 char *kwnames[] = {
22463 (char *) "self",(char *) "dt", NULL
22464 };
22465
22466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22468 if (SWIG_arg_fail(1)) SWIG_fail;
22469 {
22470 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22471 if (SWIG_arg_fail(2)) SWIG_fail;
22472 if (arg2 == NULL) {
22473 SWIG_null_ref("wxDateTime");
22474 }
22475 if (SWIG_arg_fail(2)) SWIG_fail;
22476 }
22477 {
22478 PyThreadState* __tstate = wxPyBeginAllowThreads();
22479 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22480
22481 wxPyEndAllowThreads(__tstate);
22482 if (PyErr_Occurred()) SWIG_fail;
22483 }
22484 {
22485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22486 }
22487 return resultobj;
22488 fail:
22489 return NULL;
22490 }
22491
22492
22493 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22494 PyObject *resultobj;
22495 wxDateTime *arg1 = (wxDateTime *) 0 ;
22496 wxDateTime *arg2 = 0 ;
22497 wxTimeSpan *arg3 = 0 ;
22498 bool result;
22499 PyObject * obj0 = 0 ;
22500 PyObject * obj1 = 0 ;
22501 PyObject * obj2 = 0 ;
22502 char *kwnames[] = {
22503 (char *) "self",(char *) "dt",(char *) "ts", NULL
22504 };
22505
22506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22508 if (SWIG_arg_fail(1)) SWIG_fail;
22509 {
22510 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22511 if (SWIG_arg_fail(2)) SWIG_fail;
22512 if (arg2 == NULL) {
22513 SWIG_null_ref("wxDateTime");
22514 }
22515 if (SWIG_arg_fail(2)) SWIG_fail;
22516 }
22517 {
22518 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22519 if (SWIG_arg_fail(3)) SWIG_fail;
22520 if (arg3 == NULL) {
22521 SWIG_null_ref("wxTimeSpan");
22522 }
22523 if (SWIG_arg_fail(3)) SWIG_fail;
22524 }
22525 {
22526 PyThreadState* __tstate = wxPyBeginAllowThreads();
22527 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22528
22529 wxPyEndAllowThreads(__tstate);
22530 if (PyErr_Occurred()) SWIG_fail;
22531 }
22532 {
22533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22534 }
22535 return resultobj;
22536 fail:
22537 return NULL;
22538 }
22539
22540
22541 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22542 PyObject *resultobj;
22543 wxDateTime *arg1 = (wxDateTime *) 0 ;
22544 wxTimeSpan *arg2 = 0 ;
22545 wxDateTime *result;
22546 PyObject * obj0 = 0 ;
22547 PyObject * obj1 = 0 ;
22548 char *kwnames[] = {
22549 (char *) "self",(char *) "diff", NULL
22550 };
22551
22552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22554 if (SWIG_arg_fail(1)) SWIG_fail;
22555 {
22556 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22557 if (SWIG_arg_fail(2)) SWIG_fail;
22558 if (arg2 == NULL) {
22559 SWIG_null_ref("wxTimeSpan");
22560 }
22561 if (SWIG_arg_fail(2)) SWIG_fail;
22562 }
22563 {
22564 PyThreadState* __tstate = wxPyBeginAllowThreads();
22565 {
22566 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22567 result = (wxDateTime *) &_result_ref;
22568 }
22569
22570 wxPyEndAllowThreads(__tstate);
22571 if (PyErr_Occurred()) SWIG_fail;
22572 }
22573 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22574 return resultobj;
22575 fail:
22576 return NULL;
22577 }
22578
22579
22580 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22581 PyObject *resultobj;
22582 wxDateTime *arg1 = (wxDateTime *) 0 ;
22583 wxDateSpan *arg2 = 0 ;
22584 wxDateTime *result;
22585 PyObject * obj0 = 0 ;
22586 PyObject * obj1 = 0 ;
22587 char *kwnames[] = {
22588 (char *) "self",(char *) "diff", NULL
22589 };
22590
22591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22593 if (SWIG_arg_fail(1)) SWIG_fail;
22594 {
22595 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22596 if (SWIG_arg_fail(2)) SWIG_fail;
22597 if (arg2 == NULL) {
22598 SWIG_null_ref("wxDateSpan");
22599 }
22600 if (SWIG_arg_fail(2)) SWIG_fail;
22601 }
22602 {
22603 PyThreadState* __tstate = wxPyBeginAllowThreads();
22604 {
22605 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22606 result = (wxDateTime *) &_result_ref;
22607 }
22608
22609 wxPyEndAllowThreads(__tstate);
22610 if (PyErr_Occurred()) SWIG_fail;
22611 }
22612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22613 return resultobj;
22614 fail:
22615 return NULL;
22616 }
22617
22618
22619 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22620 PyObject *resultobj;
22621 wxDateTime *arg1 = (wxDateTime *) 0 ;
22622 wxTimeSpan *arg2 = 0 ;
22623 wxDateTime *result;
22624 PyObject * obj0 = 0 ;
22625 PyObject * obj1 = 0 ;
22626 char *kwnames[] = {
22627 (char *) "self",(char *) "diff", NULL
22628 };
22629
22630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22632 if (SWIG_arg_fail(1)) SWIG_fail;
22633 {
22634 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22635 if (SWIG_arg_fail(2)) SWIG_fail;
22636 if (arg2 == NULL) {
22637 SWIG_null_ref("wxTimeSpan");
22638 }
22639 if (SWIG_arg_fail(2)) SWIG_fail;
22640 }
22641 {
22642 PyThreadState* __tstate = wxPyBeginAllowThreads();
22643 {
22644 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22645 result = (wxDateTime *) &_result_ref;
22646 }
22647
22648 wxPyEndAllowThreads(__tstate);
22649 if (PyErr_Occurred()) SWIG_fail;
22650 }
22651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22652 return resultobj;
22653 fail:
22654 return NULL;
22655 }
22656
22657
22658 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22659 PyObject *resultobj;
22660 wxDateTime *arg1 = (wxDateTime *) 0 ;
22661 wxDateSpan *arg2 = 0 ;
22662 wxDateTime *result;
22663 PyObject * obj0 = 0 ;
22664 PyObject * obj1 = 0 ;
22665 char *kwnames[] = {
22666 (char *) "self",(char *) "diff", NULL
22667 };
22668
22669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22671 if (SWIG_arg_fail(1)) SWIG_fail;
22672 {
22673 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22674 if (SWIG_arg_fail(2)) SWIG_fail;
22675 if (arg2 == NULL) {
22676 SWIG_null_ref("wxDateSpan");
22677 }
22678 if (SWIG_arg_fail(2)) SWIG_fail;
22679 }
22680 {
22681 PyThreadState* __tstate = wxPyBeginAllowThreads();
22682 {
22683 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22684 result = (wxDateTime *) &_result_ref;
22685 }
22686
22687 wxPyEndAllowThreads(__tstate);
22688 if (PyErr_Occurred()) SWIG_fail;
22689 }
22690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22691 return resultobj;
22692 fail:
22693 return NULL;
22694 }
22695
22696
22697 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22698 PyObject *resultobj;
22699 wxDateTime *arg1 = (wxDateTime *) 0 ;
22700 wxDateTime *arg2 = 0 ;
22701 wxTimeSpan result;
22702 PyObject * obj0 = 0 ;
22703 PyObject * obj1 = 0 ;
22704 char *kwnames[] = {
22705 (char *) "self",(char *) "dt", NULL
22706 };
22707
22708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22710 if (SWIG_arg_fail(1)) SWIG_fail;
22711 {
22712 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22713 if (SWIG_arg_fail(2)) SWIG_fail;
22714 if (arg2 == NULL) {
22715 SWIG_null_ref("wxDateTime");
22716 }
22717 if (SWIG_arg_fail(2)) SWIG_fail;
22718 }
22719 {
22720 PyThreadState* __tstate = wxPyBeginAllowThreads();
22721 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22722
22723 wxPyEndAllowThreads(__tstate);
22724 if (PyErr_Occurred()) SWIG_fail;
22725 }
22726 {
22727 wxTimeSpan * resultptr;
22728 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22729 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22730 }
22731 return resultobj;
22732 fail:
22733 return NULL;
22734 }
22735
22736
22737 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22738 PyObject *resultobj;
22739 wxDateTime *arg1 = (wxDateTime *) 0 ;
22740 wxTimeSpan *arg2 = 0 ;
22741 wxDateTime *result;
22742 PyObject * obj0 = 0 ;
22743 PyObject * obj1 = 0 ;
22744
22745 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22747 if (SWIG_arg_fail(1)) SWIG_fail;
22748 {
22749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22750 if (SWIG_arg_fail(2)) SWIG_fail;
22751 if (arg2 == NULL) {
22752 SWIG_null_ref("wxTimeSpan");
22753 }
22754 if (SWIG_arg_fail(2)) SWIG_fail;
22755 }
22756 {
22757 PyThreadState* __tstate = wxPyBeginAllowThreads();
22758 {
22759 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22760 result = (wxDateTime *) &_result_ref;
22761 }
22762
22763 wxPyEndAllowThreads(__tstate);
22764 if (PyErr_Occurred()) SWIG_fail;
22765 }
22766 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22767 return resultobj;
22768 fail:
22769 return NULL;
22770 }
22771
22772
22773 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22774 PyObject *resultobj;
22775 wxDateTime *arg1 = (wxDateTime *) 0 ;
22776 wxDateSpan *arg2 = 0 ;
22777 wxDateTime *result;
22778 PyObject * obj0 = 0 ;
22779 PyObject * obj1 = 0 ;
22780
22781 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22783 if (SWIG_arg_fail(1)) SWIG_fail;
22784 {
22785 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22786 if (SWIG_arg_fail(2)) SWIG_fail;
22787 if (arg2 == NULL) {
22788 SWIG_null_ref("wxDateSpan");
22789 }
22790 if (SWIG_arg_fail(2)) SWIG_fail;
22791 }
22792 {
22793 PyThreadState* __tstate = wxPyBeginAllowThreads();
22794 {
22795 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22796 result = (wxDateTime *) &_result_ref;
22797 }
22798
22799 wxPyEndAllowThreads(__tstate);
22800 if (PyErr_Occurred()) SWIG_fail;
22801 }
22802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22803 return resultobj;
22804 fail:
22805 return NULL;
22806 }
22807
22808
22809 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22810 int argc;
22811 PyObject *argv[3];
22812 int ii;
22813
22814 argc = PyObject_Length(args);
22815 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22816 argv[ii] = PyTuple_GetItem(args,ii);
22817 }
22818 if (argc == 2) {
22819 int _v;
22820 {
22821 void *ptr;
22822 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22823 _v = 0;
22824 PyErr_Clear();
22825 } else {
22826 _v = 1;
22827 }
22828 }
22829 if (_v) {
22830 {
22831 void *ptr = 0;
22832 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22833 _v = 0;
22834 PyErr_Clear();
22835 } else {
22836 _v = (ptr != 0);
22837 }
22838 }
22839 if (_v) {
22840 return _wrap_DateTime___iadd____SWIG_0(self,args);
22841 }
22842 }
22843 }
22844 if (argc == 2) {
22845 int _v;
22846 {
22847 void *ptr;
22848 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22849 _v = 0;
22850 PyErr_Clear();
22851 } else {
22852 _v = 1;
22853 }
22854 }
22855 if (_v) {
22856 {
22857 void *ptr = 0;
22858 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22859 _v = 0;
22860 PyErr_Clear();
22861 } else {
22862 _v = (ptr != 0);
22863 }
22864 }
22865 if (_v) {
22866 return _wrap_DateTime___iadd____SWIG_1(self,args);
22867 }
22868 }
22869 }
22870
22871 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22872 return NULL;
22873 }
22874
22875
22876 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22877 PyObject *resultobj;
22878 wxDateTime *arg1 = (wxDateTime *) 0 ;
22879 wxTimeSpan *arg2 = 0 ;
22880 wxDateTime *result;
22881 PyObject * obj0 = 0 ;
22882 PyObject * obj1 = 0 ;
22883
22884 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22886 if (SWIG_arg_fail(1)) SWIG_fail;
22887 {
22888 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22889 if (SWIG_arg_fail(2)) SWIG_fail;
22890 if (arg2 == NULL) {
22891 SWIG_null_ref("wxTimeSpan");
22892 }
22893 if (SWIG_arg_fail(2)) SWIG_fail;
22894 }
22895 {
22896 PyThreadState* __tstate = wxPyBeginAllowThreads();
22897 {
22898 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22899 result = (wxDateTime *) &_result_ref;
22900 }
22901
22902 wxPyEndAllowThreads(__tstate);
22903 if (PyErr_Occurred()) SWIG_fail;
22904 }
22905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22906 return resultobj;
22907 fail:
22908 return NULL;
22909 }
22910
22911
22912 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22913 PyObject *resultobj;
22914 wxDateTime *arg1 = (wxDateTime *) 0 ;
22915 wxDateSpan *arg2 = 0 ;
22916 wxDateTime *result;
22917 PyObject * obj0 = 0 ;
22918 PyObject * obj1 = 0 ;
22919
22920 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22922 if (SWIG_arg_fail(1)) SWIG_fail;
22923 {
22924 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22925 if (SWIG_arg_fail(2)) SWIG_fail;
22926 if (arg2 == NULL) {
22927 SWIG_null_ref("wxDateSpan");
22928 }
22929 if (SWIG_arg_fail(2)) SWIG_fail;
22930 }
22931 {
22932 PyThreadState* __tstate = wxPyBeginAllowThreads();
22933 {
22934 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22935 result = (wxDateTime *) &_result_ref;
22936 }
22937
22938 wxPyEndAllowThreads(__tstate);
22939 if (PyErr_Occurred()) SWIG_fail;
22940 }
22941 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22942 return resultobj;
22943 fail:
22944 return NULL;
22945 }
22946
22947
22948 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22949 int argc;
22950 PyObject *argv[3];
22951 int ii;
22952
22953 argc = PyObject_Length(args);
22954 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22955 argv[ii] = PyTuple_GetItem(args,ii);
22956 }
22957 if (argc == 2) {
22958 int _v;
22959 {
22960 void *ptr;
22961 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22962 _v = 0;
22963 PyErr_Clear();
22964 } else {
22965 _v = 1;
22966 }
22967 }
22968 if (_v) {
22969 {
22970 void *ptr = 0;
22971 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22972 _v = 0;
22973 PyErr_Clear();
22974 } else {
22975 _v = (ptr != 0);
22976 }
22977 }
22978 if (_v) {
22979 return _wrap_DateTime___isub____SWIG_0(self,args);
22980 }
22981 }
22982 }
22983 if (argc == 2) {
22984 int _v;
22985 {
22986 void *ptr;
22987 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22988 _v = 0;
22989 PyErr_Clear();
22990 } else {
22991 _v = 1;
22992 }
22993 }
22994 if (_v) {
22995 {
22996 void *ptr = 0;
22997 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22998 _v = 0;
22999 PyErr_Clear();
23000 } else {
23001 _v = (ptr != 0);
23002 }
23003 }
23004 if (_v) {
23005 return _wrap_DateTime___isub____SWIG_1(self,args);
23006 }
23007 }
23008 }
23009
23010 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
23011 return NULL;
23012 }
23013
23014
23015 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
23016 PyObject *resultobj;
23017 wxDateTime *arg1 = (wxDateTime *) 0 ;
23018 wxTimeSpan *arg2 = 0 ;
23019 wxDateTime result;
23020 PyObject * obj0 = 0 ;
23021 PyObject * obj1 = 0 ;
23022
23023 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
23024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23025 if (SWIG_arg_fail(1)) SWIG_fail;
23026 {
23027 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23028 if (SWIG_arg_fail(2)) SWIG_fail;
23029 if (arg2 == NULL) {
23030 SWIG_null_ref("wxTimeSpan");
23031 }
23032 if (SWIG_arg_fail(2)) SWIG_fail;
23033 }
23034 {
23035 PyThreadState* __tstate = wxPyBeginAllowThreads();
23036 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
23037
23038 wxPyEndAllowThreads(__tstate);
23039 if (PyErr_Occurred()) SWIG_fail;
23040 }
23041 {
23042 wxDateTime * resultptr;
23043 resultptr = new wxDateTime((wxDateTime &)(result));
23044 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23045 }
23046 return resultobj;
23047 fail:
23048 return NULL;
23049 }
23050
23051
23052 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
23053 PyObject *resultobj;
23054 wxDateTime *arg1 = (wxDateTime *) 0 ;
23055 wxDateSpan *arg2 = 0 ;
23056 wxDateTime result;
23057 PyObject * obj0 = 0 ;
23058 PyObject * obj1 = 0 ;
23059
23060 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
23061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23062 if (SWIG_arg_fail(1)) SWIG_fail;
23063 {
23064 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23065 if (SWIG_arg_fail(2)) SWIG_fail;
23066 if (arg2 == NULL) {
23067 SWIG_null_ref("wxDateSpan");
23068 }
23069 if (SWIG_arg_fail(2)) SWIG_fail;
23070 }
23071 {
23072 PyThreadState* __tstate = wxPyBeginAllowThreads();
23073 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
23074
23075 wxPyEndAllowThreads(__tstate);
23076 if (PyErr_Occurred()) SWIG_fail;
23077 }
23078 {
23079 wxDateTime * resultptr;
23080 resultptr = new wxDateTime((wxDateTime &)(result));
23081 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23082 }
23083 return resultobj;
23084 fail:
23085 return NULL;
23086 }
23087
23088
23089 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
23090 int argc;
23091 PyObject *argv[3];
23092 int ii;
23093
23094 argc = PyObject_Length(args);
23095 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23096 argv[ii] = PyTuple_GetItem(args,ii);
23097 }
23098 if (argc == 2) {
23099 int _v;
23100 {
23101 void *ptr;
23102 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23103 _v = 0;
23104 PyErr_Clear();
23105 } else {
23106 _v = 1;
23107 }
23108 }
23109 if (_v) {
23110 {
23111 void *ptr = 0;
23112 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23113 _v = 0;
23114 PyErr_Clear();
23115 } else {
23116 _v = (ptr != 0);
23117 }
23118 }
23119 if (_v) {
23120 return _wrap_DateTime___add____SWIG_0(self,args);
23121 }
23122 }
23123 }
23124 if (argc == 2) {
23125 int _v;
23126 {
23127 void *ptr;
23128 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23129 _v = 0;
23130 PyErr_Clear();
23131 } else {
23132 _v = 1;
23133 }
23134 }
23135 if (_v) {
23136 {
23137 void *ptr = 0;
23138 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23139 _v = 0;
23140 PyErr_Clear();
23141 } else {
23142 _v = (ptr != 0);
23143 }
23144 }
23145 if (_v) {
23146 return _wrap_DateTime___add____SWIG_1(self,args);
23147 }
23148 }
23149 }
23150
23151 Py_INCREF(Py_NotImplemented);
23152 return Py_NotImplemented;
23153 }
23154
23155
23156 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
23157 PyObject *resultobj;
23158 wxDateTime *arg1 = (wxDateTime *) 0 ;
23159 wxDateTime *arg2 = 0 ;
23160 wxTimeSpan result;
23161 PyObject * obj0 = 0 ;
23162 PyObject * obj1 = 0 ;
23163
23164 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23166 if (SWIG_arg_fail(1)) SWIG_fail;
23167 {
23168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23169 if (SWIG_arg_fail(2)) SWIG_fail;
23170 if (arg2 == NULL) {
23171 SWIG_null_ref("wxDateTime");
23172 }
23173 if (SWIG_arg_fail(2)) SWIG_fail;
23174 }
23175 {
23176 PyThreadState* __tstate = wxPyBeginAllowThreads();
23177 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
23178
23179 wxPyEndAllowThreads(__tstate);
23180 if (PyErr_Occurred()) SWIG_fail;
23181 }
23182 {
23183 wxTimeSpan * resultptr;
23184 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23185 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23186 }
23187 return resultobj;
23188 fail:
23189 return NULL;
23190 }
23191
23192
23193 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23194 PyObject *resultobj;
23195 wxDateTime *arg1 = (wxDateTime *) 0 ;
23196 wxTimeSpan *arg2 = 0 ;
23197 wxDateTime result;
23198 PyObject * obj0 = 0 ;
23199 PyObject * obj1 = 0 ;
23200
23201 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23203 if (SWIG_arg_fail(1)) SWIG_fail;
23204 {
23205 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23206 if (SWIG_arg_fail(2)) SWIG_fail;
23207 if (arg2 == NULL) {
23208 SWIG_null_ref("wxTimeSpan");
23209 }
23210 if (SWIG_arg_fail(2)) SWIG_fail;
23211 }
23212 {
23213 PyThreadState* __tstate = wxPyBeginAllowThreads();
23214 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23215
23216 wxPyEndAllowThreads(__tstate);
23217 if (PyErr_Occurred()) SWIG_fail;
23218 }
23219 {
23220 wxDateTime * resultptr;
23221 resultptr = new wxDateTime((wxDateTime &)(result));
23222 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23223 }
23224 return resultobj;
23225 fail:
23226 return NULL;
23227 }
23228
23229
23230 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23231 PyObject *resultobj;
23232 wxDateTime *arg1 = (wxDateTime *) 0 ;
23233 wxDateSpan *arg2 = 0 ;
23234 wxDateTime result;
23235 PyObject * obj0 = 0 ;
23236 PyObject * obj1 = 0 ;
23237
23238 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23240 if (SWIG_arg_fail(1)) SWIG_fail;
23241 {
23242 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23243 if (SWIG_arg_fail(2)) SWIG_fail;
23244 if (arg2 == NULL) {
23245 SWIG_null_ref("wxDateSpan");
23246 }
23247 if (SWIG_arg_fail(2)) SWIG_fail;
23248 }
23249 {
23250 PyThreadState* __tstate = wxPyBeginAllowThreads();
23251 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23252
23253 wxPyEndAllowThreads(__tstate);
23254 if (PyErr_Occurred()) SWIG_fail;
23255 }
23256 {
23257 wxDateTime * resultptr;
23258 resultptr = new wxDateTime((wxDateTime &)(result));
23259 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23260 }
23261 return resultobj;
23262 fail:
23263 return NULL;
23264 }
23265
23266
23267 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23268 int argc;
23269 PyObject *argv[3];
23270 int ii;
23271
23272 argc = PyObject_Length(args);
23273 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23274 argv[ii] = PyTuple_GetItem(args,ii);
23275 }
23276 if (argc == 2) {
23277 int _v;
23278 {
23279 void *ptr;
23280 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23281 _v = 0;
23282 PyErr_Clear();
23283 } else {
23284 _v = 1;
23285 }
23286 }
23287 if (_v) {
23288 {
23289 void *ptr = 0;
23290 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23291 _v = 0;
23292 PyErr_Clear();
23293 } else {
23294 _v = (ptr != 0);
23295 }
23296 }
23297 if (_v) {
23298 return _wrap_DateTime___sub____SWIG_0(self,args);
23299 }
23300 }
23301 }
23302 if (argc == 2) {
23303 int _v;
23304 {
23305 void *ptr;
23306 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23307 _v = 0;
23308 PyErr_Clear();
23309 } else {
23310 _v = 1;
23311 }
23312 }
23313 if (_v) {
23314 {
23315 void *ptr = 0;
23316 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23317 _v = 0;
23318 PyErr_Clear();
23319 } else {
23320 _v = (ptr != 0);
23321 }
23322 }
23323 if (_v) {
23324 return _wrap_DateTime___sub____SWIG_1(self,args);
23325 }
23326 }
23327 }
23328 if (argc == 2) {
23329 int _v;
23330 {
23331 void *ptr;
23332 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23333 _v = 0;
23334 PyErr_Clear();
23335 } else {
23336 _v = 1;
23337 }
23338 }
23339 if (_v) {
23340 {
23341 void *ptr = 0;
23342 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23343 _v = 0;
23344 PyErr_Clear();
23345 } else {
23346 _v = (ptr != 0);
23347 }
23348 }
23349 if (_v) {
23350 return _wrap_DateTime___sub____SWIG_2(self,args);
23351 }
23352 }
23353 }
23354
23355 Py_INCREF(Py_NotImplemented);
23356 return Py_NotImplemented;
23357 }
23358
23359
23360 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23361 PyObject *resultobj;
23362 wxDateTime *arg1 = (wxDateTime *) 0 ;
23363 wxDateTime *arg2 = (wxDateTime *) 0 ;
23364 bool result;
23365 PyObject * obj0 = 0 ;
23366 PyObject * obj1 = 0 ;
23367 char *kwnames[] = {
23368 (char *) "self",(char *) "other", NULL
23369 };
23370
23371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23373 if (SWIG_arg_fail(1)) SWIG_fail;
23374 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23375 if (SWIG_arg_fail(2)) SWIG_fail;
23376 {
23377 PyThreadState* __tstate = wxPyBeginAllowThreads();
23378 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23379
23380 wxPyEndAllowThreads(__tstate);
23381 if (PyErr_Occurred()) SWIG_fail;
23382 }
23383 {
23384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23385 }
23386 return resultobj;
23387 fail:
23388 return NULL;
23389 }
23390
23391
23392 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23393 PyObject *resultobj;
23394 wxDateTime *arg1 = (wxDateTime *) 0 ;
23395 wxDateTime *arg2 = (wxDateTime *) 0 ;
23396 bool result;
23397 PyObject * obj0 = 0 ;
23398 PyObject * obj1 = 0 ;
23399 char *kwnames[] = {
23400 (char *) "self",(char *) "other", NULL
23401 };
23402
23403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23405 if (SWIG_arg_fail(1)) SWIG_fail;
23406 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23407 if (SWIG_arg_fail(2)) SWIG_fail;
23408 {
23409 PyThreadState* __tstate = wxPyBeginAllowThreads();
23410 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23411
23412 wxPyEndAllowThreads(__tstate);
23413 if (PyErr_Occurred()) SWIG_fail;
23414 }
23415 {
23416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23417 }
23418 return resultobj;
23419 fail:
23420 return NULL;
23421 }
23422
23423
23424 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23425 PyObject *resultobj;
23426 wxDateTime *arg1 = (wxDateTime *) 0 ;
23427 wxDateTime *arg2 = (wxDateTime *) 0 ;
23428 bool result;
23429 PyObject * obj0 = 0 ;
23430 PyObject * obj1 = 0 ;
23431 char *kwnames[] = {
23432 (char *) "self",(char *) "other", NULL
23433 };
23434
23435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23437 if (SWIG_arg_fail(1)) SWIG_fail;
23438 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23439 if (SWIG_arg_fail(2)) SWIG_fail;
23440 {
23441 PyThreadState* __tstate = wxPyBeginAllowThreads();
23442 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23443
23444 wxPyEndAllowThreads(__tstate);
23445 if (PyErr_Occurred()) SWIG_fail;
23446 }
23447 {
23448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23449 }
23450 return resultobj;
23451 fail:
23452 return NULL;
23453 }
23454
23455
23456 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23457 PyObject *resultobj;
23458 wxDateTime *arg1 = (wxDateTime *) 0 ;
23459 wxDateTime *arg2 = (wxDateTime *) 0 ;
23460 bool result;
23461 PyObject * obj0 = 0 ;
23462 PyObject * obj1 = 0 ;
23463 char *kwnames[] = {
23464 (char *) "self",(char *) "other", NULL
23465 };
23466
23467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23469 if (SWIG_arg_fail(1)) SWIG_fail;
23470 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23471 if (SWIG_arg_fail(2)) SWIG_fail;
23472 {
23473 PyThreadState* __tstate = wxPyBeginAllowThreads();
23474 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23475
23476 wxPyEndAllowThreads(__tstate);
23477 if (PyErr_Occurred()) SWIG_fail;
23478 }
23479 {
23480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23481 }
23482 return resultobj;
23483 fail:
23484 return NULL;
23485 }
23486
23487
23488 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23489 PyObject *resultobj;
23490 wxDateTime *arg1 = (wxDateTime *) 0 ;
23491 wxDateTime *arg2 = (wxDateTime *) 0 ;
23492 bool result;
23493 PyObject * obj0 = 0 ;
23494 PyObject * obj1 = 0 ;
23495 char *kwnames[] = {
23496 (char *) "self",(char *) "other", NULL
23497 };
23498
23499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23501 if (SWIG_arg_fail(1)) SWIG_fail;
23502 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23503 if (SWIG_arg_fail(2)) SWIG_fail;
23504 {
23505 PyThreadState* __tstate = wxPyBeginAllowThreads();
23506 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23507
23508 wxPyEndAllowThreads(__tstate);
23509 if (PyErr_Occurred()) SWIG_fail;
23510 }
23511 {
23512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23513 }
23514 return resultobj;
23515 fail:
23516 return NULL;
23517 }
23518
23519
23520 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23521 PyObject *resultobj;
23522 wxDateTime *arg1 = (wxDateTime *) 0 ;
23523 wxDateTime *arg2 = (wxDateTime *) 0 ;
23524 bool result;
23525 PyObject * obj0 = 0 ;
23526 PyObject * obj1 = 0 ;
23527 char *kwnames[] = {
23528 (char *) "self",(char *) "other", NULL
23529 };
23530
23531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23533 if (SWIG_arg_fail(1)) SWIG_fail;
23534 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23535 if (SWIG_arg_fail(2)) SWIG_fail;
23536 {
23537 PyThreadState* __tstate = wxPyBeginAllowThreads();
23538 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23539
23540 wxPyEndAllowThreads(__tstate);
23541 if (PyErr_Occurred()) SWIG_fail;
23542 }
23543 {
23544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23545 }
23546 return resultobj;
23547 fail:
23548 return NULL;
23549 }
23550
23551
23552 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23553 PyObject *resultobj;
23554 wxDateTime *arg1 = (wxDateTime *) 0 ;
23555 wxString *arg2 = 0 ;
23556 int result;
23557 bool temp2 = false ;
23558 PyObject * obj0 = 0 ;
23559 PyObject * obj1 = 0 ;
23560 char *kwnames[] = {
23561 (char *) "self",(char *) "date", NULL
23562 };
23563
23564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23566 if (SWIG_arg_fail(1)) SWIG_fail;
23567 {
23568 arg2 = wxString_in_helper(obj1);
23569 if (arg2 == NULL) SWIG_fail;
23570 temp2 = true;
23571 }
23572 {
23573 PyThreadState* __tstate = wxPyBeginAllowThreads();
23574 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23575
23576 wxPyEndAllowThreads(__tstate);
23577 if (PyErr_Occurred()) SWIG_fail;
23578 }
23579 {
23580 resultobj = SWIG_From_int((int)(result));
23581 }
23582 {
23583 if (temp2)
23584 delete arg2;
23585 }
23586 return resultobj;
23587 fail:
23588 {
23589 if (temp2)
23590 delete arg2;
23591 }
23592 return NULL;
23593 }
23594
23595
23596 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23597 PyObject *resultobj;
23598 wxDateTime *arg1 = (wxDateTime *) 0 ;
23599 wxString *arg2 = 0 ;
23600 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23601 wxString *arg3 = (wxString *) &arg3_defvalue ;
23602 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23603 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23604 int result;
23605 bool temp2 = false ;
23606 bool temp3 = false ;
23607 PyObject * obj0 = 0 ;
23608 PyObject * obj1 = 0 ;
23609 PyObject * obj2 = 0 ;
23610 PyObject * obj3 = 0 ;
23611 char *kwnames[] = {
23612 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23613 };
23614
23615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23617 if (SWIG_arg_fail(1)) SWIG_fail;
23618 {
23619 arg2 = wxString_in_helper(obj1);
23620 if (arg2 == NULL) SWIG_fail;
23621 temp2 = true;
23622 }
23623 if (obj2) {
23624 {
23625 arg3 = wxString_in_helper(obj2);
23626 if (arg3 == NULL) SWIG_fail;
23627 temp3 = true;
23628 }
23629 }
23630 if (obj3) {
23631 {
23632 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23633 if (SWIG_arg_fail(4)) SWIG_fail;
23634 if (arg4 == NULL) {
23635 SWIG_null_ref("wxDateTime");
23636 }
23637 if (SWIG_arg_fail(4)) SWIG_fail;
23638 }
23639 }
23640 {
23641 PyThreadState* __tstate = wxPyBeginAllowThreads();
23642 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23643
23644 wxPyEndAllowThreads(__tstate);
23645 if (PyErr_Occurred()) SWIG_fail;
23646 }
23647 {
23648 resultobj = SWIG_From_int((int)(result));
23649 }
23650 {
23651 if (temp2)
23652 delete arg2;
23653 }
23654 {
23655 if (temp3)
23656 delete arg3;
23657 }
23658 return resultobj;
23659 fail:
23660 {
23661 if (temp2)
23662 delete arg2;
23663 }
23664 {
23665 if (temp3)
23666 delete arg3;
23667 }
23668 return NULL;
23669 }
23670
23671
23672 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23673 PyObject *resultobj;
23674 wxDateTime *arg1 = (wxDateTime *) 0 ;
23675 wxString *arg2 = 0 ;
23676 int result;
23677 bool temp2 = false ;
23678 PyObject * obj0 = 0 ;
23679 PyObject * obj1 = 0 ;
23680 char *kwnames[] = {
23681 (char *) "self",(char *) "datetime", NULL
23682 };
23683
23684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23686 if (SWIG_arg_fail(1)) SWIG_fail;
23687 {
23688 arg2 = wxString_in_helper(obj1);
23689 if (arg2 == NULL) SWIG_fail;
23690 temp2 = true;
23691 }
23692 {
23693 PyThreadState* __tstate = wxPyBeginAllowThreads();
23694 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23695
23696 wxPyEndAllowThreads(__tstate);
23697 if (PyErr_Occurred()) SWIG_fail;
23698 }
23699 {
23700 resultobj = SWIG_From_int((int)(result));
23701 }
23702 {
23703 if (temp2)
23704 delete arg2;
23705 }
23706 return resultobj;
23707 fail:
23708 {
23709 if (temp2)
23710 delete arg2;
23711 }
23712 return NULL;
23713 }
23714
23715
23716 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23717 PyObject *resultobj;
23718 wxDateTime *arg1 = (wxDateTime *) 0 ;
23719 wxString *arg2 = 0 ;
23720 int result;
23721 bool temp2 = false ;
23722 PyObject * obj0 = 0 ;
23723 PyObject * obj1 = 0 ;
23724 char *kwnames[] = {
23725 (char *) "self",(char *) "date", NULL
23726 };
23727
23728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23730 if (SWIG_arg_fail(1)) SWIG_fail;
23731 {
23732 arg2 = wxString_in_helper(obj1);
23733 if (arg2 == NULL) SWIG_fail;
23734 temp2 = true;
23735 }
23736 {
23737 PyThreadState* __tstate = wxPyBeginAllowThreads();
23738 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23739
23740 wxPyEndAllowThreads(__tstate);
23741 if (PyErr_Occurred()) SWIG_fail;
23742 }
23743 {
23744 resultobj = SWIG_From_int((int)(result));
23745 }
23746 {
23747 if (temp2)
23748 delete arg2;
23749 }
23750 return resultobj;
23751 fail:
23752 {
23753 if (temp2)
23754 delete arg2;
23755 }
23756 return NULL;
23757 }
23758
23759
23760 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23761 PyObject *resultobj;
23762 wxDateTime *arg1 = (wxDateTime *) 0 ;
23763 wxString *arg2 = 0 ;
23764 int result;
23765 bool temp2 = false ;
23766 PyObject * obj0 = 0 ;
23767 PyObject * obj1 = 0 ;
23768 char *kwnames[] = {
23769 (char *) "self",(char *) "time", NULL
23770 };
23771
23772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23774 if (SWIG_arg_fail(1)) SWIG_fail;
23775 {
23776 arg2 = wxString_in_helper(obj1);
23777 if (arg2 == NULL) SWIG_fail;
23778 temp2 = true;
23779 }
23780 {
23781 PyThreadState* __tstate = wxPyBeginAllowThreads();
23782 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23783
23784 wxPyEndAllowThreads(__tstate);
23785 if (PyErr_Occurred()) SWIG_fail;
23786 }
23787 {
23788 resultobj = SWIG_From_int((int)(result));
23789 }
23790 {
23791 if (temp2)
23792 delete arg2;
23793 }
23794 return resultobj;
23795 fail:
23796 {
23797 if (temp2)
23798 delete arg2;
23799 }
23800 return NULL;
23801 }
23802
23803
23804 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23805 PyObject *resultobj;
23806 wxDateTime *arg1 = (wxDateTime *) 0 ;
23807 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23808 wxString *arg2 = (wxString *) &arg2_defvalue ;
23809 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23810 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23811 wxString result;
23812 bool temp2 = false ;
23813 bool temp3 = false ;
23814 PyObject * obj0 = 0 ;
23815 PyObject * obj1 = 0 ;
23816 PyObject * obj2 = 0 ;
23817 char *kwnames[] = {
23818 (char *) "self",(char *) "format",(char *) "tz", NULL
23819 };
23820
23821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23823 if (SWIG_arg_fail(1)) SWIG_fail;
23824 if (obj1) {
23825 {
23826 arg2 = wxString_in_helper(obj1);
23827 if (arg2 == NULL) SWIG_fail;
23828 temp2 = true;
23829 }
23830 }
23831 if (obj2) {
23832 {
23833 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23834 temp3 = true;
23835 }
23836 }
23837 {
23838 PyThreadState* __tstate = wxPyBeginAllowThreads();
23839 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23840
23841 wxPyEndAllowThreads(__tstate);
23842 if (PyErr_Occurred()) SWIG_fail;
23843 }
23844 {
23845 #if wxUSE_UNICODE
23846 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23847 #else
23848 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23849 #endif
23850 }
23851 {
23852 if (temp2)
23853 delete arg2;
23854 }
23855 {
23856 if (temp3) delete arg3;
23857 }
23858 return resultobj;
23859 fail:
23860 {
23861 if (temp2)
23862 delete arg2;
23863 }
23864 {
23865 if (temp3) delete arg3;
23866 }
23867 return NULL;
23868 }
23869
23870
23871 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23872 PyObject *resultobj;
23873 wxDateTime *arg1 = (wxDateTime *) 0 ;
23874 wxString result;
23875 PyObject * obj0 = 0 ;
23876 char *kwnames[] = {
23877 (char *) "self", NULL
23878 };
23879
23880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23882 if (SWIG_arg_fail(1)) SWIG_fail;
23883 {
23884 PyThreadState* __tstate = wxPyBeginAllowThreads();
23885 result = ((wxDateTime const *)arg1)->FormatDate();
23886
23887 wxPyEndAllowThreads(__tstate);
23888 if (PyErr_Occurred()) SWIG_fail;
23889 }
23890 {
23891 #if wxUSE_UNICODE
23892 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23893 #else
23894 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23895 #endif
23896 }
23897 return resultobj;
23898 fail:
23899 return NULL;
23900 }
23901
23902
23903 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23904 PyObject *resultobj;
23905 wxDateTime *arg1 = (wxDateTime *) 0 ;
23906 wxString result;
23907 PyObject * obj0 = 0 ;
23908 char *kwnames[] = {
23909 (char *) "self", NULL
23910 };
23911
23912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23914 if (SWIG_arg_fail(1)) SWIG_fail;
23915 {
23916 PyThreadState* __tstate = wxPyBeginAllowThreads();
23917 result = ((wxDateTime const *)arg1)->FormatTime();
23918
23919 wxPyEndAllowThreads(__tstate);
23920 if (PyErr_Occurred()) SWIG_fail;
23921 }
23922 {
23923 #if wxUSE_UNICODE
23924 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23925 #else
23926 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23927 #endif
23928 }
23929 return resultobj;
23930 fail:
23931 return NULL;
23932 }
23933
23934
23935 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23936 PyObject *resultobj;
23937 wxDateTime *arg1 = (wxDateTime *) 0 ;
23938 wxString result;
23939 PyObject * obj0 = 0 ;
23940 char *kwnames[] = {
23941 (char *) "self", NULL
23942 };
23943
23944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23946 if (SWIG_arg_fail(1)) SWIG_fail;
23947 {
23948 PyThreadState* __tstate = wxPyBeginAllowThreads();
23949 result = ((wxDateTime const *)arg1)->FormatISODate();
23950
23951 wxPyEndAllowThreads(__tstate);
23952 if (PyErr_Occurred()) SWIG_fail;
23953 }
23954 {
23955 #if wxUSE_UNICODE
23956 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23957 #else
23958 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23959 #endif
23960 }
23961 return resultobj;
23962 fail:
23963 return NULL;
23964 }
23965
23966
23967 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23968 PyObject *resultobj;
23969 wxDateTime *arg1 = (wxDateTime *) 0 ;
23970 wxString result;
23971 PyObject * obj0 = 0 ;
23972 char *kwnames[] = {
23973 (char *) "self", NULL
23974 };
23975
23976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23978 if (SWIG_arg_fail(1)) SWIG_fail;
23979 {
23980 PyThreadState* __tstate = wxPyBeginAllowThreads();
23981 result = ((wxDateTime const *)arg1)->FormatISOTime();
23982
23983 wxPyEndAllowThreads(__tstate);
23984 if (PyErr_Occurred()) SWIG_fail;
23985 }
23986 {
23987 #if wxUSE_UNICODE
23988 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23989 #else
23990 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23991 #endif
23992 }
23993 return resultobj;
23994 fail:
23995 return NULL;
23996 }
23997
23998
23999 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
24000 PyObject *obj;
24001 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24002 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
24003 Py_INCREF(obj);
24004 return Py_BuildValue((char *)"");
24005 }
24006 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
24007 PyObject *resultobj;
24008 long arg1 ;
24009 wxTimeSpan result;
24010 PyObject * obj0 = 0 ;
24011 char *kwnames[] = {
24012 (char *) "sec", NULL
24013 };
24014
24015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
24016 {
24017 arg1 = (long)(SWIG_As_long(obj0));
24018 if (SWIG_arg_fail(1)) SWIG_fail;
24019 }
24020 {
24021 PyThreadState* __tstate = wxPyBeginAllowThreads();
24022 result = wxTimeSpan::Seconds(arg1);
24023
24024 wxPyEndAllowThreads(__tstate);
24025 if (PyErr_Occurred()) SWIG_fail;
24026 }
24027 {
24028 wxTimeSpan * resultptr;
24029 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24030 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24031 }
24032 return resultobj;
24033 fail:
24034 return NULL;
24035 }
24036
24037
24038 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
24039 PyObject *resultobj;
24040 wxTimeSpan result;
24041 char *kwnames[] = {
24042 NULL
24043 };
24044
24045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
24046 {
24047 PyThreadState* __tstate = wxPyBeginAllowThreads();
24048 result = wxTimeSpan::Second();
24049
24050 wxPyEndAllowThreads(__tstate);
24051 if (PyErr_Occurred()) SWIG_fail;
24052 }
24053 {
24054 wxTimeSpan * resultptr;
24055 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24056 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24057 }
24058 return resultobj;
24059 fail:
24060 return NULL;
24061 }
24062
24063
24064 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
24065 PyObject *resultobj;
24066 long arg1 ;
24067 wxTimeSpan result;
24068 PyObject * obj0 = 0 ;
24069 char *kwnames[] = {
24070 (char *) "min", NULL
24071 };
24072
24073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
24074 {
24075 arg1 = (long)(SWIG_As_long(obj0));
24076 if (SWIG_arg_fail(1)) SWIG_fail;
24077 }
24078 {
24079 PyThreadState* __tstate = wxPyBeginAllowThreads();
24080 result = wxTimeSpan::Minutes(arg1);
24081
24082 wxPyEndAllowThreads(__tstate);
24083 if (PyErr_Occurred()) SWIG_fail;
24084 }
24085 {
24086 wxTimeSpan * resultptr;
24087 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24088 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24089 }
24090 return resultobj;
24091 fail:
24092 return NULL;
24093 }
24094
24095
24096 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
24097 PyObject *resultobj;
24098 wxTimeSpan result;
24099 char *kwnames[] = {
24100 NULL
24101 };
24102
24103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
24104 {
24105 PyThreadState* __tstate = wxPyBeginAllowThreads();
24106 result = wxTimeSpan::Minute();
24107
24108 wxPyEndAllowThreads(__tstate);
24109 if (PyErr_Occurred()) SWIG_fail;
24110 }
24111 {
24112 wxTimeSpan * resultptr;
24113 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24114 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24115 }
24116 return resultobj;
24117 fail:
24118 return NULL;
24119 }
24120
24121
24122 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
24123 PyObject *resultobj;
24124 long arg1 ;
24125 wxTimeSpan result;
24126 PyObject * obj0 = 0 ;
24127 char *kwnames[] = {
24128 (char *) "hours", NULL
24129 };
24130
24131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
24132 {
24133 arg1 = (long)(SWIG_As_long(obj0));
24134 if (SWIG_arg_fail(1)) SWIG_fail;
24135 }
24136 {
24137 PyThreadState* __tstate = wxPyBeginAllowThreads();
24138 result = wxTimeSpan::Hours(arg1);
24139
24140 wxPyEndAllowThreads(__tstate);
24141 if (PyErr_Occurred()) SWIG_fail;
24142 }
24143 {
24144 wxTimeSpan * resultptr;
24145 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24146 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24147 }
24148 return resultobj;
24149 fail:
24150 return NULL;
24151 }
24152
24153
24154 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
24155 PyObject *resultobj;
24156 wxTimeSpan result;
24157 char *kwnames[] = {
24158 NULL
24159 };
24160
24161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
24162 {
24163 PyThreadState* __tstate = wxPyBeginAllowThreads();
24164 result = wxTimeSpan::Hour();
24165
24166 wxPyEndAllowThreads(__tstate);
24167 if (PyErr_Occurred()) SWIG_fail;
24168 }
24169 {
24170 wxTimeSpan * resultptr;
24171 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24172 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24173 }
24174 return resultobj;
24175 fail:
24176 return NULL;
24177 }
24178
24179
24180 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24181 PyObject *resultobj;
24182 long arg1 ;
24183 wxTimeSpan result;
24184 PyObject * obj0 = 0 ;
24185 char *kwnames[] = {
24186 (char *) "days", NULL
24187 };
24188
24189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24190 {
24191 arg1 = (long)(SWIG_As_long(obj0));
24192 if (SWIG_arg_fail(1)) SWIG_fail;
24193 }
24194 {
24195 PyThreadState* __tstate = wxPyBeginAllowThreads();
24196 result = wxTimeSpan::Days(arg1);
24197
24198 wxPyEndAllowThreads(__tstate);
24199 if (PyErr_Occurred()) SWIG_fail;
24200 }
24201 {
24202 wxTimeSpan * resultptr;
24203 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24204 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24205 }
24206 return resultobj;
24207 fail:
24208 return NULL;
24209 }
24210
24211
24212 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24213 PyObject *resultobj;
24214 wxTimeSpan result;
24215 char *kwnames[] = {
24216 NULL
24217 };
24218
24219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24220 {
24221 PyThreadState* __tstate = wxPyBeginAllowThreads();
24222 result = wxTimeSpan::Day();
24223
24224 wxPyEndAllowThreads(__tstate);
24225 if (PyErr_Occurred()) SWIG_fail;
24226 }
24227 {
24228 wxTimeSpan * resultptr;
24229 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24230 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24231 }
24232 return resultobj;
24233 fail:
24234 return NULL;
24235 }
24236
24237
24238 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24239 PyObject *resultobj;
24240 long arg1 ;
24241 wxTimeSpan result;
24242 PyObject * obj0 = 0 ;
24243 char *kwnames[] = {
24244 (char *) "days", NULL
24245 };
24246
24247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24248 {
24249 arg1 = (long)(SWIG_As_long(obj0));
24250 if (SWIG_arg_fail(1)) SWIG_fail;
24251 }
24252 {
24253 PyThreadState* __tstate = wxPyBeginAllowThreads();
24254 result = wxTimeSpan::Weeks(arg1);
24255
24256 wxPyEndAllowThreads(__tstate);
24257 if (PyErr_Occurred()) SWIG_fail;
24258 }
24259 {
24260 wxTimeSpan * resultptr;
24261 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24262 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24263 }
24264 return resultobj;
24265 fail:
24266 return NULL;
24267 }
24268
24269
24270 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24271 PyObject *resultobj;
24272 wxTimeSpan result;
24273 char *kwnames[] = {
24274 NULL
24275 };
24276
24277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24278 {
24279 PyThreadState* __tstate = wxPyBeginAllowThreads();
24280 result = wxTimeSpan::Week();
24281
24282 wxPyEndAllowThreads(__tstate);
24283 if (PyErr_Occurred()) SWIG_fail;
24284 }
24285 {
24286 wxTimeSpan * resultptr;
24287 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24288 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24289 }
24290 return resultobj;
24291 fail:
24292 return NULL;
24293 }
24294
24295
24296 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24297 PyObject *resultobj;
24298 long arg1 = (long) 0 ;
24299 long arg2 = (long) 0 ;
24300 long arg3 = (long) 0 ;
24301 long arg4 = (long) 0 ;
24302 wxTimeSpan *result;
24303 PyObject * obj0 = 0 ;
24304 PyObject * obj1 = 0 ;
24305 PyObject * obj2 = 0 ;
24306 PyObject * obj3 = 0 ;
24307 char *kwnames[] = {
24308 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24309 };
24310
24311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24312 if (obj0) {
24313 {
24314 arg1 = (long)(SWIG_As_long(obj0));
24315 if (SWIG_arg_fail(1)) SWIG_fail;
24316 }
24317 }
24318 if (obj1) {
24319 {
24320 arg2 = (long)(SWIG_As_long(obj1));
24321 if (SWIG_arg_fail(2)) SWIG_fail;
24322 }
24323 }
24324 if (obj2) {
24325 {
24326 arg3 = (long)(SWIG_As_long(obj2));
24327 if (SWIG_arg_fail(3)) SWIG_fail;
24328 }
24329 }
24330 if (obj3) {
24331 {
24332 arg4 = (long)(SWIG_As_long(obj3));
24333 if (SWIG_arg_fail(4)) SWIG_fail;
24334 }
24335 }
24336 {
24337 PyThreadState* __tstate = wxPyBeginAllowThreads();
24338 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24339
24340 wxPyEndAllowThreads(__tstate);
24341 if (PyErr_Occurred()) SWIG_fail;
24342 }
24343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24344 return resultobj;
24345 fail:
24346 return NULL;
24347 }
24348
24349
24350 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24351 PyObject *resultobj;
24352 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24353 PyObject * obj0 = 0 ;
24354 char *kwnames[] = {
24355 (char *) "self", NULL
24356 };
24357
24358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24360 if (SWIG_arg_fail(1)) SWIG_fail;
24361 {
24362 PyThreadState* __tstate = wxPyBeginAllowThreads();
24363 delete arg1;
24364
24365 wxPyEndAllowThreads(__tstate);
24366 if (PyErr_Occurred()) SWIG_fail;
24367 }
24368 Py_INCREF(Py_None); resultobj = Py_None;
24369 return resultobj;
24370 fail:
24371 return NULL;
24372 }
24373
24374
24375 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24376 PyObject *resultobj;
24377 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24378 wxTimeSpan *arg2 = 0 ;
24379 wxTimeSpan *result;
24380 PyObject * obj0 = 0 ;
24381 PyObject * obj1 = 0 ;
24382 char *kwnames[] = {
24383 (char *) "self",(char *) "diff", NULL
24384 };
24385
24386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24388 if (SWIG_arg_fail(1)) SWIG_fail;
24389 {
24390 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24391 if (SWIG_arg_fail(2)) SWIG_fail;
24392 if (arg2 == NULL) {
24393 SWIG_null_ref("wxTimeSpan");
24394 }
24395 if (SWIG_arg_fail(2)) SWIG_fail;
24396 }
24397 {
24398 PyThreadState* __tstate = wxPyBeginAllowThreads();
24399 {
24400 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24401 result = (wxTimeSpan *) &_result_ref;
24402 }
24403
24404 wxPyEndAllowThreads(__tstate);
24405 if (PyErr_Occurred()) SWIG_fail;
24406 }
24407 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24408 return resultobj;
24409 fail:
24410 return NULL;
24411 }
24412
24413
24414 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24415 PyObject *resultobj;
24416 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24417 wxTimeSpan *arg2 = 0 ;
24418 wxTimeSpan *result;
24419 PyObject * obj0 = 0 ;
24420 PyObject * obj1 = 0 ;
24421 char *kwnames[] = {
24422 (char *) "self",(char *) "diff", NULL
24423 };
24424
24425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24427 if (SWIG_arg_fail(1)) SWIG_fail;
24428 {
24429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24430 if (SWIG_arg_fail(2)) SWIG_fail;
24431 if (arg2 == NULL) {
24432 SWIG_null_ref("wxTimeSpan");
24433 }
24434 if (SWIG_arg_fail(2)) SWIG_fail;
24435 }
24436 {
24437 PyThreadState* __tstate = wxPyBeginAllowThreads();
24438 {
24439 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24440 result = (wxTimeSpan *) &_result_ref;
24441 }
24442
24443 wxPyEndAllowThreads(__tstate);
24444 if (PyErr_Occurred()) SWIG_fail;
24445 }
24446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24447 return resultobj;
24448 fail:
24449 return NULL;
24450 }
24451
24452
24453 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24454 PyObject *resultobj;
24455 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24456 int arg2 ;
24457 wxTimeSpan *result;
24458 PyObject * obj0 = 0 ;
24459 PyObject * obj1 = 0 ;
24460 char *kwnames[] = {
24461 (char *) "self",(char *) "n", NULL
24462 };
24463
24464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24466 if (SWIG_arg_fail(1)) SWIG_fail;
24467 {
24468 arg2 = (int)(SWIG_As_int(obj1));
24469 if (SWIG_arg_fail(2)) SWIG_fail;
24470 }
24471 {
24472 PyThreadState* __tstate = wxPyBeginAllowThreads();
24473 {
24474 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24475 result = (wxTimeSpan *) &_result_ref;
24476 }
24477
24478 wxPyEndAllowThreads(__tstate);
24479 if (PyErr_Occurred()) SWIG_fail;
24480 }
24481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24482 return resultobj;
24483 fail:
24484 return NULL;
24485 }
24486
24487
24488 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24489 PyObject *resultobj;
24490 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24491 wxTimeSpan *result;
24492 PyObject * obj0 = 0 ;
24493 char *kwnames[] = {
24494 (char *) "self", NULL
24495 };
24496
24497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24499 if (SWIG_arg_fail(1)) SWIG_fail;
24500 {
24501 PyThreadState* __tstate = wxPyBeginAllowThreads();
24502 {
24503 wxTimeSpan &_result_ref = (arg1)->Neg();
24504 result = (wxTimeSpan *) &_result_ref;
24505 }
24506
24507 wxPyEndAllowThreads(__tstate);
24508 if (PyErr_Occurred()) SWIG_fail;
24509 }
24510 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24511 return resultobj;
24512 fail:
24513 return NULL;
24514 }
24515
24516
24517 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24518 PyObject *resultobj;
24519 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24520 wxTimeSpan result;
24521 PyObject * obj0 = 0 ;
24522 char *kwnames[] = {
24523 (char *) "self", NULL
24524 };
24525
24526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
24531 result = ((wxTimeSpan const *)arg1)->Abs();
24532
24533 wxPyEndAllowThreads(__tstate);
24534 if (PyErr_Occurred()) SWIG_fail;
24535 }
24536 {
24537 wxTimeSpan * resultptr;
24538 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24539 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24540 }
24541 return resultobj;
24542 fail:
24543 return NULL;
24544 }
24545
24546
24547 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24548 PyObject *resultobj;
24549 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24550 wxTimeSpan *arg2 = 0 ;
24551 wxTimeSpan *result;
24552 PyObject * obj0 = 0 ;
24553 PyObject * obj1 = 0 ;
24554 char *kwnames[] = {
24555 (char *) "self",(char *) "diff", NULL
24556 };
24557
24558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24560 if (SWIG_arg_fail(1)) SWIG_fail;
24561 {
24562 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24563 if (SWIG_arg_fail(2)) SWIG_fail;
24564 if (arg2 == NULL) {
24565 SWIG_null_ref("wxTimeSpan");
24566 }
24567 if (SWIG_arg_fail(2)) SWIG_fail;
24568 }
24569 {
24570 PyThreadState* __tstate = wxPyBeginAllowThreads();
24571 {
24572 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24573 result = (wxTimeSpan *) &_result_ref;
24574 }
24575
24576 wxPyEndAllowThreads(__tstate);
24577 if (PyErr_Occurred()) SWIG_fail;
24578 }
24579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24580 return resultobj;
24581 fail:
24582 return NULL;
24583 }
24584
24585
24586 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24587 PyObject *resultobj;
24588 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24589 wxTimeSpan *arg2 = 0 ;
24590 wxTimeSpan *result;
24591 PyObject * obj0 = 0 ;
24592 PyObject * obj1 = 0 ;
24593 char *kwnames[] = {
24594 (char *) "self",(char *) "diff", NULL
24595 };
24596
24597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24599 if (SWIG_arg_fail(1)) SWIG_fail;
24600 {
24601 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24602 if (SWIG_arg_fail(2)) SWIG_fail;
24603 if (arg2 == NULL) {
24604 SWIG_null_ref("wxTimeSpan");
24605 }
24606 if (SWIG_arg_fail(2)) SWIG_fail;
24607 }
24608 {
24609 PyThreadState* __tstate = wxPyBeginAllowThreads();
24610 {
24611 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24612 result = (wxTimeSpan *) &_result_ref;
24613 }
24614
24615 wxPyEndAllowThreads(__tstate);
24616 if (PyErr_Occurred()) SWIG_fail;
24617 }
24618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24619 return resultobj;
24620 fail:
24621 return NULL;
24622 }
24623
24624
24625 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24626 PyObject *resultobj;
24627 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24628 int arg2 ;
24629 wxTimeSpan *result;
24630 PyObject * obj0 = 0 ;
24631 PyObject * obj1 = 0 ;
24632 char *kwnames[] = {
24633 (char *) "self",(char *) "n", NULL
24634 };
24635
24636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24638 if (SWIG_arg_fail(1)) SWIG_fail;
24639 {
24640 arg2 = (int)(SWIG_As_int(obj1));
24641 if (SWIG_arg_fail(2)) SWIG_fail;
24642 }
24643 {
24644 PyThreadState* __tstate = wxPyBeginAllowThreads();
24645 {
24646 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24647 result = (wxTimeSpan *) &_result_ref;
24648 }
24649
24650 wxPyEndAllowThreads(__tstate);
24651 if (PyErr_Occurred()) SWIG_fail;
24652 }
24653 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24654 return resultobj;
24655 fail:
24656 return NULL;
24657 }
24658
24659
24660 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24661 PyObject *resultobj;
24662 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24663 wxTimeSpan *result;
24664 PyObject * obj0 = 0 ;
24665 char *kwnames[] = {
24666 (char *) "self", NULL
24667 };
24668
24669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24671 if (SWIG_arg_fail(1)) SWIG_fail;
24672 {
24673 PyThreadState* __tstate = wxPyBeginAllowThreads();
24674 {
24675 wxTimeSpan &_result_ref = (arg1)->operator -();
24676 result = (wxTimeSpan *) &_result_ref;
24677 }
24678
24679 wxPyEndAllowThreads(__tstate);
24680 if (PyErr_Occurred()) SWIG_fail;
24681 }
24682 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24683 return resultobj;
24684 fail:
24685 return NULL;
24686 }
24687
24688
24689 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24690 PyObject *resultobj;
24691 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24692 wxTimeSpan *arg2 = 0 ;
24693 wxTimeSpan result;
24694 PyObject * obj0 = 0 ;
24695 PyObject * obj1 = 0 ;
24696 char *kwnames[] = {
24697 (char *) "self",(char *) "other", NULL
24698 };
24699
24700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24702 if (SWIG_arg_fail(1)) SWIG_fail;
24703 {
24704 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24705 if (SWIG_arg_fail(2)) SWIG_fail;
24706 if (arg2 == NULL) {
24707 SWIG_null_ref("wxTimeSpan");
24708 }
24709 if (SWIG_arg_fail(2)) SWIG_fail;
24710 }
24711 {
24712 PyThreadState* __tstate = wxPyBeginAllowThreads();
24713 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24714
24715 wxPyEndAllowThreads(__tstate);
24716 if (PyErr_Occurred()) SWIG_fail;
24717 }
24718 {
24719 wxTimeSpan * resultptr;
24720 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24721 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24722 }
24723 return resultobj;
24724 fail:
24725 return NULL;
24726 }
24727
24728
24729 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24730 PyObject *resultobj;
24731 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24732 wxTimeSpan *arg2 = 0 ;
24733 wxTimeSpan result;
24734 PyObject * obj0 = 0 ;
24735 PyObject * obj1 = 0 ;
24736 char *kwnames[] = {
24737 (char *) "self",(char *) "other", NULL
24738 };
24739
24740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24742 if (SWIG_arg_fail(1)) SWIG_fail;
24743 {
24744 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24745 if (SWIG_arg_fail(2)) SWIG_fail;
24746 if (arg2 == NULL) {
24747 SWIG_null_ref("wxTimeSpan");
24748 }
24749 if (SWIG_arg_fail(2)) SWIG_fail;
24750 }
24751 {
24752 PyThreadState* __tstate = wxPyBeginAllowThreads();
24753 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24754
24755 wxPyEndAllowThreads(__tstate);
24756 if (PyErr_Occurred()) SWIG_fail;
24757 }
24758 {
24759 wxTimeSpan * resultptr;
24760 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24761 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24762 }
24763 return resultobj;
24764 fail:
24765 return NULL;
24766 }
24767
24768
24769 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24770 PyObject *resultobj;
24771 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24772 int arg2 ;
24773 wxTimeSpan result;
24774 PyObject * obj0 = 0 ;
24775 PyObject * obj1 = 0 ;
24776 char *kwnames[] = {
24777 (char *) "self",(char *) "n", NULL
24778 };
24779
24780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
24785 if (SWIG_arg_fail(2)) SWIG_fail;
24786 }
24787 {
24788 PyThreadState* __tstate = wxPyBeginAllowThreads();
24789 result = wxTimeSpan___mul__(arg1,arg2);
24790
24791 wxPyEndAllowThreads(__tstate);
24792 if (PyErr_Occurred()) SWIG_fail;
24793 }
24794 {
24795 wxTimeSpan * resultptr;
24796 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24797 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24798 }
24799 return resultobj;
24800 fail:
24801 return NULL;
24802 }
24803
24804
24805 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24806 PyObject *resultobj;
24807 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24808 int arg2 ;
24809 wxTimeSpan result;
24810 PyObject * obj0 = 0 ;
24811 PyObject * obj1 = 0 ;
24812 char *kwnames[] = {
24813 (char *) "self",(char *) "n", NULL
24814 };
24815
24816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24818 if (SWIG_arg_fail(1)) SWIG_fail;
24819 {
24820 arg2 = (int)(SWIG_As_int(obj1));
24821 if (SWIG_arg_fail(2)) SWIG_fail;
24822 }
24823 {
24824 PyThreadState* __tstate = wxPyBeginAllowThreads();
24825 result = wxTimeSpan___rmul__(arg1,arg2);
24826
24827 wxPyEndAllowThreads(__tstate);
24828 if (PyErr_Occurred()) SWIG_fail;
24829 }
24830 {
24831 wxTimeSpan * resultptr;
24832 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24833 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24834 }
24835 return resultobj;
24836 fail:
24837 return NULL;
24838 }
24839
24840
24841 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24842 PyObject *resultobj;
24843 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24844 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24845 bool result;
24846 PyObject * obj0 = 0 ;
24847 PyObject * obj1 = 0 ;
24848 char *kwnames[] = {
24849 (char *) "self",(char *) "other", NULL
24850 };
24851
24852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24854 if (SWIG_arg_fail(1)) SWIG_fail;
24855 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24856 if (SWIG_arg_fail(2)) SWIG_fail;
24857 {
24858 PyThreadState* __tstate = wxPyBeginAllowThreads();
24859 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24860
24861 wxPyEndAllowThreads(__tstate);
24862 if (PyErr_Occurred()) SWIG_fail;
24863 }
24864 {
24865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24866 }
24867 return resultobj;
24868 fail:
24869 return NULL;
24870 }
24871
24872
24873 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24874 PyObject *resultobj;
24875 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24876 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24877 bool result;
24878 PyObject * obj0 = 0 ;
24879 PyObject * obj1 = 0 ;
24880 char *kwnames[] = {
24881 (char *) "self",(char *) "other", NULL
24882 };
24883
24884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24886 if (SWIG_arg_fail(1)) SWIG_fail;
24887 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24888 if (SWIG_arg_fail(2)) SWIG_fail;
24889 {
24890 PyThreadState* __tstate = wxPyBeginAllowThreads();
24891 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24892
24893 wxPyEndAllowThreads(__tstate);
24894 if (PyErr_Occurred()) SWIG_fail;
24895 }
24896 {
24897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24898 }
24899 return resultobj;
24900 fail:
24901 return NULL;
24902 }
24903
24904
24905 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24906 PyObject *resultobj;
24907 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24908 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24909 bool result;
24910 PyObject * obj0 = 0 ;
24911 PyObject * obj1 = 0 ;
24912 char *kwnames[] = {
24913 (char *) "self",(char *) "other", NULL
24914 };
24915
24916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24918 if (SWIG_arg_fail(1)) SWIG_fail;
24919 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24920 if (SWIG_arg_fail(2)) SWIG_fail;
24921 {
24922 PyThreadState* __tstate = wxPyBeginAllowThreads();
24923 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24924
24925 wxPyEndAllowThreads(__tstate);
24926 if (PyErr_Occurred()) SWIG_fail;
24927 }
24928 {
24929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24930 }
24931 return resultobj;
24932 fail:
24933 return NULL;
24934 }
24935
24936
24937 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24938 PyObject *resultobj;
24939 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24940 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24941 bool result;
24942 PyObject * obj0 = 0 ;
24943 PyObject * obj1 = 0 ;
24944 char *kwnames[] = {
24945 (char *) "self",(char *) "other", NULL
24946 };
24947
24948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24950 if (SWIG_arg_fail(1)) SWIG_fail;
24951 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24952 if (SWIG_arg_fail(2)) SWIG_fail;
24953 {
24954 PyThreadState* __tstate = wxPyBeginAllowThreads();
24955 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24956
24957 wxPyEndAllowThreads(__tstate);
24958 if (PyErr_Occurred()) SWIG_fail;
24959 }
24960 {
24961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24962 }
24963 return resultobj;
24964 fail:
24965 return NULL;
24966 }
24967
24968
24969 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24970 PyObject *resultobj;
24971 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24972 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24973 bool result;
24974 PyObject * obj0 = 0 ;
24975 PyObject * obj1 = 0 ;
24976 char *kwnames[] = {
24977 (char *) "self",(char *) "other", NULL
24978 };
24979
24980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24982 if (SWIG_arg_fail(1)) SWIG_fail;
24983 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24984 if (SWIG_arg_fail(2)) SWIG_fail;
24985 {
24986 PyThreadState* __tstate = wxPyBeginAllowThreads();
24987 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24988
24989 wxPyEndAllowThreads(__tstate);
24990 if (PyErr_Occurred()) SWIG_fail;
24991 }
24992 {
24993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24994 }
24995 return resultobj;
24996 fail:
24997 return NULL;
24998 }
24999
25000
25001 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
25002 PyObject *resultobj;
25003 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25004 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25005 bool result;
25006 PyObject * obj0 = 0 ;
25007 PyObject * obj1 = 0 ;
25008 char *kwnames[] = {
25009 (char *) "self",(char *) "other", NULL
25010 };
25011
25012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
25013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25014 if (SWIG_arg_fail(1)) SWIG_fail;
25015 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25016 if (SWIG_arg_fail(2)) SWIG_fail;
25017 {
25018 PyThreadState* __tstate = wxPyBeginAllowThreads();
25019 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
25020
25021 wxPyEndAllowThreads(__tstate);
25022 if (PyErr_Occurred()) SWIG_fail;
25023 }
25024 {
25025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25026 }
25027 return resultobj;
25028 fail:
25029 return NULL;
25030 }
25031
25032
25033 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
25034 PyObject *resultobj;
25035 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25036 bool result;
25037 PyObject * obj0 = 0 ;
25038 char *kwnames[] = {
25039 (char *) "self", NULL
25040 };
25041
25042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
25043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25044 if (SWIG_arg_fail(1)) SWIG_fail;
25045 {
25046 PyThreadState* __tstate = wxPyBeginAllowThreads();
25047 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
25048
25049 wxPyEndAllowThreads(__tstate);
25050 if (PyErr_Occurred()) SWIG_fail;
25051 }
25052 {
25053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25054 }
25055 return resultobj;
25056 fail:
25057 return NULL;
25058 }
25059
25060
25061 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
25062 PyObject *resultobj;
25063 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25064 bool result;
25065 PyObject * obj0 = 0 ;
25066 char *kwnames[] = {
25067 (char *) "self", NULL
25068 };
25069
25070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
25071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25072 if (SWIG_arg_fail(1)) SWIG_fail;
25073 {
25074 PyThreadState* __tstate = wxPyBeginAllowThreads();
25075 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
25076
25077 wxPyEndAllowThreads(__tstate);
25078 if (PyErr_Occurred()) SWIG_fail;
25079 }
25080 {
25081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25082 }
25083 return resultobj;
25084 fail:
25085 return NULL;
25086 }
25087
25088
25089 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
25090 PyObject *resultobj;
25091 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25092 bool result;
25093 PyObject * obj0 = 0 ;
25094 char *kwnames[] = {
25095 (char *) "self", NULL
25096 };
25097
25098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
25099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25100 if (SWIG_arg_fail(1)) SWIG_fail;
25101 {
25102 PyThreadState* __tstate = wxPyBeginAllowThreads();
25103 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
25104
25105 wxPyEndAllowThreads(__tstate);
25106 if (PyErr_Occurred()) SWIG_fail;
25107 }
25108 {
25109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25110 }
25111 return resultobj;
25112 fail:
25113 return NULL;
25114 }
25115
25116
25117 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
25118 PyObject *resultobj;
25119 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25120 wxTimeSpan *arg2 = 0 ;
25121 bool result;
25122 PyObject * obj0 = 0 ;
25123 PyObject * obj1 = 0 ;
25124 char *kwnames[] = {
25125 (char *) "self",(char *) "ts", NULL
25126 };
25127
25128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
25129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25130 if (SWIG_arg_fail(1)) SWIG_fail;
25131 {
25132 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25133 if (SWIG_arg_fail(2)) SWIG_fail;
25134 if (arg2 == NULL) {
25135 SWIG_null_ref("wxTimeSpan");
25136 }
25137 if (SWIG_arg_fail(2)) SWIG_fail;
25138 }
25139 {
25140 PyThreadState* __tstate = wxPyBeginAllowThreads();
25141 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
25142
25143 wxPyEndAllowThreads(__tstate);
25144 if (PyErr_Occurred()) SWIG_fail;
25145 }
25146 {
25147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25148 }
25149 return resultobj;
25150 fail:
25151 return NULL;
25152 }
25153
25154
25155 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
25156 PyObject *resultobj;
25157 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25158 wxTimeSpan *arg2 = 0 ;
25159 bool result;
25160 PyObject * obj0 = 0 ;
25161 PyObject * obj1 = 0 ;
25162 char *kwnames[] = {
25163 (char *) "self",(char *) "ts", NULL
25164 };
25165
25166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
25167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25168 if (SWIG_arg_fail(1)) SWIG_fail;
25169 {
25170 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25171 if (SWIG_arg_fail(2)) SWIG_fail;
25172 if (arg2 == NULL) {
25173 SWIG_null_ref("wxTimeSpan");
25174 }
25175 if (SWIG_arg_fail(2)) SWIG_fail;
25176 }
25177 {
25178 PyThreadState* __tstate = wxPyBeginAllowThreads();
25179 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
25180
25181 wxPyEndAllowThreads(__tstate);
25182 if (PyErr_Occurred()) SWIG_fail;
25183 }
25184 {
25185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25186 }
25187 return resultobj;
25188 fail:
25189 return NULL;
25190 }
25191
25192
25193 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25194 PyObject *resultobj;
25195 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25196 wxTimeSpan *arg2 = 0 ;
25197 bool result;
25198 PyObject * obj0 = 0 ;
25199 PyObject * obj1 = 0 ;
25200 char *kwnames[] = {
25201 (char *) "self",(char *) "t", NULL
25202 };
25203
25204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25206 if (SWIG_arg_fail(1)) SWIG_fail;
25207 {
25208 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25209 if (SWIG_arg_fail(2)) SWIG_fail;
25210 if (arg2 == NULL) {
25211 SWIG_null_ref("wxTimeSpan");
25212 }
25213 if (SWIG_arg_fail(2)) SWIG_fail;
25214 }
25215 {
25216 PyThreadState* __tstate = wxPyBeginAllowThreads();
25217 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25218
25219 wxPyEndAllowThreads(__tstate);
25220 if (PyErr_Occurred()) SWIG_fail;
25221 }
25222 {
25223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25224 }
25225 return resultobj;
25226 fail:
25227 return NULL;
25228 }
25229
25230
25231 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25232 PyObject *resultobj;
25233 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25234 int result;
25235 PyObject * obj0 = 0 ;
25236 char *kwnames[] = {
25237 (char *) "self", NULL
25238 };
25239
25240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25242 if (SWIG_arg_fail(1)) SWIG_fail;
25243 {
25244 PyThreadState* __tstate = wxPyBeginAllowThreads();
25245 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25246
25247 wxPyEndAllowThreads(__tstate);
25248 if (PyErr_Occurred()) SWIG_fail;
25249 }
25250 {
25251 resultobj = SWIG_From_int((int)(result));
25252 }
25253 return resultobj;
25254 fail:
25255 return NULL;
25256 }
25257
25258
25259 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25260 PyObject *resultobj;
25261 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25262 int result;
25263 PyObject * obj0 = 0 ;
25264 char *kwnames[] = {
25265 (char *) "self", NULL
25266 };
25267
25268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25270 if (SWIG_arg_fail(1)) SWIG_fail;
25271 {
25272 PyThreadState* __tstate = wxPyBeginAllowThreads();
25273 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25274
25275 wxPyEndAllowThreads(__tstate);
25276 if (PyErr_Occurred()) SWIG_fail;
25277 }
25278 {
25279 resultobj = SWIG_From_int((int)(result));
25280 }
25281 return resultobj;
25282 fail:
25283 return NULL;
25284 }
25285
25286
25287 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25288 PyObject *resultobj;
25289 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25290 int result;
25291 PyObject * obj0 = 0 ;
25292 char *kwnames[] = {
25293 (char *) "self", NULL
25294 };
25295
25296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25298 if (SWIG_arg_fail(1)) SWIG_fail;
25299 {
25300 PyThreadState* __tstate = wxPyBeginAllowThreads();
25301 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25302
25303 wxPyEndAllowThreads(__tstate);
25304 if (PyErr_Occurred()) SWIG_fail;
25305 }
25306 {
25307 resultobj = SWIG_From_int((int)(result));
25308 }
25309 return resultobj;
25310 fail:
25311 return NULL;
25312 }
25313
25314
25315 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25316 PyObject *resultobj;
25317 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25318 int result;
25319 PyObject * obj0 = 0 ;
25320 char *kwnames[] = {
25321 (char *) "self", NULL
25322 };
25323
25324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25326 if (SWIG_arg_fail(1)) SWIG_fail;
25327 {
25328 PyThreadState* __tstate = wxPyBeginAllowThreads();
25329 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25330
25331 wxPyEndAllowThreads(__tstate);
25332 if (PyErr_Occurred()) SWIG_fail;
25333 }
25334 {
25335 resultobj = SWIG_From_int((int)(result));
25336 }
25337 return resultobj;
25338 fail:
25339 return NULL;
25340 }
25341
25342
25343 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25344 PyObject *resultobj;
25345 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25346 wxLongLong result;
25347 PyObject * obj0 = 0 ;
25348 char *kwnames[] = {
25349 (char *) "self", NULL
25350 };
25351
25352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25354 if (SWIG_arg_fail(1)) SWIG_fail;
25355 {
25356 PyThreadState* __tstate = wxPyBeginAllowThreads();
25357 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25358
25359 wxPyEndAllowThreads(__tstate);
25360 if (PyErr_Occurred()) SWIG_fail;
25361 }
25362 {
25363 PyObject *hi, *lo, *shifter, *shifted;
25364 hi = PyLong_FromLong( (&result)->GetHi() );
25365 lo = PyLong_FromLong( (&result)->GetLo() );
25366 shifter = PyLong_FromLong(32);
25367 shifted = PyNumber_Lshift(hi, shifter);
25368 resultobj = PyNumber_Or(shifted, lo);
25369 Py_DECREF(hi);
25370 Py_DECREF(lo);
25371 Py_DECREF(shifter);
25372 Py_DECREF(shifted);
25373 }
25374 return resultobj;
25375 fail:
25376 return NULL;
25377 }
25378
25379
25380 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25381 PyObject *resultobj;
25382 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25383 wxLongLong result;
25384 PyObject * obj0 = 0 ;
25385 char *kwnames[] = {
25386 (char *) "self", NULL
25387 };
25388
25389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25391 if (SWIG_arg_fail(1)) SWIG_fail;
25392 {
25393 PyThreadState* __tstate = wxPyBeginAllowThreads();
25394 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25395
25396 wxPyEndAllowThreads(__tstate);
25397 if (PyErr_Occurred()) SWIG_fail;
25398 }
25399 {
25400 PyObject *hi, *lo, *shifter, *shifted;
25401 hi = PyLong_FromLong( (&result)->GetHi() );
25402 lo = PyLong_FromLong( (&result)->GetLo() );
25403 shifter = PyLong_FromLong(32);
25404 shifted = PyNumber_Lshift(hi, shifter);
25405 resultobj = PyNumber_Or(shifted, lo);
25406 Py_DECREF(hi);
25407 Py_DECREF(lo);
25408 Py_DECREF(shifter);
25409 Py_DECREF(shifted);
25410 }
25411 return resultobj;
25412 fail:
25413 return NULL;
25414 }
25415
25416
25417 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25418 PyObject *resultobj;
25419 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25420 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25421 wxString *arg2 = (wxString *) &arg2_defvalue ;
25422 wxString result;
25423 bool temp2 = false ;
25424 PyObject * obj0 = 0 ;
25425 PyObject * obj1 = 0 ;
25426 char *kwnames[] = {
25427 (char *) "self",(char *) "format", NULL
25428 };
25429
25430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25432 if (SWIG_arg_fail(1)) SWIG_fail;
25433 if (obj1) {
25434 {
25435 arg2 = wxString_in_helper(obj1);
25436 if (arg2 == NULL) SWIG_fail;
25437 temp2 = true;
25438 }
25439 }
25440 {
25441 PyThreadState* __tstate = wxPyBeginAllowThreads();
25442 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25443
25444 wxPyEndAllowThreads(__tstate);
25445 if (PyErr_Occurred()) SWIG_fail;
25446 }
25447 {
25448 #if wxUSE_UNICODE
25449 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25450 #else
25451 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25452 #endif
25453 }
25454 {
25455 if (temp2)
25456 delete arg2;
25457 }
25458 return resultobj;
25459 fail:
25460 {
25461 if (temp2)
25462 delete arg2;
25463 }
25464 return NULL;
25465 }
25466
25467
25468 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25469 PyObject *obj;
25470 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25471 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25472 Py_INCREF(obj);
25473 return Py_BuildValue((char *)"");
25474 }
25475 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25476 PyObject *resultobj;
25477 int arg1 = (int) 0 ;
25478 int arg2 = (int) 0 ;
25479 int arg3 = (int) 0 ;
25480 int arg4 = (int) 0 ;
25481 wxDateSpan *result;
25482 PyObject * obj0 = 0 ;
25483 PyObject * obj1 = 0 ;
25484 PyObject * obj2 = 0 ;
25485 PyObject * obj3 = 0 ;
25486 char *kwnames[] = {
25487 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25488 };
25489
25490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25491 if (obj0) {
25492 {
25493 arg1 = (int)(SWIG_As_int(obj0));
25494 if (SWIG_arg_fail(1)) SWIG_fail;
25495 }
25496 }
25497 if (obj1) {
25498 {
25499 arg2 = (int)(SWIG_As_int(obj1));
25500 if (SWIG_arg_fail(2)) SWIG_fail;
25501 }
25502 }
25503 if (obj2) {
25504 {
25505 arg3 = (int)(SWIG_As_int(obj2));
25506 if (SWIG_arg_fail(3)) SWIG_fail;
25507 }
25508 }
25509 if (obj3) {
25510 {
25511 arg4 = (int)(SWIG_As_int(obj3));
25512 if (SWIG_arg_fail(4)) SWIG_fail;
25513 }
25514 }
25515 {
25516 PyThreadState* __tstate = wxPyBeginAllowThreads();
25517 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25518
25519 wxPyEndAllowThreads(__tstate);
25520 if (PyErr_Occurred()) SWIG_fail;
25521 }
25522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25523 return resultobj;
25524 fail:
25525 return NULL;
25526 }
25527
25528
25529 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25530 PyObject *resultobj;
25531 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25532 PyObject * obj0 = 0 ;
25533 char *kwnames[] = {
25534 (char *) "self", NULL
25535 };
25536
25537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25539 if (SWIG_arg_fail(1)) SWIG_fail;
25540 {
25541 PyThreadState* __tstate = wxPyBeginAllowThreads();
25542 delete arg1;
25543
25544 wxPyEndAllowThreads(__tstate);
25545 if (PyErr_Occurred()) SWIG_fail;
25546 }
25547 Py_INCREF(Py_None); resultobj = Py_None;
25548 return resultobj;
25549 fail:
25550 return NULL;
25551 }
25552
25553
25554 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25555 PyObject *resultobj;
25556 int arg1 ;
25557 wxDateSpan result;
25558 PyObject * obj0 = 0 ;
25559 char *kwnames[] = {
25560 (char *) "days", NULL
25561 };
25562
25563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25564 {
25565 arg1 = (int)(SWIG_As_int(obj0));
25566 if (SWIG_arg_fail(1)) SWIG_fail;
25567 }
25568 {
25569 PyThreadState* __tstate = wxPyBeginAllowThreads();
25570 result = wxDateSpan::Days(arg1);
25571
25572 wxPyEndAllowThreads(__tstate);
25573 if (PyErr_Occurred()) SWIG_fail;
25574 }
25575 {
25576 wxDateSpan * resultptr;
25577 resultptr = new wxDateSpan((wxDateSpan &)(result));
25578 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25579 }
25580 return resultobj;
25581 fail:
25582 return NULL;
25583 }
25584
25585
25586 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25587 PyObject *resultobj;
25588 wxDateSpan result;
25589 char *kwnames[] = {
25590 NULL
25591 };
25592
25593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25594 {
25595 PyThreadState* __tstate = wxPyBeginAllowThreads();
25596 result = wxDateSpan::Day();
25597
25598 wxPyEndAllowThreads(__tstate);
25599 if (PyErr_Occurred()) SWIG_fail;
25600 }
25601 {
25602 wxDateSpan * resultptr;
25603 resultptr = new wxDateSpan((wxDateSpan &)(result));
25604 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25605 }
25606 return resultobj;
25607 fail:
25608 return NULL;
25609 }
25610
25611
25612 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25613 PyObject *resultobj;
25614 int arg1 ;
25615 wxDateSpan result;
25616 PyObject * obj0 = 0 ;
25617 char *kwnames[] = {
25618 (char *) "weeks", NULL
25619 };
25620
25621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25622 {
25623 arg1 = (int)(SWIG_As_int(obj0));
25624 if (SWIG_arg_fail(1)) SWIG_fail;
25625 }
25626 {
25627 PyThreadState* __tstate = wxPyBeginAllowThreads();
25628 result = wxDateSpan::Weeks(arg1);
25629
25630 wxPyEndAllowThreads(__tstate);
25631 if (PyErr_Occurred()) SWIG_fail;
25632 }
25633 {
25634 wxDateSpan * resultptr;
25635 resultptr = new wxDateSpan((wxDateSpan &)(result));
25636 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25637 }
25638 return resultobj;
25639 fail:
25640 return NULL;
25641 }
25642
25643
25644 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25645 PyObject *resultobj;
25646 wxDateSpan result;
25647 char *kwnames[] = {
25648 NULL
25649 };
25650
25651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25652 {
25653 PyThreadState* __tstate = wxPyBeginAllowThreads();
25654 result = wxDateSpan::Week();
25655
25656 wxPyEndAllowThreads(__tstate);
25657 if (PyErr_Occurred()) SWIG_fail;
25658 }
25659 {
25660 wxDateSpan * resultptr;
25661 resultptr = new wxDateSpan((wxDateSpan &)(result));
25662 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25663 }
25664 return resultobj;
25665 fail:
25666 return NULL;
25667 }
25668
25669
25670 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25671 PyObject *resultobj;
25672 int arg1 ;
25673 wxDateSpan result;
25674 PyObject * obj0 = 0 ;
25675 char *kwnames[] = {
25676 (char *) "mon", NULL
25677 };
25678
25679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25680 {
25681 arg1 = (int)(SWIG_As_int(obj0));
25682 if (SWIG_arg_fail(1)) SWIG_fail;
25683 }
25684 {
25685 PyThreadState* __tstate = wxPyBeginAllowThreads();
25686 result = wxDateSpan::Months(arg1);
25687
25688 wxPyEndAllowThreads(__tstate);
25689 if (PyErr_Occurred()) SWIG_fail;
25690 }
25691 {
25692 wxDateSpan * resultptr;
25693 resultptr = new wxDateSpan((wxDateSpan &)(result));
25694 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25695 }
25696 return resultobj;
25697 fail:
25698 return NULL;
25699 }
25700
25701
25702 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25703 PyObject *resultobj;
25704 wxDateSpan result;
25705 char *kwnames[] = {
25706 NULL
25707 };
25708
25709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25710 {
25711 PyThreadState* __tstate = wxPyBeginAllowThreads();
25712 result = wxDateSpan::Month();
25713
25714 wxPyEndAllowThreads(__tstate);
25715 if (PyErr_Occurred()) SWIG_fail;
25716 }
25717 {
25718 wxDateSpan * resultptr;
25719 resultptr = new wxDateSpan((wxDateSpan &)(result));
25720 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25721 }
25722 return resultobj;
25723 fail:
25724 return NULL;
25725 }
25726
25727
25728 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25729 PyObject *resultobj;
25730 int arg1 ;
25731 wxDateSpan result;
25732 PyObject * obj0 = 0 ;
25733 char *kwnames[] = {
25734 (char *) "years", NULL
25735 };
25736
25737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25738 {
25739 arg1 = (int)(SWIG_As_int(obj0));
25740 if (SWIG_arg_fail(1)) SWIG_fail;
25741 }
25742 {
25743 PyThreadState* __tstate = wxPyBeginAllowThreads();
25744 result = wxDateSpan::Years(arg1);
25745
25746 wxPyEndAllowThreads(__tstate);
25747 if (PyErr_Occurred()) SWIG_fail;
25748 }
25749 {
25750 wxDateSpan * resultptr;
25751 resultptr = new wxDateSpan((wxDateSpan &)(result));
25752 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25753 }
25754 return resultobj;
25755 fail:
25756 return NULL;
25757 }
25758
25759
25760 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25761 PyObject *resultobj;
25762 wxDateSpan result;
25763 char *kwnames[] = {
25764 NULL
25765 };
25766
25767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25768 {
25769 PyThreadState* __tstate = wxPyBeginAllowThreads();
25770 result = wxDateSpan::Year();
25771
25772 wxPyEndAllowThreads(__tstate);
25773 if (PyErr_Occurred()) SWIG_fail;
25774 }
25775 {
25776 wxDateSpan * resultptr;
25777 resultptr = new wxDateSpan((wxDateSpan &)(result));
25778 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25779 }
25780 return resultobj;
25781 fail:
25782 return NULL;
25783 }
25784
25785
25786 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25787 PyObject *resultobj;
25788 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25789 int arg2 ;
25790 wxDateSpan *result;
25791 PyObject * obj0 = 0 ;
25792 PyObject * obj1 = 0 ;
25793 char *kwnames[] = {
25794 (char *) "self",(char *) "n", NULL
25795 };
25796
25797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25799 if (SWIG_arg_fail(1)) SWIG_fail;
25800 {
25801 arg2 = (int)(SWIG_As_int(obj1));
25802 if (SWIG_arg_fail(2)) SWIG_fail;
25803 }
25804 {
25805 PyThreadState* __tstate = wxPyBeginAllowThreads();
25806 {
25807 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25808 result = (wxDateSpan *) &_result_ref;
25809 }
25810
25811 wxPyEndAllowThreads(__tstate);
25812 if (PyErr_Occurred()) SWIG_fail;
25813 }
25814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25815 return resultobj;
25816 fail:
25817 return NULL;
25818 }
25819
25820
25821 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25822 PyObject *resultobj;
25823 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25824 int arg2 ;
25825 wxDateSpan *result;
25826 PyObject * obj0 = 0 ;
25827 PyObject * obj1 = 0 ;
25828 char *kwnames[] = {
25829 (char *) "self",(char *) "n", NULL
25830 };
25831
25832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25834 if (SWIG_arg_fail(1)) SWIG_fail;
25835 {
25836 arg2 = (int)(SWIG_As_int(obj1));
25837 if (SWIG_arg_fail(2)) SWIG_fail;
25838 }
25839 {
25840 PyThreadState* __tstate = wxPyBeginAllowThreads();
25841 {
25842 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25843 result = (wxDateSpan *) &_result_ref;
25844 }
25845
25846 wxPyEndAllowThreads(__tstate);
25847 if (PyErr_Occurred()) SWIG_fail;
25848 }
25849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25850 return resultobj;
25851 fail:
25852 return NULL;
25853 }
25854
25855
25856 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25857 PyObject *resultobj;
25858 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25859 int arg2 ;
25860 wxDateSpan *result;
25861 PyObject * obj0 = 0 ;
25862 PyObject * obj1 = 0 ;
25863 char *kwnames[] = {
25864 (char *) "self",(char *) "n", NULL
25865 };
25866
25867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25869 if (SWIG_arg_fail(1)) SWIG_fail;
25870 {
25871 arg2 = (int)(SWIG_As_int(obj1));
25872 if (SWIG_arg_fail(2)) SWIG_fail;
25873 }
25874 {
25875 PyThreadState* __tstate = wxPyBeginAllowThreads();
25876 {
25877 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25878 result = (wxDateSpan *) &_result_ref;
25879 }
25880
25881 wxPyEndAllowThreads(__tstate);
25882 if (PyErr_Occurred()) SWIG_fail;
25883 }
25884 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25885 return resultobj;
25886 fail:
25887 return NULL;
25888 }
25889
25890
25891 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25892 PyObject *resultobj;
25893 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25894 int arg2 ;
25895 wxDateSpan *result;
25896 PyObject * obj0 = 0 ;
25897 PyObject * obj1 = 0 ;
25898 char *kwnames[] = {
25899 (char *) "self",(char *) "n", NULL
25900 };
25901
25902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25904 if (SWIG_arg_fail(1)) SWIG_fail;
25905 {
25906 arg2 = (int)(SWIG_As_int(obj1));
25907 if (SWIG_arg_fail(2)) SWIG_fail;
25908 }
25909 {
25910 PyThreadState* __tstate = wxPyBeginAllowThreads();
25911 {
25912 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25913 result = (wxDateSpan *) &_result_ref;
25914 }
25915
25916 wxPyEndAllowThreads(__tstate);
25917 if (PyErr_Occurred()) SWIG_fail;
25918 }
25919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25920 return resultobj;
25921 fail:
25922 return NULL;
25923 }
25924
25925
25926 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25927 PyObject *resultobj;
25928 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25929 int result;
25930 PyObject * obj0 = 0 ;
25931 char *kwnames[] = {
25932 (char *) "self", NULL
25933 };
25934
25935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25937 if (SWIG_arg_fail(1)) SWIG_fail;
25938 {
25939 PyThreadState* __tstate = wxPyBeginAllowThreads();
25940 result = (int)((wxDateSpan const *)arg1)->GetYears();
25941
25942 wxPyEndAllowThreads(__tstate);
25943 if (PyErr_Occurred()) SWIG_fail;
25944 }
25945 {
25946 resultobj = SWIG_From_int((int)(result));
25947 }
25948 return resultobj;
25949 fail:
25950 return NULL;
25951 }
25952
25953
25954 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25955 PyObject *resultobj;
25956 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25957 int result;
25958 PyObject * obj0 = 0 ;
25959 char *kwnames[] = {
25960 (char *) "self", NULL
25961 };
25962
25963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25965 if (SWIG_arg_fail(1)) SWIG_fail;
25966 {
25967 PyThreadState* __tstate = wxPyBeginAllowThreads();
25968 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25969
25970 wxPyEndAllowThreads(__tstate);
25971 if (PyErr_Occurred()) SWIG_fail;
25972 }
25973 {
25974 resultobj = SWIG_From_int((int)(result));
25975 }
25976 return resultobj;
25977 fail:
25978 return NULL;
25979 }
25980
25981
25982 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25983 PyObject *resultobj;
25984 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25985 int result;
25986 PyObject * obj0 = 0 ;
25987 char *kwnames[] = {
25988 (char *) "self", NULL
25989 };
25990
25991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25993 if (SWIG_arg_fail(1)) SWIG_fail;
25994 {
25995 PyThreadState* __tstate = wxPyBeginAllowThreads();
25996 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25997
25998 wxPyEndAllowThreads(__tstate);
25999 if (PyErr_Occurred()) SWIG_fail;
26000 }
26001 {
26002 resultobj = SWIG_From_int((int)(result));
26003 }
26004 return resultobj;
26005 fail:
26006 return NULL;
26007 }
26008
26009
26010 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
26011 PyObject *resultobj;
26012 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26013 int result;
26014 PyObject * obj0 = 0 ;
26015 char *kwnames[] = {
26016 (char *) "self", NULL
26017 };
26018
26019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
26020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26021 if (SWIG_arg_fail(1)) SWIG_fail;
26022 {
26023 PyThreadState* __tstate = wxPyBeginAllowThreads();
26024 result = (int)((wxDateSpan const *)arg1)->GetDays();
26025
26026 wxPyEndAllowThreads(__tstate);
26027 if (PyErr_Occurred()) SWIG_fail;
26028 }
26029 {
26030 resultobj = SWIG_From_int((int)(result));
26031 }
26032 return resultobj;
26033 fail:
26034 return NULL;
26035 }
26036
26037
26038 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
26039 PyObject *resultobj;
26040 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26041 int result;
26042 PyObject * obj0 = 0 ;
26043 char *kwnames[] = {
26044 (char *) "self", NULL
26045 };
26046
26047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
26048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26049 if (SWIG_arg_fail(1)) SWIG_fail;
26050 {
26051 PyThreadState* __tstate = wxPyBeginAllowThreads();
26052 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
26053
26054 wxPyEndAllowThreads(__tstate);
26055 if (PyErr_Occurred()) SWIG_fail;
26056 }
26057 {
26058 resultobj = SWIG_From_int((int)(result));
26059 }
26060 return resultobj;
26061 fail:
26062 return NULL;
26063 }
26064
26065
26066 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
26067 PyObject *resultobj;
26068 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26069 wxDateSpan *arg2 = 0 ;
26070 wxDateSpan *result;
26071 PyObject * obj0 = 0 ;
26072 PyObject * obj1 = 0 ;
26073 char *kwnames[] = {
26074 (char *) "self",(char *) "other", NULL
26075 };
26076
26077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
26078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26079 if (SWIG_arg_fail(1)) SWIG_fail;
26080 {
26081 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26082 if (SWIG_arg_fail(2)) SWIG_fail;
26083 if (arg2 == NULL) {
26084 SWIG_null_ref("wxDateSpan");
26085 }
26086 if (SWIG_arg_fail(2)) SWIG_fail;
26087 }
26088 {
26089 PyThreadState* __tstate = wxPyBeginAllowThreads();
26090 {
26091 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
26092 result = (wxDateSpan *) &_result_ref;
26093 }
26094
26095 wxPyEndAllowThreads(__tstate);
26096 if (PyErr_Occurred()) SWIG_fail;
26097 }
26098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26099 return resultobj;
26100 fail:
26101 return NULL;
26102 }
26103
26104
26105 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
26106 PyObject *resultobj;
26107 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26108 wxDateSpan *arg2 = 0 ;
26109 wxDateSpan *result;
26110 PyObject * obj0 = 0 ;
26111 PyObject * obj1 = 0 ;
26112 char *kwnames[] = {
26113 (char *) "self",(char *) "other", NULL
26114 };
26115
26116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
26117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26118 if (SWIG_arg_fail(1)) SWIG_fail;
26119 {
26120 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26121 if (SWIG_arg_fail(2)) SWIG_fail;
26122 if (arg2 == NULL) {
26123 SWIG_null_ref("wxDateSpan");
26124 }
26125 if (SWIG_arg_fail(2)) SWIG_fail;
26126 }
26127 {
26128 PyThreadState* __tstate = wxPyBeginAllowThreads();
26129 {
26130 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26131 result = (wxDateSpan *) &_result_ref;
26132 }
26133
26134 wxPyEndAllowThreads(__tstate);
26135 if (PyErr_Occurred()) SWIG_fail;
26136 }
26137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26138 return resultobj;
26139 fail:
26140 return NULL;
26141 }
26142
26143
26144 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
26145 PyObject *resultobj;
26146 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26147 wxDateSpan *result;
26148 PyObject * obj0 = 0 ;
26149 char *kwnames[] = {
26150 (char *) "self", NULL
26151 };
26152
26153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
26154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26155 if (SWIG_arg_fail(1)) SWIG_fail;
26156 {
26157 PyThreadState* __tstate = wxPyBeginAllowThreads();
26158 {
26159 wxDateSpan &_result_ref = (arg1)->Neg();
26160 result = (wxDateSpan *) &_result_ref;
26161 }
26162
26163 wxPyEndAllowThreads(__tstate);
26164 if (PyErr_Occurred()) SWIG_fail;
26165 }
26166 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26167 return resultobj;
26168 fail:
26169 return NULL;
26170 }
26171
26172
26173 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
26174 PyObject *resultobj;
26175 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26176 int arg2 ;
26177 wxDateSpan *result;
26178 PyObject * obj0 = 0 ;
26179 PyObject * obj1 = 0 ;
26180 char *kwnames[] = {
26181 (char *) "self",(char *) "factor", NULL
26182 };
26183
26184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
26185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26186 if (SWIG_arg_fail(1)) SWIG_fail;
26187 {
26188 arg2 = (int)(SWIG_As_int(obj1));
26189 if (SWIG_arg_fail(2)) SWIG_fail;
26190 }
26191 {
26192 PyThreadState* __tstate = wxPyBeginAllowThreads();
26193 {
26194 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26195 result = (wxDateSpan *) &_result_ref;
26196 }
26197
26198 wxPyEndAllowThreads(__tstate);
26199 if (PyErr_Occurred()) SWIG_fail;
26200 }
26201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26202 return resultobj;
26203 fail:
26204 return NULL;
26205 }
26206
26207
26208 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26209 PyObject *resultobj;
26210 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26211 wxDateSpan *arg2 = 0 ;
26212 wxDateSpan *result;
26213 PyObject * obj0 = 0 ;
26214 PyObject * obj1 = 0 ;
26215 char *kwnames[] = {
26216 (char *) "self",(char *) "other", NULL
26217 };
26218
26219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26221 if (SWIG_arg_fail(1)) SWIG_fail;
26222 {
26223 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26224 if (SWIG_arg_fail(2)) SWIG_fail;
26225 if (arg2 == NULL) {
26226 SWIG_null_ref("wxDateSpan");
26227 }
26228 if (SWIG_arg_fail(2)) SWIG_fail;
26229 }
26230 {
26231 PyThreadState* __tstate = wxPyBeginAllowThreads();
26232 {
26233 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26234 result = (wxDateSpan *) &_result_ref;
26235 }
26236
26237 wxPyEndAllowThreads(__tstate);
26238 if (PyErr_Occurred()) SWIG_fail;
26239 }
26240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26241 return resultobj;
26242 fail:
26243 return NULL;
26244 }
26245
26246
26247 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26248 PyObject *resultobj;
26249 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26250 wxDateSpan *arg2 = 0 ;
26251 wxDateSpan *result;
26252 PyObject * obj0 = 0 ;
26253 PyObject * obj1 = 0 ;
26254 char *kwnames[] = {
26255 (char *) "self",(char *) "other", NULL
26256 };
26257
26258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26260 if (SWIG_arg_fail(1)) SWIG_fail;
26261 {
26262 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26263 if (SWIG_arg_fail(2)) SWIG_fail;
26264 if (arg2 == NULL) {
26265 SWIG_null_ref("wxDateSpan");
26266 }
26267 if (SWIG_arg_fail(2)) SWIG_fail;
26268 }
26269 {
26270 PyThreadState* __tstate = wxPyBeginAllowThreads();
26271 {
26272 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26273 result = (wxDateSpan *) &_result_ref;
26274 }
26275
26276 wxPyEndAllowThreads(__tstate);
26277 if (PyErr_Occurred()) SWIG_fail;
26278 }
26279 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26280 return resultobj;
26281 fail:
26282 return NULL;
26283 }
26284
26285
26286 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26287 PyObject *resultobj;
26288 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26289 wxDateSpan *result;
26290 PyObject * obj0 = 0 ;
26291 char *kwnames[] = {
26292 (char *) "self", NULL
26293 };
26294
26295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26297 if (SWIG_arg_fail(1)) SWIG_fail;
26298 {
26299 PyThreadState* __tstate = wxPyBeginAllowThreads();
26300 {
26301 wxDateSpan &_result_ref = (arg1)->operator -();
26302 result = (wxDateSpan *) &_result_ref;
26303 }
26304
26305 wxPyEndAllowThreads(__tstate);
26306 if (PyErr_Occurred()) SWIG_fail;
26307 }
26308 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26309 return resultobj;
26310 fail:
26311 return NULL;
26312 }
26313
26314
26315 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26316 PyObject *resultobj;
26317 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26318 int arg2 ;
26319 wxDateSpan *result;
26320 PyObject * obj0 = 0 ;
26321 PyObject * obj1 = 0 ;
26322 char *kwnames[] = {
26323 (char *) "self",(char *) "factor", NULL
26324 };
26325
26326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26328 if (SWIG_arg_fail(1)) SWIG_fail;
26329 {
26330 arg2 = (int)(SWIG_As_int(obj1));
26331 if (SWIG_arg_fail(2)) SWIG_fail;
26332 }
26333 {
26334 PyThreadState* __tstate = wxPyBeginAllowThreads();
26335 {
26336 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26337 result = (wxDateSpan *) &_result_ref;
26338 }
26339
26340 wxPyEndAllowThreads(__tstate);
26341 if (PyErr_Occurred()) SWIG_fail;
26342 }
26343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26344 return resultobj;
26345 fail:
26346 return NULL;
26347 }
26348
26349
26350 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26351 PyObject *resultobj;
26352 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26353 wxDateSpan *arg2 = 0 ;
26354 wxDateSpan result;
26355 PyObject * obj0 = 0 ;
26356 PyObject * obj1 = 0 ;
26357 char *kwnames[] = {
26358 (char *) "self",(char *) "other", NULL
26359 };
26360
26361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26363 if (SWIG_arg_fail(1)) SWIG_fail;
26364 {
26365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26366 if (SWIG_arg_fail(2)) SWIG_fail;
26367 if (arg2 == NULL) {
26368 SWIG_null_ref("wxDateSpan");
26369 }
26370 if (SWIG_arg_fail(2)) SWIG_fail;
26371 }
26372 {
26373 PyThreadState* __tstate = wxPyBeginAllowThreads();
26374 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26375
26376 wxPyEndAllowThreads(__tstate);
26377 if (PyErr_Occurred()) SWIG_fail;
26378 }
26379 {
26380 wxDateSpan * resultptr;
26381 resultptr = new wxDateSpan((wxDateSpan &)(result));
26382 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26383 }
26384 return resultobj;
26385 fail:
26386 return NULL;
26387 }
26388
26389
26390 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26391 PyObject *resultobj;
26392 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26393 wxDateSpan *arg2 = 0 ;
26394 wxDateSpan result;
26395 PyObject * obj0 = 0 ;
26396 PyObject * obj1 = 0 ;
26397 char *kwnames[] = {
26398 (char *) "self",(char *) "other", NULL
26399 };
26400
26401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26403 if (SWIG_arg_fail(1)) SWIG_fail;
26404 {
26405 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26406 if (SWIG_arg_fail(2)) SWIG_fail;
26407 if (arg2 == NULL) {
26408 SWIG_null_ref("wxDateSpan");
26409 }
26410 if (SWIG_arg_fail(2)) SWIG_fail;
26411 }
26412 {
26413 PyThreadState* __tstate = wxPyBeginAllowThreads();
26414 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26415
26416 wxPyEndAllowThreads(__tstate);
26417 if (PyErr_Occurred()) SWIG_fail;
26418 }
26419 {
26420 wxDateSpan * resultptr;
26421 resultptr = new wxDateSpan((wxDateSpan &)(result));
26422 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26423 }
26424 return resultobj;
26425 fail:
26426 return NULL;
26427 }
26428
26429
26430 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26431 PyObject *resultobj;
26432 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26433 int arg2 ;
26434 wxDateSpan result;
26435 PyObject * obj0 = 0 ;
26436 PyObject * obj1 = 0 ;
26437 char *kwnames[] = {
26438 (char *) "self",(char *) "n", NULL
26439 };
26440
26441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26443 if (SWIG_arg_fail(1)) SWIG_fail;
26444 {
26445 arg2 = (int)(SWIG_As_int(obj1));
26446 if (SWIG_arg_fail(2)) SWIG_fail;
26447 }
26448 {
26449 PyThreadState* __tstate = wxPyBeginAllowThreads();
26450 result = wxDateSpan___mul__(arg1,arg2);
26451
26452 wxPyEndAllowThreads(__tstate);
26453 if (PyErr_Occurred()) SWIG_fail;
26454 }
26455 {
26456 wxDateSpan * resultptr;
26457 resultptr = new wxDateSpan((wxDateSpan &)(result));
26458 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26459 }
26460 return resultobj;
26461 fail:
26462 return NULL;
26463 }
26464
26465
26466 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26467 PyObject *resultobj;
26468 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26469 int arg2 ;
26470 wxDateSpan result;
26471 PyObject * obj0 = 0 ;
26472 PyObject * obj1 = 0 ;
26473 char *kwnames[] = {
26474 (char *) "self",(char *) "n", NULL
26475 };
26476
26477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26479 if (SWIG_arg_fail(1)) SWIG_fail;
26480 {
26481 arg2 = (int)(SWIG_As_int(obj1));
26482 if (SWIG_arg_fail(2)) SWIG_fail;
26483 }
26484 {
26485 PyThreadState* __tstate = wxPyBeginAllowThreads();
26486 result = wxDateSpan___rmul__(arg1,arg2);
26487
26488 wxPyEndAllowThreads(__tstate);
26489 if (PyErr_Occurred()) SWIG_fail;
26490 }
26491 {
26492 wxDateSpan * resultptr;
26493 resultptr = new wxDateSpan((wxDateSpan &)(result));
26494 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26495 }
26496 return resultobj;
26497 fail:
26498 return NULL;
26499 }
26500
26501
26502 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26503 PyObject *resultobj;
26504 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26505 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26506 bool result;
26507 PyObject * obj0 = 0 ;
26508 PyObject * obj1 = 0 ;
26509 char *kwnames[] = {
26510 (char *) "self",(char *) "other", NULL
26511 };
26512
26513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26515 if (SWIG_arg_fail(1)) SWIG_fail;
26516 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26517 if (SWIG_arg_fail(2)) SWIG_fail;
26518 {
26519 PyThreadState* __tstate = wxPyBeginAllowThreads();
26520 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26521
26522 wxPyEndAllowThreads(__tstate);
26523 if (PyErr_Occurred()) SWIG_fail;
26524 }
26525 {
26526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26527 }
26528 return resultobj;
26529 fail:
26530 return NULL;
26531 }
26532
26533
26534 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26535 PyObject *resultobj;
26536 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26537 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26538 bool result;
26539 PyObject * obj0 = 0 ;
26540 PyObject * obj1 = 0 ;
26541 char *kwnames[] = {
26542 (char *) "self",(char *) "other", NULL
26543 };
26544
26545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26547 if (SWIG_arg_fail(1)) SWIG_fail;
26548 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26549 if (SWIG_arg_fail(2)) SWIG_fail;
26550 {
26551 PyThreadState* __tstate = wxPyBeginAllowThreads();
26552 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26553
26554 wxPyEndAllowThreads(__tstate);
26555 if (PyErr_Occurred()) SWIG_fail;
26556 }
26557 {
26558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26559 }
26560 return resultobj;
26561 fail:
26562 return NULL;
26563 }
26564
26565
26566 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26567 PyObject *obj;
26568 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26569 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26570 Py_INCREF(obj);
26571 return Py_BuildValue((char *)"");
26572 }
26573 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26574 PyObject *resultobj;
26575 long result;
26576 char *kwnames[] = {
26577 NULL
26578 };
26579
26580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26581 {
26582 PyThreadState* __tstate = wxPyBeginAllowThreads();
26583 result = (long)wxGetLocalTime();
26584
26585 wxPyEndAllowThreads(__tstate);
26586 if (PyErr_Occurred()) SWIG_fail;
26587 }
26588 {
26589 resultobj = SWIG_From_long((long)(result));
26590 }
26591 return resultobj;
26592 fail:
26593 return NULL;
26594 }
26595
26596
26597 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26598 PyObject *resultobj;
26599 long result;
26600 char *kwnames[] = {
26601 NULL
26602 };
26603
26604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26605 {
26606 PyThreadState* __tstate = wxPyBeginAllowThreads();
26607 result = (long)wxGetUTCTime();
26608
26609 wxPyEndAllowThreads(__tstate);
26610 if (PyErr_Occurred()) SWIG_fail;
26611 }
26612 {
26613 resultobj = SWIG_From_long((long)(result));
26614 }
26615 return resultobj;
26616 fail:
26617 return NULL;
26618 }
26619
26620
26621 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26622 PyObject *resultobj;
26623 long result;
26624 char *kwnames[] = {
26625 NULL
26626 };
26627
26628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26629 {
26630 PyThreadState* __tstate = wxPyBeginAllowThreads();
26631 result = (long)wxGetCurrentTime();
26632
26633 wxPyEndAllowThreads(__tstate);
26634 if (PyErr_Occurred()) SWIG_fail;
26635 }
26636 {
26637 resultobj = SWIG_From_long((long)(result));
26638 }
26639 return resultobj;
26640 fail:
26641 return NULL;
26642 }
26643
26644
26645 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26646 PyObject *resultobj;
26647 wxLongLong result;
26648 char *kwnames[] = {
26649 NULL
26650 };
26651
26652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26653 {
26654 PyThreadState* __tstate = wxPyBeginAllowThreads();
26655 result = wxGetLocalTimeMillis();
26656
26657 wxPyEndAllowThreads(__tstate);
26658 if (PyErr_Occurred()) SWIG_fail;
26659 }
26660 {
26661 PyObject *hi, *lo, *shifter, *shifted;
26662 hi = PyLong_FromLong( (&result)->GetHi() );
26663 lo = PyLong_FromLong( (&result)->GetLo() );
26664 shifter = PyLong_FromLong(32);
26665 shifted = PyNumber_Lshift(hi, shifter);
26666 resultobj = PyNumber_Or(shifted, lo);
26667 Py_DECREF(hi);
26668 Py_DECREF(lo);
26669 Py_DECREF(shifter);
26670 Py_DECREF(shifted);
26671 }
26672 return resultobj;
26673 fail:
26674 return NULL;
26675 }
26676
26677
26678 static int _wrap_DefaultDateTime_set(PyObject *) {
26679 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26680 return 1;
26681 }
26682
26683
26684 static PyObject *_wrap_DefaultDateTime_get(void) {
26685 PyObject *pyobj;
26686
26687 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26688 return pyobj;
26689 }
26690
26691
26692 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26693 PyObject *resultobj;
26694 wxDataFormatId arg1 ;
26695 wxDataFormat *result;
26696 PyObject * obj0 = 0 ;
26697 char *kwnames[] = {
26698 (char *) "type", NULL
26699 };
26700
26701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26702 {
26703 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26704 if (SWIG_arg_fail(1)) SWIG_fail;
26705 }
26706 {
26707 PyThreadState* __tstate = wxPyBeginAllowThreads();
26708 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26709
26710 wxPyEndAllowThreads(__tstate);
26711 if (PyErr_Occurred()) SWIG_fail;
26712 }
26713 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26714 return resultobj;
26715 fail:
26716 return NULL;
26717 }
26718
26719
26720 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26721 PyObject *resultobj;
26722 wxString *arg1 = 0 ;
26723 wxDataFormat *result;
26724 bool temp1 = false ;
26725 PyObject * obj0 = 0 ;
26726 char *kwnames[] = {
26727 (char *) "format", NULL
26728 };
26729
26730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26731 {
26732 arg1 = wxString_in_helper(obj0);
26733 if (arg1 == NULL) SWIG_fail;
26734 temp1 = true;
26735 }
26736 {
26737 PyThreadState* __tstate = wxPyBeginAllowThreads();
26738 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26739
26740 wxPyEndAllowThreads(__tstate);
26741 if (PyErr_Occurred()) SWIG_fail;
26742 }
26743 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26744 {
26745 if (temp1)
26746 delete arg1;
26747 }
26748 return resultobj;
26749 fail:
26750 {
26751 if (temp1)
26752 delete arg1;
26753 }
26754 return NULL;
26755 }
26756
26757
26758 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26759 PyObject *resultobj;
26760 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26761 PyObject * obj0 = 0 ;
26762 char *kwnames[] = {
26763 (char *) "self", NULL
26764 };
26765
26766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26768 if (SWIG_arg_fail(1)) SWIG_fail;
26769 {
26770 PyThreadState* __tstate = wxPyBeginAllowThreads();
26771 delete arg1;
26772
26773 wxPyEndAllowThreads(__tstate);
26774 if (PyErr_Occurred()) SWIG_fail;
26775 }
26776 Py_INCREF(Py_None); resultobj = Py_None;
26777 return resultobj;
26778 fail:
26779 return NULL;
26780 }
26781
26782
26783 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26784 PyObject *resultobj;
26785 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26786 wxDataFormatId arg2 ;
26787 bool result;
26788 PyObject * obj0 = 0 ;
26789 PyObject * obj1 = 0 ;
26790
26791 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26793 if (SWIG_arg_fail(1)) SWIG_fail;
26794 {
26795 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26796 if (SWIG_arg_fail(2)) SWIG_fail;
26797 }
26798 {
26799 PyThreadState* __tstate = wxPyBeginAllowThreads();
26800 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26801
26802 wxPyEndAllowThreads(__tstate);
26803 if (PyErr_Occurred()) SWIG_fail;
26804 }
26805 {
26806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26807 }
26808 return resultobj;
26809 fail:
26810 return NULL;
26811 }
26812
26813
26814 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26815 PyObject *resultobj;
26816 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26817 wxDataFormatId arg2 ;
26818 bool result;
26819 PyObject * obj0 = 0 ;
26820 PyObject * obj1 = 0 ;
26821
26822 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26824 if (SWIG_arg_fail(1)) SWIG_fail;
26825 {
26826 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26827 if (SWIG_arg_fail(2)) SWIG_fail;
26828 }
26829 {
26830 PyThreadState* __tstate = wxPyBeginAllowThreads();
26831 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26832
26833 wxPyEndAllowThreads(__tstate);
26834 if (PyErr_Occurred()) SWIG_fail;
26835 }
26836 {
26837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26838 }
26839 return resultobj;
26840 fail:
26841 return NULL;
26842 }
26843
26844
26845 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26846 PyObject *resultobj;
26847 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26848 wxDataFormat *arg2 = 0 ;
26849 bool result;
26850 PyObject * obj0 = 0 ;
26851 PyObject * obj1 = 0 ;
26852
26853 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26855 if (SWIG_arg_fail(1)) SWIG_fail;
26856 {
26857 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26858 if (SWIG_arg_fail(2)) SWIG_fail;
26859 if (arg2 == NULL) {
26860 SWIG_null_ref("wxDataFormat");
26861 }
26862 if (SWIG_arg_fail(2)) SWIG_fail;
26863 }
26864 {
26865 PyThreadState* __tstate = wxPyBeginAllowThreads();
26866 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26867
26868 wxPyEndAllowThreads(__tstate);
26869 if (PyErr_Occurred()) SWIG_fail;
26870 }
26871 {
26872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26873 }
26874 return resultobj;
26875 fail:
26876 return NULL;
26877 }
26878
26879
26880 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26881 int argc;
26882 PyObject *argv[3];
26883 int ii;
26884
26885 argc = PyObject_Length(args);
26886 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26887 argv[ii] = PyTuple_GetItem(args,ii);
26888 }
26889 if (argc == 2) {
26890 int _v;
26891 {
26892 void *ptr;
26893 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26894 _v = 0;
26895 PyErr_Clear();
26896 } else {
26897 _v = 1;
26898 }
26899 }
26900 if (_v) {
26901 {
26902 void *ptr = 0;
26903 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26904 _v = 0;
26905 PyErr_Clear();
26906 } else {
26907 _v = (ptr != 0);
26908 }
26909 }
26910 if (_v) {
26911 return _wrap_DataFormat___eq____SWIG_1(self,args);
26912 }
26913 }
26914 }
26915 if (argc == 2) {
26916 int _v;
26917 {
26918 void *ptr;
26919 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26920 _v = 0;
26921 PyErr_Clear();
26922 } else {
26923 _v = 1;
26924 }
26925 }
26926 if (_v) {
26927 _v = SWIG_Check_int(argv[1]);
26928 if (_v) {
26929 return _wrap_DataFormat___eq____SWIG_0(self,args);
26930 }
26931 }
26932 }
26933
26934 Py_INCREF(Py_NotImplemented);
26935 return Py_NotImplemented;
26936 }
26937
26938
26939 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26940 PyObject *resultobj;
26941 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26942 wxDataFormat *arg2 = 0 ;
26943 bool result;
26944 PyObject * obj0 = 0 ;
26945 PyObject * obj1 = 0 ;
26946
26947 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26949 if (SWIG_arg_fail(1)) SWIG_fail;
26950 {
26951 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26952 if (SWIG_arg_fail(2)) SWIG_fail;
26953 if (arg2 == NULL) {
26954 SWIG_null_ref("wxDataFormat");
26955 }
26956 if (SWIG_arg_fail(2)) SWIG_fail;
26957 }
26958 {
26959 PyThreadState* __tstate = wxPyBeginAllowThreads();
26960 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26961
26962 wxPyEndAllowThreads(__tstate);
26963 if (PyErr_Occurred()) SWIG_fail;
26964 }
26965 {
26966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26967 }
26968 return resultobj;
26969 fail:
26970 return NULL;
26971 }
26972
26973
26974 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26975 int argc;
26976 PyObject *argv[3];
26977 int ii;
26978
26979 argc = PyObject_Length(args);
26980 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26981 argv[ii] = PyTuple_GetItem(args,ii);
26982 }
26983 if (argc == 2) {
26984 int _v;
26985 {
26986 void *ptr;
26987 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26988 _v = 0;
26989 PyErr_Clear();
26990 } else {
26991 _v = 1;
26992 }
26993 }
26994 if (_v) {
26995 {
26996 void *ptr = 0;
26997 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26998 _v = 0;
26999 PyErr_Clear();
27000 } else {
27001 _v = (ptr != 0);
27002 }
27003 }
27004 if (_v) {
27005 return _wrap_DataFormat___ne____SWIG_1(self,args);
27006 }
27007 }
27008 }
27009 if (argc == 2) {
27010 int _v;
27011 {
27012 void *ptr;
27013 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27014 _v = 0;
27015 PyErr_Clear();
27016 } else {
27017 _v = 1;
27018 }
27019 }
27020 if (_v) {
27021 _v = SWIG_Check_int(argv[1]);
27022 if (_v) {
27023 return _wrap_DataFormat___ne____SWIG_0(self,args);
27024 }
27025 }
27026 }
27027
27028 Py_INCREF(Py_NotImplemented);
27029 return Py_NotImplemented;
27030 }
27031
27032
27033 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
27034 PyObject *resultobj;
27035 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27036 wxDataFormatId arg2 ;
27037 PyObject * obj0 = 0 ;
27038 PyObject * obj1 = 0 ;
27039 char *kwnames[] = {
27040 (char *) "self",(char *) "format", NULL
27041 };
27042
27043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
27044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27045 if (SWIG_arg_fail(1)) SWIG_fail;
27046 {
27047 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
27048 if (SWIG_arg_fail(2)) SWIG_fail;
27049 }
27050 {
27051 PyThreadState* __tstate = wxPyBeginAllowThreads();
27052 (arg1)->SetType((wxDataFormatId )arg2);
27053
27054 wxPyEndAllowThreads(__tstate);
27055 if (PyErr_Occurred()) SWIG_fail;
27056 }
27057 Py_INCREF(Py_None); resultobj = Py_None;
27058 return resultobj;
27059 fail:
27060 return NULL;
27061 }
27062
27063
27064 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
27065 PyObject *resultobj;
27066 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27067 wxDataFormatId result;
27068 PyObject * obj0 = 0 ;
27069 char *kwnames[] = {
27070 (char *) "self", NULL
27071 };
27072
27073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
27074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27075 if (SWIG_arg_fail(1)) SWIG_fail;
27076 {
27077 PyThreadState* __tstate = wxPyBeginAllowThreads();
27078 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
27079
27080 wxPyEndAllowThreads(__tstate);
27081 if (PyErr_Occurred()) SWIG_fail;
27082 }
27083 resultobj = SWIG_From_int((result));
27084 return resultobj;
27085 fail:
27086 return NULL;
27087 }
27088
27089
27090 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
27091 PyObject *resultobj;
27092 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27093 wxString result;
27094 PyObject * obj0 = 0 ;
27095 char *kwnames[] = {
27096 (char *) "self", NULL
27097 };
27098
27099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
27100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27101 if (SWIG_arg_fail(1)) SWIG_fail;
27102 {
27103 PyThreadState* __tstate = wxPyBeginAllowThreads();
27104 result = ((wxDataFormat const *)arg1)->GetId();
27105
27106 wxPyEndAllowThreads(__tstate);
27107 if (PyErr_Occurred()) SWIG_fail;
27108 }
27109 {
27110 #if wxUSE_UNICODE
27111 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27112 #else
27113 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27114 #endif
27115 }
27116 return resultobj;
27117 fail:
27118 return NULL;
27119 }
27120
27121
27122 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
27123 PyObject *resultobj;
27124 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27125 wxString *arg2 = 0 ;
27126 bool temp2 = false ;
27127 PyObject * obj0 = 0 ;
27128 PyObject * obj1 = 0 ;
27129 char *kwnames[] = {
27130 (char *) "self",(char *) "format", NULL
27131 };
27132
27133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
27134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27135 if (SWIG_arg_fail(1)) SWIG_fail;
27136 {
27137 arg2 = wxString_in_helper(obj1);
27138 if (arg2 == NULL) SWIG_fail;
27139 temp2 = true;
27140 }
27141 {
27142 PyThreadState* __tstate = wxPyBeginAllowThreads();
27143 (arg1)->SetId((wxString const &)*arg2);
27144
27145 wxPyEndAllowThreads(__tstate);
27146 if (PyErr_Occurred()) SWIG_fail;
27147 }
27148 Py_INCREF(Py_None); resultobj = Py_None;
27149 {
27150 if (temp2)
27151 delete arg2;
27152 }
27153 return resultobj;
27154 fail:
27155 {
27156 if (temp2)
27157 delete arg2;
27158 }
27159 return NULL;
27160 }
27161
27162
27163 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
27164 PyObject *obj;
27165 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27166 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
27167 Py_INCREF(obj);
27168 return Py_BuildValue((char *)"");
27169 }
27170 static int _wrap_FormatInvalid_set(PyObject *) {
27171 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
27172 return 1;
27173 }
27174
27175
27176 static PyObject *_wrap_FormatInvalid_get(void) {
27177 PyObject *pyobj;
27178
27179 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
27180 return pyobj;
27181 }
27182
27183
27184 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27185 PyObject *resultobj;
27186 wxDataObject *arg1 = (wxDataObject *) 0 ;
27187 PyObject * obj0 = 0 ;
27188 char *kwnames[] = {
27189 (char *) "self", NULL
27190 };
27191
27192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27194 if (SWIG_arg_fail(1)) SWIG_fail;
27195 {
27196 PyThreadState* __tstate = wxPyBeginAllowThreads();
27197 delete arg1;
27198
27199 wxPyEndAllowThreads(__tstate);
27200 if (PyErr_Occurred()) SWIG_fail;
27201 }
27202 Py_INCREF(Py_None); resultobj = Py_None;
27203 return resultobj;
27204 fail:
27205 return NULL;
27206 }
27207
27208
27209 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27210 PyObject *resultobj;
27211 wxDataObject *arg1 = (wxDataObject *) 0 ;
27212 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27213 SwigValueWrapper<wxDataFormat > result;
27214 PyObject * obj0 = 0 ;
27215 PyObject * obj1 = 0 ;
27216 char *kwnames[] = {
27217 (char *) "self",(char *) "dir", NULL
27218 };
27219
27220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27222 if (SWIG_arg_fail(1)) SWIG_fail;
27223 if (obj1) {
27224 {
27225 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27226 if (SWIG_arg_fail(2)) SWIG_fail;
27227 }
27228 }
27229 {
27230 PyThreadState* __tstate = wxPyBeginAllowThreads();
27231 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27232
27233 wxPyEndAllowThreads(__tstate);
27234 if (PyErr_Occurred()) SWIG_fail;
27235 }
27236 {
27237 wxDataFormat * resultptr;
27238 resultptr = new wxDataFormat((wxDataFormat &)(result));
27239 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27240 }
27241 return resultobj;
27242 fail:
27243 return NULL;
27244 }
27245
27246
27247 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27248 PyObject *resultobj;
27249 wxDataObject *arg1 = (wxDataObject *) 0 ;
27250 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27251 size_t result;
27252 PyObject * obj0 = 0 ;
27253 PyObject * obj1 = 0 ;
27254 char *kwnames[] = {
27255 (char *) "self",(char *) "dir", NULL
27256 };
27257
27258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27260 if (SWIG_arg_fail(1)) SWIG_fail;
27261 if (obj1) {
27262 {
27263 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27264 if (SWIG_arg_fail(2)) SWIG_fail;
27265 }
27266 }
27267 {
27268 PyThreadState* __tstate = wxPyBeginAllowThreads();
27269 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27270
27271 wxPyEndAllowThreads(__tstate);
27272 if (PyErr_Occurred()) SWIG_fail;
27273 }
27274 {
27275 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27276 }
27277 return resultobj;
27278 fail:
27279 return NULL;
27280 }
27281
27282
27283 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27284 PyObject *resultobj;
27285 wxDataObject *arg1 = (wxDataObject *) 0 ;
27286 wxDataFormat *arg2 = 0 ;
27287 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27288 bool result;
27289 PyObject * obj0 = 0 ;
27290 PyObject * obj1 = 0 ;
27291 PyObject * obj2 = 0 ;
27292 char *kwnames[] = {
27293 (char *) "self",(char *) "format",(char *) "dir", NULL
27294 };
27295
27296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27298 if (SWIG_arg_fail(1)) SWIG_fail;
27299 {
27300 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27301 if (SWIG_arg_fail(2)) SWIG_fail;
27302 if (arg2 == NULL) {
27303 SWIG_null_ref("wxDataFormat");
27304 }
27305 if (SWIG_arg_fail(2)) SWIG_fail;
27306 }
27307 if (obj2) {
27308 {
27309 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27310 if (SWIG_arg_fail(3)) SWIG_fail;
27311 }
27312 }
27313 {
27314 PyThreadState* __tstate = wxPyBeginAllowThreads();
27315 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27316
27317 wxPyEndAllowThreads(__tstate);
27318 if (PyErr_Occurred()) SWIG_fail;
27319 }
27320 {
27321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27322 }
27323 return resultobj;
27324 fail:
27325 return NULL;
27326 }
27327
27328
27329 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27330 PyObject *resultobj;
27331 wxDataObject *arg1 = (wxDataObject *) 0 ;
27332 wxDataFormat *arg2 = 0 ;
27333 size_t result;
27334 PyObject * obj0 = 0 ;
27335 PyObject * obj1 = 0 ;
27336 char *kwnames[] = {
27337 (char *) "self",(char *) "format", NULL
27338 };
27339
27340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27342 if (SWIG_arg_fail(1)) SWIG_fail;
27343 {
27344 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27345 if (SWIG_arg_fail(2)) SWIG_fail;
27346 if (arg2 == NULL) {
27347 SWIG_null_ref("wxDataFormat");
27348 }
27349 if (SWIG_arg_fail(2)) SWIG_fail;
27350 }
27351 {
27352 PyThreadState* __tstate = wxPyBeginAllowThreads();
27353 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27354
27355 wxPyEndAllowThreads(__tstate);
27356 if (PyErr_Occurred()) SWIG_fail;
27357 }
27358 {
27359 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27360 }
27361 return resultobj;
27362 fail:
27363 return NULL;
27364 }
27365
27366
27367 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27368 PyObject *resultobj;
27369 wxDataObject *arg1 = (wxDataObject *) 0 ;
27370 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27371 PyObject *result;
27372 PyObject * obj0 = 0 ;
27373 PyObject * obj1 = 0 ;
27374 char *kwnames[] = {
27375 (char *) "self",(char *) "dir", NULL
27376 };
27377
27378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27380 if (SWIG_arg_fail(1)) SWIG_fail;
27381 if (obj1) {
27382 {
27383 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27384 if (SWIG_arg_fail(2)) SWIG_fail;
27385 }
27386 }
27387 {
27388 PyThreadState* __tstate = wxPyBeginAllowThreads();
27389 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27390
27391 wxPyEndAllowThreads(__tstate);
27392 if (PyErr_Occurred()) SWIG_fail;
27393 }
27394 resultobj = result;
27395 return resultobj;
27396 fail:
27397 return NULL;
27398 }
27399
27400
27401 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27402 PyObject *resultobj;
27403 wxDataObject *arg1 = (wxDataObject *) 0 ;
27404 wxDataFormat *arg2 = 0 ;
27405 PyObject *result;
27406 PyObject * obj0 = 0 ;
27407 PyObject * obj1 = 0 ;
27408 char *kwnames[] = {
27409 (char *) "self",(char *) "format", NULL
27410 };
27411
27412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27414 if (SWIG_arg_fail(1)) SWIG_fail;
27415 {
27416 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27417 if (SWIG_arg_fail(2)) SWIG_fail;
27418 if (arg2 == NULL) {
27419 SWIG_null_ref("wxDataFormat");
27420 }
27421 if (SWIG_arg_fail(2)) SWIG_fail;
27422 }
27423 {
27424 PyThreadState* __tstate = wxPyBeginAllowThreads();
27425 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27426
27427 wxPyEndAllowThreads(__tstate);
27428 if (PyErr_Occurred()) SWIG_fail;
27429 }
27430 resultobj = result;
27431 return resultobj;
27432 fail:
27433 return NULL;
27434 }
27435
27436
27437 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27438 PyObject *resultobj;
27439 wxDataObject *arg1 = (wxDataObject *) 0 ;
27440 wxDataFormat *arg2 = 0 ;
27441 PyObject *arg3 = (PyObject *) 0 ;
27442 bool result;
27443 PyObject * obj0 = 0 ;
27444 PyObject * obj1 = 0 ;
27445 PyObject * obj2 = 0 ;
27446 char *kwnames[] = {
27447 (char *) "self",(char *) "format",(char *) "data", NULL
27448 };
27449
27450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27452 if (SWIG_arg_fail(1)) SWIG_fail;
27453 {
27454 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27455 if (SWIG_arg_fail(2)) SWIG_fail;
27456 if (arg2 == NULL) {
27457 SWIG_null_ref("wxDataFormat");
27458 }
27459 if (SWIG_arg_fail(2)) SWIG_fail;
27460 }
27461 arg3 = obj2;
27462 {
27463 PyThreadState* __tstate = wxPyBeginAllowThreads();
27464 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27465
27466 wxPyEndAllowThreads(__tstate);
27467 if (PyErr_Occurred()) SWIG_fail;
27468 }
27469 {
27470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27471 }
27472 return resultobj;
27473 fail:
27474 return NULL;
27475 }
27476
27477
27478 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27479 PyObject *obj;
27480 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27481 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27482 Py_INCREF(obj);
27483 return Py_BuildValue((char *)"");
27484 }
27485 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27486 PyObject *resultobj;
27487 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27488 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27489 wxDataObjectSimple *result;
27490 PyObject * obj0 = 0 ;
27491 char *kwnames[] = {
27492 (char *) "format", NULL
27493 };
27494
27495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27496 if (obj0) {
27497 {
27498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27499 if (SWIG_arg_fail(1)) SWIG_fail;
27500 if (arg1 == NULL) {
27501 SWIG_null_ref("wxDataFormat");
27502 }
27503 if (SWIG_arg_fail(1)) SWIG_fail;
27504 }
27505 }
27506 {
27507 PyThreadState* __tstate = wxPyBeginAllowThreads();
27508 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27509
27510 wxPyEndAllowThreads(__tstate);
27511 if (PyErr_Occurred()) SWIG_fail;
27512 }
27513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27514 return resultobj;
27515 fail:
27516 return NULL;
27517 }
27518
27519
27520 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27521 PyObject *resultobj;
27522 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27523 wxDataFormat *result;
27524 PyObject * obj0 = 0 ;
27525 char *kwnames[] = {
27526 (char *) "self", NULL
27527 };
27528
27529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27531 if (SWIG_arg_fail(1)) SWIG_fail;
27532 {
27533 PyThreadState* __tstate = wxPyBeginAllowThreads();
27534 {
27535 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27536 result = (wxDataFormat *) &_result_ref;
27537 }
27538
27539 wxPyEndAllowThreads(__tstate);
27540 if (PyErr_Occurred()) SWIG_fail;
27541 }
27542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27543 return resultobj;
27544 fail:
27545 return NULL;
27546 }
27547
27548
27549 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27550 PyObject *resultobj;
27551 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27552 wxDataFormat *arg2 = 0 ;
27553 PyObject * obj0 = 0 ;
27554 PyObject * obj1 = 0 ;
27555 char *kwnames[] = {
27556 (char *) "self",(char *) "format", NULL
27557 };
27558
27559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27561 if (SWIG_arg_fail(1)) SWIG_fail;
27562 {
27563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27564 if (SWIG_arg_fail(2)) SWIG_fail;
27565 if (arg2 == NULL) {
27566 SWIG_null_ref("wxDataFormat");
27567 }
27568 if (SWIG_arg_fail(2)) SWIG_fail;
27569 }
27570 {
27571 PyThreadState* __tstate = wxPyBeginAllowThreads();
27572 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27573
27574 wxPyEndAllowThreads(__tstate);
27575 if (PyErr_Occurred()) SWIG_fail;
27576 }
27577 Py_INCREF(Py_None); resultobj = Py_None;
27578 return resultobj;
27579 fail:
27580 return NULL;
27581 }
27582
27583
27584 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27585 PyObject *resultobj;
27586 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27587 size_t result;
27588 PyObject * obj0 = 0 ;
27589 char *kwnames[] = {
27590 (char *) "self", NULL
27591 };
27592
27593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27595 if (SWIG_arg_fail(1)) SWIG_fail;
27596 {
27597 PyThreadState* __tstate = wxPyBeginAllowThreads();
27598 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27599
27600 wxPyEndAllowThreads(__tstate);
27601 if (PyErr_Occurred()) SWIG_fail;
27602 }
27603 {
27604 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27605 }
27606 return resultobj;
27607 fail:
27608 return NULL;
27609 }
27610
27611
27612 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27613 PyObject *resultobj;
27614 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27615 PyObject *result;
27616 PyObject * obj0 = 0 ;
27617 char *kwnames[] = {
27618 (char *) "self", NULL
27619 };
27620
27621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27623 if (SWIG_arg_fail(1)) SWIG_fail;
27624 {
27625 PyThreadState* __tstate = wxPyBeginAllowThreads();
27626 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27627
27628 wxPyEndAllowThreads(__tstate);
27629 if (PyErr_Occurred()) SWIG_fail;
27630 }
27631 resultobj = result;
27632 return resultobj;
27633 fail:
27634 return NULL;
27635 }
27636
27637
27638 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27639 PyObject *resultobj;
27640 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27641 PyObject *arg2 = (PyObject *) 0 ;
27642 bool result;
27643 PyObject * obj0 = 0 ;
27644 PyObject * obj1 = 0 ;
27645 char *kwnames[] = {
27646 (char *) "self",(char *) "data", NULL
27647 };
27648
27649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27651 if (SWIG_arg_fail(1)) SWIG_fail;
27652 arg2 = obj1;
27653 {
27654 PyThreadState* __tstate = wxPyBeginAllowThreads();
27655 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27656
27657 wxPyEndAllowThreads(__tstate);
27658 if (PyErr_Occurred()) SWIG_fail;
27659 }
27660 {
27661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27662 }
27663 return resultobj;
27664 fail:
27665 return NULL;
27666 }
27667
27668
27669 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27670 PyObject *obj;
27671 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27672 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27673 Py_INCREF(obj);
27674 return Py_BuildValue((char *)"");
27675 }
27676 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27677 PyObject *resultobj;
27678 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27679 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27680 wxPyDataObjectSimple *result;
27681 PyObject * obj0 = 0 ;
27682 char *kwnames[] = {
27683 (char *) "format", NULL
27684 };
27685
27686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27687 if (obj0) {
27688 {
27689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27690 if (SWIG_arg_fail(1)) SWIG_fail;
27691 if (arg1 == NULL) {
27692 SWIG_null_ref("wxDataFormat");
27693 }
27694 if (SWIG_arg_fail(1)) SWIG_fail;
27695 }
27696 }
27697 {
27698 PyThreadState* __tstate = wxPyBeginAllowThreads();
27699 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27700
27701 wxPyEndAllowThreads(__tstate);
27702 if (PyErr_Occurred()) SWIG_fail;
27703 }
27704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27705 return resultobj;
27706 fail:
27707 return NULL;
27708 }
27709
27710
27711 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27712 PyObject *resultobj;
27713 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27714 PyObject *arg2 = (PyObject *) 0 ;
27715 PyObject *arg3 = (PyObject *) 0 ;
27716 PyObject * obj0 = 0 ;
27717 PyObject * obj1 = 0 ;
27718 PyObject * obj2 = 0 ;
27719 char *kwnames[] = {
27720 (char *) "self",(char *) "self",(char *) "_class", NULL
27721 };
27722
27723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27725 if (SWIG_arg_fail(1)) SWIG_fail;
27726 arg2 = obj1;
27727 arg3 = obj2;
27728 {
27729 PyThreadState* __tstate = wxPyBeginAllowThreads();
27730 (arg1)->_setCallbackInfo(arg2,arg3);
27731
27732 wxPyEndAllowThreads(__tstate);
27733 if (PyErr_Occurred()) SWIG_fail;
27734 }
27735 Py_INCREF(Py_None); resultobj = Py_None;
27736 return resultobj;
27737 fail:
27738 return NULL;
27739 }
27740
27741
27742 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27743 PyObject *obj;
27744 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27745 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27746 Py_INCREF(obj);
27747 return Py_BuildValue((char *)"");
27748 }
27749 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27750 PyObject *resultobj;
27751 wxDataObjectComposite *result;
27752 char *kwnames[] = {
27753 NULL
27754 };
27755
27756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27757 {
27758 PyThreadState* __tstate = wxPyBeginAllowThreads();
27759 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27760
27761 wxPyEndAllowThreads(__tstate);
27762 if (PyErr_Occurred()) SWIG_fail;
27763 }
27764 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27765 return resultobj;
27766 fail:
27767 return NULL;
27768 }
27769
27770
27771 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27772 PyObject *resultobj;
27773 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27774 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27775 bool arg3 = (bool) false ;
27776 PyObject * obj0 = 0 ;
27777 PyObject * obj1 = 0 ;
27778 PyObject * obj2 = 0 ;
27779 char *kwnames[] = {
27780 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27781 };
27782
27783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27785 if (SWIG_arg_fail(1)) SWIG_fail;
27786 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27787 if (SWIG_arg_fail(2)) SWIG_fail;
27788 if (obj2) {
27789 {
27790 arg3 = (bool)(SWIG_As_bool(obj2));
27791 if (SWIG_arg_fail(3)) SWIG_fail;
27792 }
27793 }
27794 {
27795 PyThreadState* __tstate = wxPyBeginAllowThreads();
27796 (arg1)->Add(arg2,arg3);
27797
27798 wxPyEndAllowThreads(__tstate);
27799 if (PyErr_Occurred()) SWIG_fail;
27800 }
27801 Py_INCREF(Py_None); resultobj = Py_None;
27802 return resultobj;
27803 fail:
27804 return NULL;
27805 }
27806
27807
27808 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27809 PyObject *obj;
27810 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27811 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27812 Py_INCREF(obj);
27813 return Py_BuildValue((char *)"");
27814 }
27815 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27816 PyObject *resultobj;
27817 wxString const &arg1_defvalue = wxPyEmptyString ;
27818 wxString *arg1 = (wxString *) &arg1_defvalue ;
27819 wxTextDataObject *result;
27820 bool temp1 = false ;
27821 PyObject * obj0 = 0 ;
27822 char *kwnames[] = {
27823 (char *) "text", NULL
27824 };
27825
27826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27827 if (obj0) {
27828 {
27829 arg1 = wxString_in_helper(obj0);
27830 if (arg1 == NULL) SWIG_fail;
27831 temp1 = true;
27832 }
27833 }
27834 {
27835 PyThreadState* __tstate = wxPyBeginAllowThreads();
27836 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27837
27838 wxPyEndAllowThreads(__tstate);
27839 if (PyErr_Occurred()) SWIG_fail;
27840 }
27841 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27842 {
27843 if (temp1)
27844 delete arg1;
27845 }
27846 return resultobj;
27847 fail:
27848 {
27849 if (temp1)
27850 delete arg1;
27851 }
27852 return NULL;
27853 }
27854
27855
27856 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27857 PyObject *resultobj;
27858 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27859 size_t result;
27860 PyObject * obj0 = 0 ;
27861 char *kwnames[] = {
27862 (char *) "self", NULL
27863 };
27864
27865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27867 if (SWIG_arg_fail(1)) SWIG_fail;
27868 {
27869 PyThreadState* __tstate = wxPyBeginAllowThreads();
27870 result = (size_t)(arg1)->GetTextLength();
27871
27872 wxPyEndAllowThreads(__tstate);
27873 if (PyErr_Occurred()) SWIG_fail;
27874 }
27875 {
27876 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27877 }
27878 return resultobj;
27879 fail:
27880 return NULL;
27881 }
27882
27883
27884 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27885 PyObject *resultobj;
27886 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27887 wxString result;
27888 PyObject * obj0 = 0 ;
27889 char *kwnames[] = {
27890 (char *) "self", NULL
27891 };
27892
27893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27895 if (SWIG_arg_fail(1)) SWIG_fail;
27896 {
27897 PyThreadState* __tstate = wxPyBeginAllowThreads();
27898 result = (arg1)->GetText();
27899
27900 wxPyEndAllowThreads(__tstate);
27901 if (PyErr_Occurred()) SWIG_fail;
27902 }
27903 {
27904 #if wxUSE_UNICODE
27905 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27906 #else
27907 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27908 #endif
27909 }
27910 return resultobj;
27911 fail:
27912 return NULL;
27913 }
27914
27915
27916 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27917 PyObject *resultobj;
27918 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27919 wxString *arg2 = 0 ;
27920 bool temp2 = false ;
27921 PyObject * obj0 = 0 ;
27922 PyObject * obj1 = 0 ;
27923 char *kwnames[] = {
27924 (char *) "self",(char *) "text", NULL
27925 };
27926
27927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27929 if (SWIG_arg_fail(1)) SWIG_fail;
27930 {
27931 arg2 = wxString_in_helper(obj1);
27932 if (arg2 == NULL) SWIG_fail;
27933 temp2 = true;
27934 }
27935 {
27936 PyThreadState* __tstate = wxPyBeginAllowThreads();
27937 (arg1)->SetText((wxString const &)*arg2);
27938
27939 wxPyEndAllowThreads(__tstate);
27940 if (PyErr_Occurred()) SWIG_fail;
27941 }
27942 Py_INCREF(Py_None); resultobj = Py_None;
27943 {
27944 if (temp2)
27945 delete arg2;
27946 }
27947 return resultobj;
27948 fail:
27949 {
27950 if (temp2)
27951 delete arg2;
27952 }
27953 return NULL;
27954 }
27955
27956
27957 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27958 PyObject *obj;
27959 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27960 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27961 Py_INCREF(obj);
27962 return Py_BuildValue((char *)"");
27963 }
27964 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27965 PyObject *resultobj;
27966 wxString const &arg1_defvalue = wxPyEmptyString ;
27967 wxString *arg1 = (wxString *) &arg1_defvalue ;
27968 wxPyTextDataObject *result;
27969 bool temp1 = false ;
27970 PyObject * obj0 = 0 ;
27971 char *kwnames[] = {
27972 (char *) "text", NULL
27973 };
27974
27975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27976 if (obj0) {
27977 {
27978 arg1 = wxString_in_helper(obj0);
27979 if (arg1 == NULL) SWIG_fail;
27980 temp1 = true;
27981 }
27982 }
27983 {
27984 PyThreadState* __tstate = wxPyBeginAllowThreads();
27985 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27986
27987 wxPyEndAllowThreads(__tstate);
27988 if (PyErr_Occurred()) SWIG_fail;
27989 }
27990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27991 {
27992 if (temp1)
27993 delete arg1;
27994 }
27995 return resultobj;
27996 fail:
27997 {
27998 if (temp1)
27999 delete arg1;
28000 }
28001 return NULL;
28002 }
28003
28004
28005 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28006 PyObject *resultobj;
28007 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
28008 PyObject *arg2 = (PyObject *) 0 ;
28009 PyObject *arg3 = (PyObject *) 0 ;
28010 PyObject * obj0 = 0 ;
28011 PyObject * obj1 = 0 ;
28012 PyObject * obj2 = 0 ;
28013 char *kwnames[] = {
28014 (char *) "self",(char *) "self",(char *) "_class", NULL
28015 };
28016
28017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28019 if (SWIG_arg_fail(1)) SWIG_fail;
28020 arg2 = obj1;
28021 arg3 = obj2;
28022 {
28023 PyThreadState* __tstate = wxPyBeginAllowThreads();
28024 (arg1)->_setCallbackInfo(arg2,arg3);
28025
28026 wxPyEndAllowThreads(__tstate);
28027 if (PyErr_Occurred()) SWIG_fail;
28028 }
28029 Py_INCREF(Py_None); resultobj = Py_None;
28030 return resultobj;
28031 fail:
28032 return NULL;
28033 }
28034
28035
28036 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
28037 PyObject *obj;
28038 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28039 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
28040 Py_INCREF(obj);
28041 return Py_BuildValue((char *)"");
28042 }
28043 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28044 PyObject *resultobj;
28045 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28046 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28047 wxBitmapDataObject *result;
28048 PyObject * obj0 = 0 ;
28049 char *kwnames[] = {
28050 (char *) "bitmap", NULL
28051 };
28052
28053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
28054 if (obj0) {
28055 {
28056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28057 if (SWIG_arg_fail(1)) SWIG_fail;
28058 if (arg1 == NULL) {
28059 SWIG_null_ref("wxBitmap");
28060 }
28061 if (SWIG_arg_fail(1)) SWIG_fail;
28062 }
28063 }
28064 {
28065 PyThreadState* __tstate = wxPyBeginAllowThreads();
28066 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
28067
28068 wxPyEndAllowThreads(__tstate);
28069 if (PyErr_Occurred()) SWIG_fail;
28070 }
28071 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
28072 return resultobj;
28073 fail:
28074 return NULL;
28075 }
28076
28077
28078 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
28079 PyObject *resultobj;
28080 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
28081 wxBitmap result;
28082 PyObject * obj0 = 0 ;
28083 char *kwnames[] = {
28084 (char *) "self", NULL
28085 };
28086
28087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
28088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28089 if (SWIG_arg_fail(1)) SWIG_fail;
28090 {
28091 PyThreadState* __tstate = wxPyBeginAllowThreads();
28092 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
28093
28094 wxPyEndAllowThreads(__tstate);
28095 if (PyErr_Occurred()) SWIG_fail;
28096 }
28097 {
28098 wxBitmap * resultptr;
28099 resultptr = new wxBitmap((wxBitmap &)(result));
28100 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
28101 }
28102 return resultobj;
28103 fail:
28104 return NULL;
28105 }
28106
28107
28108 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
28109 PyObject *resultobj;
28110 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
28111 wxBitmap *arg2 = 0 ;
28112 PyObject * obj0 = 0 ;
28113 PyObject * obj1 = 0 ;
28114 char *kwnames[] = {
28115 (char *) "self",(char *) "bitmap", NULL
28116 };
28117
28118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
28119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28120 if (SWIG_arg_fail(1)) SWIG_fail;
28121 {
28122 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28123 if (SWIG_arg_fail(2)) SWIG_fail;
28124 if (arg2 == NULL) {
28125 SWIG_null_ref("wxBitmap");
28126 }
28127 if (SWIG_arg_fail(2)) SWIG_fail;
28128 }
28129 {
28130 PyThreadState* __tstate = wxPyBeginAllowThreads();
28131 (arg1)->SetBitmap((wxBitmap const &)*arg2);
28132
28133 wxPyEndAllowThreads(__tstate);
28134 if (PyErr_Occurred()) SWIG_fail;
28135 }
28136 Py_INCREF(Py_None); resultobj = Py_None;
28137 return resultobj;
28138 fail:
28139 return NULL;
28140 }
28141
28142
28143 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
28144 PyObject *obj;
28145 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28146 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
28147 Py_INCREF(obj);
28148 return Py_BuildValue((char *)"");
28149 }
28150 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28151 PyObject *resultobj;
28152 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28153 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28154 wxPyBitmapDataObject *result;
28155 PyObject * obj0 = 0 ;
28156 char *kwnames[] = {
28157 (char *) "bitmap", NULL
28158 };
28159
28160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
28161 if (obj0) {
28162 {
28163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28164 if (SWIG_arg_fail(1)) SWIG_fail;
28165 if (arg1 == NULL) {
28166 SWIG_null_ref("wxBitmap");
28167 }
28168 if (SWIG_arg_fail(1)) SWIG_fail;
28169 }
28170 }
28171 {
28172 PyThreadState* __tstate = wxPyBeginAllowThreads();
28173 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
28174
28175 wxPyEndAllowThreads(__tstate);
28176 if (PyErr_Occurred()) SWIG_fail;
28177 }
28178 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
28179 return resultobj;
28180 fail:
28181 return NULL;
28182 }
28183
28184
28185 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28186 PyObject *resultobj;
28187 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28188 PyObject *arg2 = (PyObject *) 0 ;
28189 PyObject *arg3 = (PyObject *) 0 ;
28190 PyObject * obj0 = 0 ;
28191 PyObject * obj1 = 0 ;
28192 PyObject * obj2 = 0 ;
28193 char *kwnames[] = {
28194 (char *) "self",(char *) "self",(char *) "_class", NULL
28195 };
28196
28197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28199 if (SWIG_arg_fail(1)) SWIG_fail;
28200 arg2 = obj1;
28201 arg3 = obj2;
28202 {
28203 PyThreadState* __tstate = wxPyBeginAllowThreads();
28204 (arg1)->_setCallbackInfo(arg2,arg3);
28205
28206 wxPyEndAllowThreads(__tstate);
28207 if (PyErr_Occurred()) SWIG_fail;
28208 }
28209 Py_INCREF(Py_None); resultobj = Py_None;
28210 return resultobj;
28211 fail:
28212 return NULL;
28213 }
28214
28215
28216 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28217 PyObject *obj;
28218 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28219 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28220 Py_INCREF(obj);
28221 return Py_BuildValue((char *)"");
28222 }
28223 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28224 PyObject *resultobj;
28225 wxFileDataObject *result;
28226 char *kwnames[] = {
28227 NULL
28228 };
28229
28230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28231 {
28232 PyThreadState* __tstate = wxPyBeginAllowThreads();
28233 result = (wxFileDataObject *)new wxFileDataObject();
28234
28235 wxPyEndAllowThreads(__tstate);
28236 if (PyErr_Occurred()) SWIG_fail;
28237 }
28238 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28239 return resultobj;
28240 fail:
28241 return NULL;
28242 }
28243
28244
28245 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28246 PyObject *resultobj;
28247 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28248 wxArrayString *result;
28249 PyObject * obj0 = 0 ;
28250 char *kwnames[] = {
28251 (char *) "self", NULL
28252 };
28253
28254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28256 if (SWIG_arg_fail(1)) SWIG_fail;
28257 {
28258 PyThreadState* __tstate = wxPyBeginAllowThreads();
28259 {
28260 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28261 result = (wxArrayString *) &_result_ref;
28262 }
28263
28264 wxPyEndAllowThreads(__tstate);
28265 if (PyErr_Occurred()) SWIG_fail;
28266 }
28267 {
28268 resultobj = wxArrayString2PyList_helper(*result);
28269 }
28270 return resultobj;
28271 fail:
28272 return NULL;
28273 }
28274
28275
28276 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28277 PyObject *resultobj;
28278 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28279 wxString *arg2 = 0 ;
28280 bool temp2 = false ;
28281 PyObject * obj0 = 0 ;
28282 PyObject * obj1 = 0 ;
28283 char *kwnames[] = {
28284 (char *) "self",(char *) "filename", NULL
28285 };
28286
28287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28289 if (SWIG_arg_fail(1)) SWIG_fail;
28290 {
28291 arg2 = wxString_in_helper(obj1);
28292 if (arg2 == NULL) SWIG_fail;
28293 temp2 = true;
28294 }
28295 {
28296 PyThreadState* __tstate = wxPyBeginAllowThreads();
28297 (arg1)->AddFile((wxString const &)*arg2);
28298
28299 wxPyEndAllowThreads(__tstate);
28300 if (PyErr_Occurred()) SWIG_fail;
28301 }
28302 Py_INCREF(Py_None); resultobj = Py_None;
28303 {
28304 if (temp2)
28305 delete arg2;
28306 }
28307 return resultobj;
28308 fail:
28309 {
28310 if (temp2)
28311 delete arg2;
28312 }
28313 return NULL;
28314 }
28315
28316
28317 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28318 PyObject *obj;
28319 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28320 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28321 Py_INCREF(obj);
28322 return Py_BuildValue((char *)"");
28323 }
28324 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28325 PyObject *resultobj;
28326 wxDataFormat *arg1 = 0 ;
28327 wxCustomDataObject *result;
28328 PyObject * obj0 = 0 ;
28329
28330 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28331 {
28332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28333 if (SWIG_arg_fail(1)) SWIG_fail;
28334 if (arg1 == NULL) {
28335 SWIG_null_ref("wxDataFormat");
28336 }
28337 if (SWIG_arg_fail(1)) SWIG_fail;
28338 }
28339 {
28340 PyThreadState* __tstate = wxPyBeginAllowThreads();
28341 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28342
28343 wxPyEndAllowThreads(__tstate);
28344 if (PyErr_Occurred()) SWIG_fail;
28345 }
28346 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28347 return resultobj;
28348 fail:
28349 return NULL;
28350 }
28351
28352
28353 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28354 PyObject *resultobj;
28355 wxString *arg1 = 0 ;
28356 wxCustomDataObject *result;
28357 bool temp1 = false ;
28358 PyObject * obj0 = 0 ;
28359
28360 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28361 {
28362 arg1 = wxString_in_helper(obj0);
28363 if (arg1 == NULL) SWIG_fail;
28364 temp1 = true;
28365 }
28366 {
28367 PyThreadState* __tstate = wxPyBeginAllowThreads();
28368 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28369
28370 wxPyEndAllowThreads(__tstate);
28371 if (PyErr_Occurred()) SWIG_fail;
28372 }
28373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28374 {
28375 if (temp1)
28376 delete arg1;
28377 }
28378 return resultobj;
28379 fail:
28380 {
28381 if (temp1)
28382 delete arg1;
28383 }
28384 return NULL;
28385 }
28386
28387
28388 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28389 PyObject *resultobj;
28390 wxCustomDataObject *result;
28391
28392 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28393 {
28394 PyThreadState* __tstate = wxPyBeginAllowThreads();
28395 result = (wxCustomDataObject *)new wxCustomDataObject();
28396
28397 wxPyEndAllowThreads(__tstate);
28398 if (PyErr_Occurred()) SWIG_fail;
28399 }
28400 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28401 return resultobj;
28402 fail:
28403 return NULL;
28404 }
28405
28406
28407 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28408 int argc;
28409 PyObject *argv[2];
28410 int ii;
28411
28412 argc = PyObject_Length(args);
28413 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28414 argv[ii] = PyTuple_GetItem(args,ii);
28415 }
28416 if (argc == 0) {
28417 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28418 }
28419 if (argc == 1) {
28420 int _v;
28421 {
28422 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28423 }
28424 if (_v) {
28425 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28426 }
28427 }
28428 if (argc == 1) {
28429 int _v;
28430 {
28431 void *ptr = 0;
28432 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28433 _v = 0;
28434 PyErr_Clear();
28435 } else {
28436 _v = (ptr != 0);
28437 }
28438 }
28439 if (_v) {
28440 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28441 }
28442 }
28443
28444 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28445 return NULL;
28446 }
28447
28448
28449 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28450 PyObject *resultobj;
28451 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28452 PyObject *arg2 = (PyObject *) 0 ;
28453 bool result;
28454 PyObject * obj0 = 0 ;
28455 PyObject * obj1 = 0 ;
28456 char *kwnames[] = {
28457 (char *) "self",(char *) "data", NULL
28458 };
28459
28460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28462 if (SWIG_arg_fail(1)) SWIG_fail;
28463 arg2 = obj1;
28464 {
28465 PyThreadState* __tstate = wxPyBeginAllowThreads();
28466 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28467
28468 wxPyEndAllowThreads(__tstate);
28469 if (PyErr_Occurred()) SWIG_fail;
28470 }
28471 {
28472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28473 }
28474 return resultobj;
28475 fail:
28476 return NULL;
28477 }
28478
28479
28480 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28481 PyObject *resultobj;
28482 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28483 size_t result;
28484 PyObject * obj0 = 0 ;
28485 char *kwnames[] = {
28486 (char *) "self", NULL
28487 };
28488
28489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28491 if (SWIG_arg_fail(1)) SWIG_fail;
28492 {
28493 PyThreadState* __tstate = wxPyBeginAllowThreads();
28494 result = (size_t)(arg1)->GetSize();
28495
28496 wxPyEndAllowThreads(__tstate);
28497 if (PyErr_Occurred()) SWIG_fail;
28498 }
28499 {
28500 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28501 }
28502 return resultobj;
28503 fail:
28504 return NULL;
28505 }
28506
28507
28508 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28509 PyObject *resultobj;
28510 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28511 PyObject *result;
28512 PyObject * obj0 = 0 ;
28513 char *kwnames[] = {
28514 (char *) "self", NULL
28515 };
28516
28517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28519 if (SWIG_arg_fail(1)) SWIG_fail;
28520 {
28521 PyThreadState* __tstate = wxPyBeginAllowThreads();
28522 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28523
28524 wxPyEndAllowThreads(__tstate);
28525 if (PyErr_Occurred()) SWIG_fail;
28526 }
28527 resultobj = result;
28528 return resultobj;
28529 fail:
28530 return NULL;
28531 }
28532
28533
28534 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28535 PyObject *obj;
28536 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28537 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28538 Py_INCREF(obj);
28539 return Py_BuildValue((char *)"");
28540 }
28541 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28542 PyObject *resultobj;
28543 wxURLDataObject *result;
28544 char *kwnames[] = {
28545 NULL
28546 };
28547
28548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28549 {
28550 PyThreadState* __tstate = wxPyBeginAllowThreads();
28551 result = (wxURLDataObject *)new wxURLDataObject();
28552
28553 wxPyEndAllowThreads(__tstate);
28554 if (PyErr_Occurred()) SWIG_fail;
28555 }
28556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28557 return resultobj;
28558 fail:
28559 return NULL;
28560 }
28561
28562
28563 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28564 PyObject *resultobj;
28565 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28566 wxString result;
28567 PyObject * obj0 = 0 ;
28568 char *kwnames[] = {
28569 (char *) "self", NULL
28570 };
28571
28572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28574 if (SWIG_arg_fail(1)) SWIG_fail;
28575 {
28576 PyThreadState* __tstate = wxPyBeginAllowThreads();
28577 result = (arg1)->GetURL();
28578
28579 wxPyEndAllowThreads(__tstate);
28580 if (PyErr_Occurred()) SWIG_fail;
28581 }
28582 {
28583 #if wxUSE_UNICODE
28584 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28585 #else
28586 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28587 #endif
28588 }
28589 return resultobj;
28590 fail:
28591 return NULL;
28592 }
28593
28594
28595 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28596 PyObject *resultobj;
28597 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28598 wxString *arg2 = 0 ;
28599 bool temp2 = false ;
28600 PyObject * obj0 = 0 ;
28601 PyObject * obj1 = 0 ;
28602 char *kwnames[] = {
28603 (char *) "self",(char *) "url", NULL
28604 };
28605
28606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28608 if (SWIG_arg_fail(1)) SWIG_fail;
28609 {
28610 arg2 = wxString_in_helper(obj1);
28611 if (arg2 == NULL) SWIG_fail;
28612 temp2 = true;
28613 }
28614 {
28615 PyThreadState* __tstate = wxPyBeginAllowThreads();
28616 (arg1)->SetURL((wxString const &)*arg2);
28617
28618 wxPyEndAllowThreads(__tstate);
28619 if (PyErr_Occurred()) SWIG_fail;
28620 }
28621 Py_INCREF(Py_None); resultobj = Py_None;
28622 {
28623 if (temp2)
28624 delete arg2;
28625 }
28626 return resultobj;
28627 fail:
28628 {
28629 if (temp2)
28630 delete arg2;
28631 }
28632 return NULL;
28633 }
28634
28635
28636 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28637 PyObject *obj;
28638 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28639 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28640 Py_INCREF(obj);
28641 return Py_BuildValue((char *)"");
28642 }
28643 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28644 PyObject *resultobj;
28645 wxMetafileDataObject *result;
28646 char *kwnames[] = {
28647 NULL
28648 };
28649
28650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28651 {
28652 PyThreadState* __tstate = wxPyBeginAllowThreads();
28653 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28654
28655 wxPyEndAllowThreads(__tstate);
28656 if (PyErr_Occurred()) SWIG_fail;
28657 }
28658 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28659 return resultobj;
28660 fail:
28661 return NULL;
28662 }
28663
28664
28665 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28666 PyObject *obj;
28667 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28668 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28669 Py_INCREF(obj);
28670 return Py_BuildValue((char *)"");
28671 }
28672 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28673 PyObject *resultobj;
28674 wxDragResult arg1 ;
28675 bool result;
28676 PyObject * obj0 = 0 ;
28677 char *kwnames[] = {
28678 (char *) "res", NULL
28679 };
28680
28681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28682 {
28683 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28684 if (SWIG_arg_fail(1)) SWIG_fail;
28685 }
28686 {
28687 PyThreadState* __tstate = wxPyBeginAllowThreads();
28688 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28689
28690 wxPyEndAllowThreads(__tstate);
28691 if (PyErr_Occurred()) SWIG_fail;
28692 }
28693 {
28694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28695 }
28696 return resultobj;
28697 fail:
28698 return NULL;
28699 }
28700
28701
28702 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28703 PyObject *resultobj;
28704 wxWindow *arg1 = (wxWindow *) 0 ;
28705 wxIcon const &arg2_defvalue = wxNullIcon ;
28706 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
28707 wxIcon const &arg3_defvalue = wxNullIcon ;
28708 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
28709 wxIcon const &arg4_defvalue = wxNullIcon ;
28710 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
28711 wxPyDropSource *result;
28712 PyObject * obj0 = 0 ;
28713 PyObject * obj1 = 0 ;
28714 PyObject * obj2 = 0 ;
28715 PyObject * obj3 = 0 ;
28716 char *kwnames[] = {
28717 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28718 };
28719
28720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28722 if (SWIG_arg_fail(1)) SWIG_fail;
28723 if (obj1) {
28724 {
28725 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28726 if (SWIG_arg_fail(2)) SWIG_fail;
28727 if (arg2 == NULL) {
28728 SWIG_null_ref("wxIcon");
28729 }
28730 if (SWIG_arg_fail(2)) SWIG_fail;
28731 }
28732 }
28733 if (obj2) {
28734 {
28735 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28736 if (SWIG_arg_fail(3)) SWIG_fail;
28737 if (arg3 == NULL) {
28738 SWIG_null_ref("wxIcon");
28739 }
28740 if (SWIG_arg_fail(3)) SWIG_fail;
28741 }
28742 }
28743 if (obj3) {
28744 {
28745 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28746 if (SWIG_arg_fail(4)) SWIG_fail;
28747 if (arg4 == NULL) {
28748 SWIG_null_ref("wxIcon");
28749 }
28750 if (SWIG_arg_fail(4)) SWIG_fail;
28751 }
28752 }
28753 {
28754 PyThreadState* __tstate = wxPyBeginAllowThreads();
28755 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
28756
28757 wxPyEndAllowThreads(__tstate);
28758 if (PyErr_Occurred()) SWIG_fail;
28759 }
28760 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28761 return resultobj;
28762 fail:
28763 return NULL;
28764 }
28765
28766
28767 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28768 PyObject *resultobj;
28769 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28770 PyObject *arg2 = (PyObject *) 0 ;
28771 PyObject *arg3 = (PyObject *) 0 ;
28772 int arg4 ;
28773 PyObject * obj0 = 0 ;
28774 PyObject * obj1 = 0 ;
28775 PyObject * obj2 = 0 ;
28776 PyObject * obj3 = 0 ;
28777 char *kwnames[] = {
28778 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28779 };
28780
28781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28783 if (SWIG_arg_fail(1)) SWIG_fail;
28784 arg2 = obj1;
28785 arg3 = obj2;
28786 {
28787 arg4 = (int)(SWIG_As_int(obj3));
28788 if (SWIG_arg_fail(4)) SWIG_fail;
28789 }
28790 {
28791 PyThreadState* __tstate = wxPyBeginAllowThreads();
28792 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28793
28794 wxPyEndAllowThreads(__tstate);
28795 if (PyErr_Occurred()) SWIG_fail;
28796 }
28797 Py_INCREF(Py_None); resultobj = Py_None;
28798 return resultobj;
28799 fail:
28800 return NULL;
28801 }
28802
28803
28804 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28805 PyObject *resultobj;
28806 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28807 PyObject * obj0 = 0 ;
28808 char *kwnames[] = {
28809 (char *) "self", NULL
28810 };
28811
28812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28814 if (SWIG_arg_fail(1)) SWIG_fail;
28815 {
28816 PyThreadState* __tstate = wxPyBeginAllowThreads();
28817 delete arg1;
28818
28819 wxPyEndAllowThreads(__tstate);
28820 if (PyErr_Occurred()) SWIG_fail;
28821 }
28822 Py_INCREF(Py_None); resultobj = Py_None;
28823 return resultobj;
28824 fail:
28825 return NULL;
28826 }
28827
28828
28829 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28830 PyObject *resultobj;
28831 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28832 wxDataObject *arg2 = 0 ;
28833 PyObject * obj0 = 0 ;
28834 PyObject * obj1 = 0 ;
28835 char *kwnames[] = {
28836 (char *) "self",(char *) "data", NULL
28837 };
28838
28839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28841 if (SWIG_arg_fail(1)) SWIG_fail;
28842 {
28843 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28844 if (SWIG_arg_fail(2)) SWIG_fail;
28845 if (arg2 == NULL) {
28846 SWIG_null_ref("wxDataObject");
28847 }
28848 if (SWIG_arg_fail(2)) SWIG_fail;
28849 }
28850 {
28851 PyThreadState* __tstate = wxPyBeginAllowThreads();
28852 (arg1)->SetData(*arg2);
28853
28854 wxPyEndAllowThreads(__tstate);
28855 if (PyErr_Occurred()) SWIG_fail;
28856 }
28857 Py_INCREF(Py_None); resultobj = Py_None;
28858 return resultobj;
28859 fail:
28860 return NULL;
28861 }
28862
28863
28864 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28865 PyObject *resultobj;
28866 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28867 wxDataObject *result;
28868 PyObject * obj0 = 0 ;
28869 char *kwnames[] = {
28870 (char *) "self", NULL
28871 };
28872
28873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28875 if (SWIG_arg_fail(1)) SWIG_fail;
28876 {
28877 PyThreadState* __tstate = wxPyBeginAllowThreads();
28878 result = (wxDataObject *)(arg1)->GetDataObject();
28879
28880 wxPyEndAllowThreads(__tstate);
28881 if (PyErr_Occurred()) SWIG_fail;
28882 }
28883 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28884 return resultobj;
28885 fail:
28886 return NULL;
28887 }
28888
28889
28890 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28891 PyObject *resultobj;
28892 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28893 wxDragResult arg2 ;
28894 wxCursor *arg3 = 0 ;
28895 PyObject * obj0 = 0 ;
28896 PyObject * obj1 = 0 ;
28897 PyObject * obj2 = 0 ;
28898 char *kwnames[] = {
28899 (char *) "self",(char *) "res",(char *) "cursor", NULL
28900 };
28901
28902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28904 if (SWIG_arg_fail(1)) SWIG_fail;
28905 {
28906 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28907 if (SWIG_arg_fail(2)) SWIG_fail;
28908 }
28909 {
28910 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28911 if (SWIG_arg_fail(3)) SWIG_fail;
28912 if (arg3 == NULL) {
28913 SWIG_null_ref("wxCursor");
28914 }
28915 if (SWIG_arg_fail(3)) SWIG_fail;
28916 }
28917 {
28918 PyThreadState* __tstate = wxPyBeginAllowThreads();
28919 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28920
28921 wxPyEndAllowThreads(__tstate);
28922 if (PyErr_Occurred()) SWIG_fail;
28923 }
28924 Py_INCREF(Py_None); resultobj = Py_None;
28925 return resultobj;
28926 fail:
28927 return NULL;
28928 }
28929
28930
28931 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28932 PyObject *resultobj;
28933 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28934 int arg2 = (int) wxDrag_CopyOnly ;
28935 wxDragResult result;
28936 PyObject * obj0 = 0 ;
28937 PyObject * obj1 = 0 ;
28938 char *kwnames[] = {
28939 (char *) "self",(char *) "flags", NULL
28940 };
28941
28942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28944 if (SWIG_arg_fail(1)) SWIG_fail;
28945 if (obj1) {
28946 {
28947 arg2 = (int)(SWIG_As_int(obj1));
28948 if (SWIG_arg_fail(2)) SWIG_fail;
28949 }
28950 }
28951 {
28952 PyThreadState* __tstate = wxPyBeginAllowThreads();
28953 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28954
28955 wxPyEndAllowThreads(__tstate);
28956 if (PyErr_Occurred()) SWIG_fail;
28957 }
28958 resultobj = SWIG_From_int((result));
28959 return resultobj;
28960 fail:
28961 return NULL;
28962 }
28963
28964
28965 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28966 PyObject *resultobj;
28967 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28968 wxDragResult arg2 ;
28969 bool result;
28970 PyObject * obj0 = 0 ;
28971 PyObject * obj1 = 0 ;
28972 char *kwnames[] = {
28973 (char *) "self",(char *) "effect", NULL
28974 };
28975
28976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28978 if (SWIG_arg_fail(1)) SWIG_fail;
28979 {
28980 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28981 if (SWIG_arg_fail(2)) SWIG_fail;
28982 }
28983 {
28984 PyThreadState* __tstate = wxPyBeginAllowThreads();
28985 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28986
28987 wxPyEndAllowThreads(__tstate);
28988 if (PyErr_Occurred()) SWIG_fail;
28989 }
28990 {
28991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28992 }
28993 return resultobj;
28994 fail:
28995 return NULL;
28996 }
28997
28998
28999 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
29000 PyObject *obj;
29001 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29002 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
29003 Py_INCREF(obj);
29004 return Py_BuildValue((char *)"");
29005 }
29006 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29007 PyObject *resultobj;
29008 wxDataObject *arg1 = (wxDataObject *) NULL ;
29009 wxPyDropTarget *result;
29010 PyObject * obj0 = 0 ;
29011 char *kwnames[] = {
29012 (char *) "dataObject", NULL
29013 };
29014
29015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
29016 if (obj0) {
29017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29018 if (SWIG_arg_fail(1)) SWIG_fail;
29019 }
29020 {
29021 PyThreadState* __tstate = wxPyBeginAllowThreads();
29022 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
29023
29024 wxPyEndAllowThreads(__tstate);
29025 if (PyErr_Occurred()) SWIG_fail;
29026 }
29027 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
29028 return resultobj;
29029 fail:
29030 return NULL;
29031 }
29032
29033
29034 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29035 PyObject *resultobj;
29036 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29037 PyObject *arg2 = (PyObject *) 0 ;
29038 PyObject *arg3 = (PyObject *) 0 ;
29039 PyObject * obj0 = 0 ;
29040 PyObject * obj1 = 0 ;
29041 PyObject * obj2 = 0 ;
29042 char *kwnames[] = {
29043 (char *) "self",(char *) "self",(char *) "_class", NULL
29044 };
29045
29046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29048 if (SWIG_arg_fail(1)) SWIG_fail;
29049 arg2 = obj1;
29050 arg3 = obj2;
29051 {
29052 PyThreadState* __tstate = wxPyBeginAllowThreads();
29053 (arg1)->_setCallbackInfo(arg2,arg3);
29054
29055 wxPyEndAllowThreads(__tstate);
29056 if (PyErr_Occurred()) SWIG_fail;
29057 }
29058 Py_INCREF(Py_None); resultobj = Py_None;
29059 return resultobj;
29060 fail:
29061 return NULL;
29062 }
29063
29064
29065 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29066 PyObject *resultobj;
29067 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29068 PyObject * obj0 = 0 ;
29069 char *kwnames[] = {
29070 (char *) "self", NULL
29071 };
29072
29073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
29074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29075 if (SWIG_arg_fail(1)) SWIG_fail;
29076 {
29077 PyThreadState* __tstate = wxPyBeginAllowThreads();
29078 delete arg1;
29079
29080 wxPyEndAllowThreads(__tstate);
29081 if (PyErr_Occurred()) SWIG_fail;
29082 }
29083 Py_INCREF(Py_None); resultobj = Py_None;
29084 return resultobj;
29085 fail:
29086 return NULL;
29087 }
29088
29089
29090 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29091 PyObject *resultobj;
29092 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29093 wxDataObject *result;
29094 PyObject * obj0 = 0 ;
29095 char *kwnames[] = {
29096 (char *) "self", NULL
29097 };
29098
29099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
29100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29101 if (SWIG_arg_fail(1)) SWIG_fail;
29102 {
29103 PyThreadState* __tstate = wxPyBeginAllowThreads();
29104 result = (wxDataObject *)(arg1)->GetDataObject();
29105
29106 wxPyEndAllowThreads(__tstate);
29107 if (PyErr_Occurred()) SWIG_fail;
29108 }
29109 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
29110 return resultobj;
29111 fail:
29112 return NULL;
29113 }
29114
29115
29116 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29117 PyObject *resultobj;
29118 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29119 wxDataObject *arg2 = (wxDataObject *) 0 ;
29120 PyObject * obj0 = 0 ;
29121 PyObject * obj1 = 0 ;
29122 char *kwnames[] = {
29123 (char *) "self",(char *) "dataObject", NULL
29124 };
29125
29126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
29127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29128 if (SWIG_arg_fail(1)) SWIG_fail;
29129 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29130 if (SWIG_arg_fail(2)) SWIG_fail;
29131 {
29132 PyThreadState* __tstate = wxPyBeginAllowThreads();
29133 (arg1)->SetDataObject(arg2);
29134
29135 wxPyEndAllowThreads(__tstate);
29136 if (PyErr_Occurred()) SWIG_fail;
29137 }
29138 Py_INCREF(Py_None); resultobj = Py_None;
29139 return resultobj;
29140 fail:
29141 return NULL;
29142 }
29143
29144
29145 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29146 PyObject *resultobj;
29147 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29148 int arg2 ;
29149 int arg3 ;
29150 wxDragResult arg4 ;
29151 wxDragResult result;
29152 PyObject * obj0 = 0 ;
29153 PyObject * obj1 = 0 ;
29154 PyObject * obj2 = 0 ;
29155 PyObject * obj3 = 0 ;
29156 char *kwnames[] = {
29157 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29158 };
29159
29160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29162 if (SWIG_arg_fail(1)) SWIG_fail;
29163 {
29164 arg2 = (int)(SWIG_As_int(obj1));
29165 if (SWIG_arg_fail(2)) SWIG_fail;
29166 }
29167 {
29168 arg3 = (int)(SWIG_As_int(obj2));
29169 if (SWIG_arg_fail(3)) SWIG_fail;
29170 }
29171 {
29172 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29173 if (SWIG_arg_fail(4)) SWIG_fail;
29174 }
29175 {
29176 PyThreadState* __tstate = wxPyBeginAllowThreads();
29177 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29178
29179 wxPyEndAllowThreads(__tstate);
29180 if (PyErr_Occurred()) SWIG_fail;
29181 }
29182 resultobj = SWIG_From_int((result));
29183 return resultobj;
29184 fail:
29185 return NULL;
29186 }
29187
29188
29189 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29190 PyObject *resultobj;
29191 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29192 int arg2 ;
29193 int arg3 ;
29194 wxDragResult arg4 ;
29195 wxDragResult result;
29196 PyObject * obj0 = 0 ;
29197 PyObject * obj1 = 0 ;
29198 PyObject * obj2 = 0 ;
29199 PyObject * obj3 = 0 ;
29200 char *kwnames[] = {
29201 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29202 };
29203
29204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29206 if (SWIG_arg_fail(1)) SWIG_fail;
29207 {
29208 arg2 = (int)(SWIG_As_int(obj1));
29209 if (SWIG_arg_fail(2)) SWIG_fail;
29210 }
29211 {
29212 arg3 = (int)(SWIG_As_int(obj2));
29213 if (SWIG_arg_fail(3)) SWIG_fail;
29214 }
29215 {
29216 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29217 if (SWIG_arg_fail(4)) SWIG_fail;
29218 }
29219 {
29220 PyThreadState* __tstate = wxPyBeginAllowThreads();
29221 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29222
29223 wxPyEndAllowThreads(__tstate);
29224 if (PyErr_Occurred()) SWIG_fail;
29225 }
29226 resultobj = SWIG_From_int((result));
29227 return resultobj;
29228 fail:
29229 return NULL;
29230 }
29231
29232
29233 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29234 PyObject *resultobj;
29235 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29236 PyObject * obj0 = 0 ;
29237 char *kwnames[] = {
29238 (char *) "self", NULL
29239 };
29240
29241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29243 if (SWIG_arg_fail(1)) SWIG_fail;
29244 {
29245 PyThreadState* __tstate = wxPyBeginAllowThreads();
29246 (arg1)->base_OnLeave();
29247
29248 wxPyEndAllowThreads(__tstate);
29249 if (PyErr_Occurred()) SWIG_fail;
29250 }
29251 Py_INCREF(Py_None); resultobj = Py_None;
29252 return resultobj;
29253 fail:
29254 return NULL;
29255 }
29256
29257
29258 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29259 PyObject *resultobj;
29260 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29261 int arg2 ;
29262 int arg3 ;
29263 bool result;
29264 PyObject * obj0 = 0 ;
29265 PyObject * obj1 = 0 ;
29266 PyObject * obj2 = 0 ;
29267 char *kwnames[] = {
29268 (char *) "self",(char *) "x",(char *) "y", NULL
29269 };
29270
29271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29273 if (SWIG_arg_fail(1)) SWIG_fail;
29274 {
29275 arg2 = (int)(SWIG_As_int(obj1));
29276 if (SWIG_arg_fail(2)) SWIG_fail;
29277 }
29278 {
29279 arg3 = (int)(SWIG_As_int(obj2));
29280 if (SWIG_arg_fail(3)) SWIG_fail;
29281 }
29282 {
29283 PyThreadState* __tstate = wxPyBeginAllowThreads();
29284 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29285
29286 wxPyEndAllowThreads(__tstate);
29287 if (PyErr_Occurred()) SWIG_fail;
29288 }
29289 {
29290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29291 }
29292 return resultobj;
29293 fail:
29294 return NULL;
29295 }
29296
29297
29298 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29299 PyObject *resultobj;
29300 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29301 bool result;
29302 PyObject * obj0 = 0 ;
29303 char *kwnames[] = {
29304 (char *) "self", NULL
29305 };
29306
29307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29309 if (SWIG_arg_fail(1)) SWIG_fail;
29310 {
29311 PyThreadState* __tstate = wxPyBeginAllowThreads();
29312 result = (bool)(arg1)->GetData();
29313
29314 wxPyEndAllowThreads(__tstate);
29315 if (PyErr_Occurred()) SWIG_fail;
29316 }
29317 {
29318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29319 }
29320 return resultobj;
29321 fail:
29322 return NULL;
29323 }
29324
29325
29326 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29327 PyObject *resultobj;
29328 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29329 wxDragResult arg2 ;
29330 PyObject * obj0 = 0 ;
29331 PyObject * obj1 = 0 ;
29332 char *kwnames[] = {
29333 (char *) "self",(char *) "action", NULL
29334 };
29335
29336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29338 if (SWIG_arg_fail(1)) SWIG_fail;
29339 {
29340 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29341 if (SWIG_arg_fail(2)) SWIG_fail;
29342 }
29343 {
29344 PyThreadState* __tstate = wxPyBeginAllowThreads();
29345 (arg1)->SetDefaultAction((wxDragResult )arg2);
29346
29347 wxPyEndAllowThreads(__tstate);
29348 if (PyErr_Occurred()) SWIG_fail;
29349 }
29350 Py_INCREF(Py_None); resultobj = Py_None;
29351 return resultobj;
29352 fail:
29353 return NULL;
29354 }
29355
29356
29357 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29358 PyObject *resultobj;
29359 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29360 wxDragResult result;
29361 PyObject * obj0 = 0 ;
29362 char *kwnames[] = {
29363 (char *) "self", NULL
29364 };
29365
29366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29368 if (SWIG_arg_fail(1)) SWIG_fail;
29369 {
29370 PyThreadState* __tstate = wxPyBeginAllowThreads();
29371 result = (wxDragResult)(arg1)->GetDefaultAction();
29372
29373 wxPyEndAllowThreads(__tstate);
29374 if (PyErr_Occurred()) SWIG_fail;
29375 }
29376 resultobj = SWIG_From_int((result));
29377 return resultobj;
29378 fail:
29379 return NULL;
29380 }
29381
29382
29383 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29384 PyObject *obj;
29385 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29386 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29387 Py_INCREF(obj);
29388 return Py_BuildValue((char *)"");
29389 }
29390 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29391 PyObject *resultobj;
29392 wxPyTextDropTarget *result;
29393 char *kwnames[] = {
29394 NULL
29395 };
29396
29397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29398 {
29399 PyThreadState* __tstate = wxPyBeginAllowThreads();
29400 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29401
29402 wxPyEndAllowThreads(__tstate);
29403 if (PyErr_Occurred()) SWIG_fail;
29404 }
29405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29406 return resultobj;
29407 fail:
29408 return NULL;
29409 }
29410
29411
29412 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29413 PyObject *resultobj;
29414 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29415 PyObject *arg2 = (PyObject *) 0 ;
29416 PyObject *arg3 = (PyObject *) 0 ;
29417 PyObject * obj0 = 0 ;
29418 PyObject * obj1 = 0 ;
29419 PyObject * obj2 = 0 ;
29420 char *kwnames[] = {
29421 (char *) "self",(char *) "self",(char *) "_class", NULL
29422 };
29423
29424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29426 if (SWIG_arg_fail(1)) SWIG_fail;
29427 arg2 = obj1;
29428 arg3 = obj2;
29429 {
29430 PyThreadState* __tstate = wxPyBeginAllowThreads();
29431 (arg1)->_setCallbackInfo(arg2,arg3);
29432
29433 wxPyEndAllowThreads(__tstate);
29434 if (PyErr_Occurred()) SWIG_fail;
29435 }
29436 Py_INCREF(Py_None); resultobj = Py_None;
29437 return resultobj;
29438 fail:
29439 return NULL;
29440 }
29441
29442
29443 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29444 PyObject *resultobj;
29445 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29446 int arg2 ;
29447 int arg3 ;
29448 wxDragResult arg4 ;
29449 wxDragResult result;
29450 PyObject * obj0 = 0 ;
29451 PyObject * obj1 = 0 ;
29452 PyObject * obj2 = 0 ;
29453 PyObject * obj3 = 0 ;
29454 char *kwnames[] = {
29455 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29456 };
29457
29458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29460 if (SWIG_arg_fail(1)) SWIG_fail;
29461 {
29462 arg2 = (int)(SWIG_As_int(obj1));
29463 if (SWIG_arg_fail(2)) SWIG_fail;
29464 }
29465 {
29466 arg3 = (int)(SWIG_As_int(obj2));
29467 if (SWIG_arg_fail(3)) SWIG_fail;
29468 }
29469 {
29470 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29471 if (SWIG_arg_fail(4)) SWIG_fail;
29472 }
29473 {
29474 PyThreadState* __tstate = wxPyBeginAllowThreads();
29475 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29476
29477 wxPyEndAllowThreads(__tstate);
29478 if (PyErr_Occurred()) SWIG_fail;
29479 }
29480 resultobj = SWIG_From_int((result));
29481 return resultobj;
29482 fail:
29483 return NULL;
29484 }
29485
29486
29487 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29488 PyObject *resultobj;
29489 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29490 int arg2 ;
29491 int arg3 ;
29492 wxDragResult arg4 ;
29493 wxDragResult result;
29494 PyObject * obj0 = 0 ;
29495 PyObject * obj1 = 0 ;
29496 PyObject * obj2 = 0 ;
29497 PyObject * obj3 = 0 ;
29498 char *kwnames[] = {
29499 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29500 };
29501
29502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29504 if (SWIG_arg_fail(1)) SWIG_fail;
29505 {
29506 arg2 = (int)(SWIG_As_int(obj1));
29507 if (SWIG_arg_fail(2)) SWIG_fail;
29508 }
29509 {
29510 arg3 = (int)(SWIG_As_int(obj2));
29511 if (SWIG_arg_fail(3)) SWIG_fail;
29512 }
29513 {
29514 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29515 if (SWIG_arg_fail(4)) SWIG_fail;
29516 }
29517 {
29518 PyThreadState* __tstate = wxPyBeginAllowThreads();
29519 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29520
29521 wxPyEndAllowThreads(__tstate);
29522 if (PyErr_Occurred()) SWIG_fail;
29523 }
29524 resultobj = SWIG_From_int((result));
29525 return resultobj;
29526 fail:
29527 return NULL;
29528 }
29529
29530
29531 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29532 PyObject *resultobj;
29533 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29534 PyObject * obj0 = 0 ;
29535 char *kwnames[] = {
29536 (char *) "self", NULL
29537 };
29538
29539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29541 if (SWIG_arg_fail(1)) SWIG_fail;
29542 {
29543 PyThreadState* __tstate = wxPyBeginAllowThreads();
29544 (arg1)->base_OnLeave();
29545
29546 wxPyEndAllowThreads(__tstate);
29547 if (PyErr_Occurred()) SWIG_fail;
29548 }
29549 Py_INCREF(Py_None); resultobj = Py_None;
29550 return resultobj;
29551 fail:
29552 return NULL;
29553 }
29554
29555
29556 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29557 PyObject *resultobj;
29558 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29559 int arg2 ;
29560 int arg3 ;
29561 bool result;
29562 PyObject * obj0 = 0 ;
29563 PyObject * obj1 = 0 ;
29564 PyObject * obj2 = 0 ;
29565 char *kwnames[] = {
29566 (char *) "self",(char *) "x",(char *) "y", NULL
29567 };
29568
29569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29571 if (SWIG_arg_fail(1)) SWIG_fail;
29572 {
29573 arg2 = (int)(SWIG_As_int(obj1));
29574 if (SWIG_arg_fail(2)) SWIG_fail;
29575 }
29576 {
29577 arg3 = (int)(SWIG_As_int(obj2));
29578 if (SWIG_arg_fail(3)) SWIG_fail;
29579 }
29580 {
29581 PyThreadState* __tstate = wxPyBeginAllowThreads();
29582 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29583
29584 wxPyEndAllowThreads(__tstate);
29585 if (PyErr_Occurred()) SWIG_fail;
29586 }
29587 {
29588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29589 }
29590 return resultobj;
29591 fail:
29592 return NULL;
29593 }
29594
29595
29596 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29597 PyObject *resultobj;
29598 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29599 int arg2 ;
29600 int arg3 ;
29601 wxDragResult arg4 ;
29602 wxDragResult result;
29603 PyObject * obj0 = 0 ;
29604 PyObject * obj1 = 0 ;
29605 PyObject * obj2 = 0 ;
29606 PyObject * obj3 = 0 ;
29607 char *kwnames[] = {
29608 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29609 };
29610
29611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29613 if (SWIG_arg_fail(1)) SWIG_fail;
29614 {
29615 arg2 = (int)(SWIG_As_int(obj1));
29616 if (SWIG_arg_fail(2)) SWIG_fail;
29617 }
29618 {
29619 arg3 = (int)(SWIG_As_int(obj2));
29620 if (SWIG_arg_fail(3)) SWIG_fail;
29621 }
29622 {
29623 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29624 if (SWIG_arg_fail(4)) SWIG_fail;
29625 }
29626 {
29627 PyThreadState* __tstate = wxPyBeginAllowThreads();
29628 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29629
29630 wxPyEndAllowThreads(__tstate);
29631 if (PyErr_Occurred()) SWIG_fail;
29632 }
29633 resultobj = SWIG_From_int((result));
29634 return resultobj;
29635 fail:
29636 return NULL;
29637 }
29638
29639
29640 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29641 PyObject *obj;
29642 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29643 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29644 Py_INCREF(obj);
29645 return Py_BuildValue((char *)"");
29646 }
29647 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29648 PyObject *resultobj;
29649 wxPyFileDropTarget *result;
29650 char *kwnames[] = {
29651 NULL
29652 };
29653
29654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29655 {
29656 PyThreadState* __tstate = wxPyBeginAllowThreads();
29657 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29658
29659 wxPyEndAllowThreads(__tstate);
29660 if (PyErr_Occurred()) SWIG_fail;
29661 }
29662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29663 return resultobj;
29664 fail:
29665 return NULL;
29666 }
29667
29668
29669 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29670 PyObject *resultobj;
29671 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29672 PyObject *arg2 = (PyObject *) 0 ;
29673 PyObject *arg3 = (PyObject *) 0 ;
29674 PyObject * obj0 = 0 ;
29675 PyObject * obj1 = 0 ;
29676 PyObject * obj2 = 0 ;
29677 char *kwnames[] = {
29678 (char *) "self",(char *) "self",(char *) "_class", NULL
29679 };
29680
29681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29683 if (SWIG_arg_fail(1)) SWIG_fail;
29684 arg2 = obj1;
29685 arg3 = obj2;
29686 {
29687 PyThreadState* __tstate = wxPyBeginAllowThreads();
29688 (arg1)->_setCallbackInfo(arg2,arg3);
29689
29690 wxPyEndAllowThreads(__tstate);
29691 if (PyErr_Occurred()) SWIG_fail;
29692 }
29693 Py_INCREF(Py_None); resultobj = Py_None;
29694 return resultobj;
29695 fail:
29696 return NULL;
29697 }
29698
29699
29700 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29701 PyObject *resultobj;
29702 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29703 int arg2 ;
29704 int arg3 ;
29705 wxDragResult arg4 ;
29706 wxDragResult result;
29707 PyObject * obj0 = 0 ;
29708 PyObject * obj1 = 0 ;
29709 PyObject * obj2 = 0 ;
29710 PyObject * obj3 = 0 ;
29711 char *kwnames[] = {
29712 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29713 };
29714
29715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29717 if (SWIG_arg_fail(1)) SWIG_fail;
29718 {
29719 arg2 = (int)(SWIG_As_int(obj1));
29720 if (SWIG_arg_fail(2)) SWIG_fail;
29721 }
29722 {
29723 arg3 = (int)(SWIG_As_int(obj2));
29724 if (SWIG_arg_fail(3)) SWIG_fail;
29725 }
29726 {
29727 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29728 if (SWIG_arg_fail(4)) SWIG_fail;
29729 }
29730 {
29731 PyThreadState* __tstate = wxPyBeginAllowThreads();
29732 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29733
29734 wxPyEndAllowThreads(__tstate);
29735 if (PyErr_Occurred()) SWIG_fail;
29736 }
29737 resultobj = SWIG_From_int((result));
29738 return resultobj;
29739 fail:
29740 return NULL;
29741 }
29742
29743
29744 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29745 PyObject *resultobj;
29746 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29747 int arg2 ;
29748 int arg3 ;
29749 wxDragResult arg4 ;
29750 wxDragResult result;
29751 PyObject * obj0 = 0 ;
29752 PyObject * obj1 = 0 ;
29753 PyObject * obj2 = 0 ;
29754 PyObject * obj3 = 0 ;
29755 char *kwnames[] = {
29756 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29757 };
29758
29759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29761 if (SWIG_arg_fail(1)) SWIG_fail;
29762 {
29763 arg2 = (int)(SWIG_As_int(obj1));
29764 if (SWIG_arg_fail(2)) SWIG_fail;
29765 }
29766 {
29767 arg3 = (int)(SWIG_As_int(obj2));
29768 if (SWIG_arg_fail(3)) SWIG_fail;
29769 }
29770 {
29771 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29772 if (SWIG_arg_fail(4)) SWIG_fail;
29773 }
29774 {
29775 PyThreadState* __tstate = wxPyBeginAllowThreads();
29776 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29777
29778 wxPyEndAllowThreads(__tstate);
29779 if (PyErr_Occurred()) SWIG_fail;
29780 }
29781 resultobj = SWIG_From_int((result));
29782 return resultobj;
29783 fail:
29784 return NULL;
29785 }
29786
29787
29788 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29789 PyObject *resultobj;
29790 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29791 PyObject * obj0 = 0 ;
29792 char *kwnames[] = {
29793 (char *) "self", NULL
29794 };
29795
29796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29798 if (SWIG_arg_fail(1)) SWIG_fail;
29799 {
29800 PyThreadState* __tstate = wxPyBeginAllowThreads();
29801 (arg1)->base_OnLeave();
29802
29803 wxPyEndAllowThreads(__tstate);
29804 if (PyErr_Occurred()) SWIG_fail;
29805 }
29806 Py_INCREF(Py_None); resultobj = Py_None;
29807 return resultobj;
29808 fail:
29809 return NULL;
29810 }
29811
29812
29813 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29814 PyObject *resultobj;
29815 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29816 int arg2 ;
29817 int arg3 ;
29818 bool result;
29819 PyObject * obj0 = 0 ;
29820 PyObject * obj1 = 0 ;
29821 PyObject * obj2 = 0 ;
29822 char *kwnames[] = {
29823 (char *) "self",(char *) "x",(char *) "y", NULL
29824 };
29825
29826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29828 if (SWIG_arg_fail(1)) SWIG_fail;
29829 {
29830 arg2 = (int)(SWIG_As_int(obj1));
29831 if (SWIG_arg_fail(2)) SWIG_fail;
29832 }
29833 {
29834 arg3 = (int)(SWIG_As_int(obj2));
29835 if (SWIG_arg_fail(3)) SWIG_fail;
29836 }
29837 {
29838 PyThreadState* __tstate = wxPyBeginAllowThreads();
29839 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29840
29841 wxPyEndAllowThreads(__tstate);
29842 if (PyErr_Occurred()) SWIG_fail;
29843 }
29844 {
29845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29846 }
29847 return resultobj;
29848 fail:
29849 return NULL;
29850 }
29851
29852
29853 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29854 PyObject *resultobj;
29855 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29856 int arg2 ;
29857 int arg3 ;
29858 wxDragResult arg4 ;
29859 wxDragResult result;
29860 PyObject * obj0 = 0 ;
29861 PyObject * obj1 = 0 ;
29862 PyObject * obj2 = 0 ;
29863 PyObject * obj3 = 0 ;
29864 char *kwnames[] = {
29865 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29866 };
29867
29868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29870 if (SWIG_arg_fail(1)) SWIG_fail;
29871 {
29872 arg2 = (int)(SWIG_As_int(obj1));
29873 if (SWIG_arg_fail(2)) SWIG_fail;
29874 }
29875 {
29876 arg3 = (int)(SWIG_As_int(obj2));
29877 if (SWIG_arg_fail(3)) SWIG_fail;
29878 }
29879 {
29880 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29881 if (SWIG_arg_fail(4)) SWIG_fail;
29882 }
29883 {
29884 PyThreadState* __tstate = wxPyBeginAllowThreads();
29885 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29886
29887 wxPyEndAllowThreads(__tstate);
29888 if (PyErr_Occurred()) SWIG_fail;
29889 }
29890 resultobj = SWIG_From_int((result));
29891 return resultobj;
29892 fail:
29893 return NULL;
29894 }
29895
29896
29897 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29898 PyObject *obj;
29899 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29900 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29901 Py_INCREF(obj);
29902 return Py_BuildValue((char *)"");
29903 }
29904 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29905 PyObject *resultobj;
29906 wxClipboard *result;
29907 char *kwnames[] = {
29908 NULL
29909 };
29910
29911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29912 {
29913 PyThreadState* __tstate = wxPyBeginAllowThreads();
29914 result = (wxClipboard *)new wxClipboard();
29915
29916 wxPyEndAllowThreads(__tstate);
29917 if (PyErr_Occurred()) SWIG_fail;
29918 }
29919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29920 return resultobj;
29921 fail:
29922 return NULL;
29923 }
29924
29925
29926 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29927 PyObject *resultobj;
29928 wxClipboard *arg1 = (wxClipboard *) 0 ;
29929 PyObject * obj0 = 0 ;
29930 char *kwnames[] = {
29931 (char *) "self", NULL
29932 };
29933
29934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29936 if (SWIG_arg_fail(1)) SWIG_fail;
29937 {
29938 PyThreadState* __tstate = wxPyBeginAllowThreads();
29939 delete arg1;
29940
29941 wxPyEndAllowThreads(__tstate);
29942 if (PyErr_Occurred()) SWIG_fail;
29943 }
29944 Py_INCREF(Py_None); resultobj = Py_None;
29945 return resultobj;
29946 fail:
29947 return NULL;
29948 }
29949
29950
29951 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29952 PyObject *resultobj;
29953 wxClipboard *arg1 = (wxClipboard *) 0 ;
29954 bool result;
29955 PyObject * obj0 = 0 ;
29956 char *kwnames[] = {
29957 (char *) "self", NULL
29958 };
29959
29960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29962 if (SWIG_arg_fail(1)) SWIG_fail;
29963 {
29964 PyThreadState* __tstate = wxPyBeginAllowThreads();
29965 result = (bool)(arg1)->Open();
29966
29967 wxPyEndAllowThreads(__tstate);
29968 if (PyErr_Occurred()) SWIG_fail;
29969 }
29970 {
29971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29972 }
29973 return resultobj;
29974 fail:
29975 return NULL;
29976 }
29977
29978
29979 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29980 PyObject *resultobj;
29981 wxClipboard *arg1 = (wxClipboard *) 0 ;
29982 PyObject * obj0 = 0 ;
29983 char *kwnames[] = {
29984 (char *) "self", NULL
29985 };
29986
29987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29989 if (SWIG_arg_fail(1)) SWIG_fail;
29990 {
29991 PyThreadState* __tstate = wxPyBeginAllowThreads();
29992 (arg1)->Close();
29993
29994 wxPyEndAllowThreads(__tstate);
29995 if (PyErr_Occurred()) SWIG_fail;
29996 }
29997 Py_INCREF(Py_None); resultobj = Py_None;
29998 return resultobj;
29999 fail:
30000 return NULL;
30001 }
30002
30003
30004 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
30005 PyObject *resultobj;
30006 wxClipboard *arg1 = (wxClipboard *) 0 ;
30007 bool result;
30008 PyObject * obj0 = 0 ;
30009 char *kwnames[] = {
30010 (char *) "self", NULL
30011 };
30012
30013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
30014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30015 if (SWIG_arg_fail(1)) SWIG_fail;
30016 {
30017 PyThreadState* __tstate = wxPyBeginAllowThreads();
30018 result = (bool)((wxClipboard const *)arg1)->IsOpened();
30019
30020 wxPyEndAllowThreads(__tstate);
30021 if (PyErr_Occurred()) SWIG_fail;
30022 }
30023 {
30024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30025 }
30026 return resultobj;
30027 fail:
30028 return NULL;
30029 }
30030
30031
30032 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
30033 PyObject *resultobj;
30034 wxClipboard *arg1 = (wxClipboard *) 0 ;
30035 wxDataObject *arg2 = (wxDataObject *) 0 ;
30036 bool result;
30037 PyObject * obj0 = 0 ;
30038 PyObject * obj1 = 0 ;
30039 char *kwnames[] = {
30040 (char *) "self",(char *) "data", NULL
30041 };
30042
30043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
30044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30045 if (SWIG_arg_fail(1)) SWIG_fail;
30046 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30047 if (SWIG_arg_fail(2)) SWIG_fail;
30048 {
30049 PyThreadState* __tstate = wxPyBeginAllowThreads();
30050 result = (bool)(arg1)->AddData(arg2);
30051
30052 wxPyEndAllowThreads(__tstate);
30053 if (PyErr_Occurred()) SWIG_fail;
30054 }
30055 {
30056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30057 }
30058 return resultobj;
30059 fail:
30060 return NULL;
30061 }
30062
30063
30064 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
30065 PyObject *resultobj;
30066 wxClipboard *arg1 = (wxClipboard *) 0 ;
30067 wxDataObject *arg2 = (wxDataObject *) 0 ;
30068 bool result;
30069 PyObject * obj0 = 0 ;
30070 PyObject * obj1 = 0 ;
30071 char *kwnames[] = {
30072 (char *) "self",(char *) "data", NULL
30073 };
30074
30075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
30076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30077 if (SWIG_arg_fail(1)) SWIG_fail;
30078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30079 if (SWIG_arg_fail(2)) SWIG_fail;
30080 {
30081 PyThreadState* __tstate = wxPyBeginAllowThreads();
30082 result = (bool)(arg1)->SetData(arg2);
30083
30084 wxPyEndAllowThreads(__tstate);
30085 if (PyErr_Occurred()) SWIG_fail;
30086 }
30087 {
30088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30089 }
30090 return resultobj;
30091 fail:
30092 return NULL;
30093 }
30094
30095
30096 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
30097 PyObject *resultobj;
30098 wxClipboard *arg1 = (wxClipboard *) 0 ;
30099 wxDataFormat *arg2 = 0 ;
30100 bool result;
30101 PyObject * obj0 = 0 ;
30102 PyObject * obj1 = 0 ;
30103 char *kwnames[] = {
30104 (char *) "self",(char *) "format", NULL
30105 };
30106
30107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
30108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30109 if (SWIG_arg_fail(1)) SWIG_fail;
30110 {
30111 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
30112 if (SWIG_arg_fail(2)) SWIG_fail;
30113 if (arg2 == NULL) {
30114 SWIG_null_ref("wxDataFormat");
30115 }
30116 if (SWIG_arg_fail(2)) SWIG_fail;
30117 }
30118 {
30119 PyThreadState* __tstate = wxPyBeginAllowThreads();
30120 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
30121
30122 wxPyEndAllowThreads(__tstate);
30123 if (PyErr_Occurred()) SWIG_fail;
30124 }
30125 {
30126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30127 }
30128 return resultobj;
30129 fail:
30130 return NULL;
30131 }
30132
30133
30134 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30135 PyObject *resultobj;
30136 wxClipboard *arg1 = (wxClipboard *) 0 ;
30137 wxDataObject *arg2 = 0 ;
30138 bool result;
30139 PyObject * obj0 = 0 ;
30140 PyObject * obj1 = 0 ;
30141 char *kwnames[] = {
30142 (char *) "self",(char *) "data", NULL
30143 };
30144
30145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30147 if (SWIG_arg_fail(1)) SWIG_fail;
30148 {
30149 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30150 if (SWIG_arg_fail(2)) SWIG_fail;
30151 if (arg2 == NULL) {
30152 SWIG_null_ref("wxDataObject");
30153 }
30154 if (SWIG_arg_fail(2)) SWIG_fail;
30155 }
30156 {
30157 PyThreadState* __tstate = wxPyBeginAllowThreads();
30158 result = (bool)(arg1)->GetData(*arg2);
30159
30160 wxPyEndAllowThreads(__tstate);
30161 if (PyErr_Occurred()) SWIG_fail;
30162 }
30163 {
30164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30165 }
30166 return resultobj;
30167 fail:
30168 return NULL;
30169 }
30170
30171
30172 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30173 PyObject *resultobj;
30174 wxClipboard *arg1 = (wxClipboard *) 0 ;
30175 PyObject * obj0 = 0 ;
30176 char *kwnames[] = {
30177 (char *) "self", NULL
30178 };
30179
30180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30182 if (SWIG_arg_fail(1)) SWIG_fail;
30183 {
30184 PyThreadState* __tstate = wxPyBeginAllowThreads();
30185 (arg1)->Clear();
30186
30187 wxPyEndAllowThreads(__tstate);
30188 if (PyErr_Occurred()) SWIG_fail;
30189 }
30190 Py_INCREF(Py_None); resultobj = Py_None;
30191 return resultobj;
30192 fail:
30193 return NULL;
30194 }
30195
30196
30197 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30198 PyObject *resultobj;
30199 wxClipboard *arg1 = (wxClipboard *) 0 ;
30200 bool result;
30201 PyObject * obj0 = 0 ;
30202 char *kwnames[] = {
30203 (char *) "self", NULL
30204 };
30205
30206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30208 if (SWIG_arg_fail(1)) SWIG_fail;
30209 {
30210 PyThreadState* __tstate = wxPyBeginAllowThreads();
30211 result = (bool)(arg1)->Flush();
30212
30213 wxPyEndAllowThreads(__tstate);
30214 if (PyErr_Occurred()) SWIG_fail;
30215 }
30216 {
30217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30218 }
30219 return resultobj;
30220 fail:
30221 return NULL;
30222 }
30223
30224
30225 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30226 PyObject *resultobj;
30227 wxClipboard *arg1 = (wxClipboard *) 0 ;
30228 bool arg2 = (bool) true ;
30229 PyObject * obj0 = 0 ;
30230 PyObject * obj1 = 0 ;
30231 char *kwnames[] = {
30232 (char *) "self",(char *) "primary", NULL
30233 };
30234
30235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30237 if (SWIG_arg_fail(1)) SWIG_fail;
30238 if (obj1) {
30239 {
30240 arg2 = (bool)(SWIG_As_bool(obj1));
30241 if (SWIG_arg_fail(2)) SWIG_fail;
30242 }
30243 }
30244 {
30245 PyThreadState* __tstate = wxPyBeginAllowThreads();
30246 (arg1)->UsePrimarySelection(arg2);
30247
30248 wxPyEndAllowThreads(__tstate);
30249 if (PyErr_Occurred()) SWIG_fail;
30250 }
30251 Py_INCREF(Py_None); resultobj = Py_None;
30252 return resultobj;
30253 fail:
30254 return NULL;
30255 }
30256
30257
30258 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30259 PyObject *resultobj;
30260 wxClipboard *result;
30261 char *kwnames[] = {
30262 NULL
30263 };
30264
30265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30266 {
30267 PyThreadState* __tstate = wxPyBeginAllowThreads();
30268 result = (wxClipboard *)wxClipboard::Get();
30269
30270 wxPyEndAllowThreads(__tstate);
30271 if (PyErr_Occurred()) SWIG_fail;
30272 }
30273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30274 return resultobj;
30275 fail:
30276 return NULL;
30277 }
30278
30279
30280 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30281 PyObject *obj;
30282 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30283 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30284 Py_INCREF(obj);
30285 return Py_BuildValue((char *)"");
30286 }
30287 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30288 PyObject *resultobj;
30289 wxClipboard *arg1 = (wxClipboard *) NULL ;
30290 wxClipboardLocker *result;
30291 PyObject * obj0 = 0 ;
30292 char *kwnames[] = {
30293 (char *) "clipboard", NULL
30294 };
30295
30296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30297 if (obj0) {
30298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30299 if (SWIG_arg_fail(1)) SWIG_fail;
30300 }
30301 {
30302 PyThreadState* __tstate = wxPyBeginAllowThreads();
30303 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30304
30305 wxPyEndAllowThreads(__tstate);
30306 if (PyErr_Occurred()) SWIG_fail;
30307 }
30308 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30309 return resultobj;
30310 fail:
30311 return NULL;
30312 }
30313
30314
30315 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30316 PyObject *resultobj;
30317 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30318 PyObject * obj0 = 0 ;
30319 char *kwnames[] = {
30320 (char *) "self", NULL
30321 };
30322
30323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30325 if (SWIG_arg_fail(1)) SWIG_fail;
30326 {
30327 PyThreadState* __tstate = wxPyBeginAllowThreads();
30328 delete arg1;
30329
30330 wxPyEndAllowThreads(__tstate);
30331 if (PyErr_Occurred()) SWIG_fail;
30332 }
30333 Py_INCREF(Py_None); resultobj = Py_None;
30334 return resultobj;
30335 fail:
30336 return NULL;
30337 }
30338
30339
30340 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30341 PyObject *resultobj;
30342 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30343 bool result;
30344 PyObject * obj0 = 0 ;
30345 char *kwnames[] = {
30346 (char *) "self", NULL
30347 };
30348
30349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30351 if (SWIG_arg_fail(1)) SWIG_fail;
30352 {
30353 PyThreadState* __tstate = wxPyBeginAllowThreads();
30354 result = (bool)wxClipboardLocker___nonzero__(arg1);
30355
30356 wxPyEndAllowThreads(__tstate);
30357 if (PyErr_Occurred()) SWIG_fail;
30358 }
30359 {
30360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30361 }
30362 return resultobj;
30363 fail:
30364 return NULL;
30365 }
30366
30367
30368 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30369 PyObject *obj;
30370 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30371 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30372 Py_INCREF(obj);
30373 return Py_BuildValue((char *)"");
30374 }
30375 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30376 PyObject *resultobj;
30377 int arg1 = (int) 0 ;
30378 int arg2 = (int) 0 ;
30379 int arg3 = (int) 0 ;
30380 int arg4 = (int) 0 ;
30381 wxVideoMode *result;
30382 PyObject * obj0 = 0 ;
30383 PyObject * obj1 = 0 ;
30384 PyObject * obj2 = 0 ;
30385 PyObject * obj3 = 0 ;
30386 char *kwnames[] = {
30387 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30388 };
30389
30390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30391 if (obj0) {
30392 {
30393 arg1 = (int)(SWIG_As_int(obj0));
30394 if (SWIG_arg_fail(1)) SWIG_fail;
30395 }
30396 }
30397 if (obj1) {
30398 {
30399 arg2 = (int)(SWIG_As_int(obj1));
30400 if (SWIG_arg_fail(2)) SWIG_fail;
30401 }
30402 }
30403 if (obj2) {
30404 {
30405 arg3 = (int)(SWIG_As_int(obj2));
30406 if (SWIG_arg_fail(3)) SWIG_fail;
30407 }
30408 }
30409 if (obj3) {
30410 {
30411 arg4 = (int)(SWIG_As_int(obj3));
30412 if (SWIG_arg_fail(4)) SWIG_fail;
30413 }
30414 }
30415 {
30416 PyThreadState* __tstate = wxPyBeginAllowThreads();
30417 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30418
30419 wxPyEndAllowThreads(__tstate);
30420 if (PyErr_Occurred()) SWIG_fail;
30421 }
30422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30423 return resultobj;
30424 fail:
30425 return NULL;
30426 }
30427
30428
30429 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30430 PyObject *resultobj;
30431 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30432 PyObject * obj0 = 0 ;
30433 char *kwnames[] = {
30434 (char *) "self", NULL
30435 };
30436
30437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30439 if (SWIG_arg_fail(1)) SWIG_fail;
30440 {
30441 PyThreadState* __tstate = wxPyBeginAllowThreads();
30442 delete arg1;
30443
30444 wxPyEndAllowThreads(__tstate);
30445 if (PyErr_Occurred()) SWIG_fail;
30446 }
30447 Py_INCREF(Py_None); resultobj = Py_None;
30448 return resultobj;
30449 fail:
30450 return NULL;
30451 }
30452
30453
30454 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30455 PyObject *resultobj;
30456 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30457 wxVideoMode *arg2 = 0 ;
30458 bool result;
30459 PyObject * obj0 = 0 ;
30460 PyObject * obj1 = 0 ;
30461 char *kwnames[] = {
30462 (char *) "self",(char *) "other", NULL
30463 };
30464
30465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30467 if (SWIG_arg_fail(1)) SWIG_fail;
30468 {
30469 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30470 if (SWIG_arg_fail(2)) SWIG_fail;
30471 if (arg2 == NULL) {
30472 SWIG_null_ref("wxVideoMode");
30473 }
30474 if (SWIG_arg_fail(2)) SWIG_fail;
30475 }
30476 {
30477 PyThreadState* __tstate = wxPyBeginAllowThreads();
30478 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30479
30480 wxPyEndAllowThreads(__tstate);
30481 if (PyErr_Occurred()) SWIG_fail;
30482 }
30483 {
30484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30485 }
30486 return resultobj;
30487 fail:
30488 return NULL;
30489 }
30490
30491
30492 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30493 PyObject *resultobj;
30494 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30495 int result;
30496 PyObject * obj0 = 0 ;
30497 char *kwnames[] = {
30498 (char *) "self", NULL
30499 };
30500
30501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30503 if (SWIG_arg_fail(1)) SWIG_fail;
30504 {
30505 PyThreadState* __tstate = wxPyBeginAllowThreads();
30506 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30507
30508 wxPyEndAllowThreads(__tstate);
30509 if (PyErr_Occurred()) SWIG_fail;
30510 }
30511 {
30512 resultobj = SWIG_From_int((int)(result));
30513 }
30514 return resultobj;
30515 fail:
30516 return NULL;
30517 }
30518
30519
30520 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30521 PyObject *resultobj;
30522 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30523 int result;
30524 PyObject * obj0 = 0 ;
30525 char *kwnames[] = {
30526 (char *) "self", NULL
30527 };
30528
30529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30531 if (SWIG_arg_fail(1)) SWIG_fail;
30532 {
30533 PyThreadState* __tstate = wxPyBeginAllowThreads();
30534 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30535
30536 wxPyEndAllowThreads(__tstate);
30537 if (PyErr_Occurred()) SWIG_fail;
30538 }
30539 {
30540 resultobj = SWIG_From_int((int)(result));
30541 }
30542 return resultobj;
30543 fail:
30544 return NULL;
30545 }
30546
30547
30548 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30549 PyObject *resultobj;
30550 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30551 int result;
30552 PyObject * obj0 = 0 ;
30553 char *kwnames[] = {
30554 (char *) "self", NULL
30555 };
30556
30557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30559 if (SWIG_arg_fail(1)) SWIG_fail;
30560 {
30561 PyThreadState* __tstate = wxPyBeginAllowThreads();
30562 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30563
30564 wxPyEndAllowThreads(__tstate);
30565 if (PyErr_Occurred()) SWIG_fail;
30566 }
30567 {
30568 resultobj = SWIG_From_int((int)(result));
30569 }
30570 return resultobj;
30571 fail:
30572 return NULL;
30573 }
30574
30575
30576 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30577 PyObject *resultobj;
30578 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30579 bool result;
30580 PyObject * obj0 = 0 ;
30581 char *kwnames[] = {
30582 (char *) "self", NULL
30583 };
30584
30585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30587 if (SWIG_arg_fail(1)) SWIG_fail;
30588 {
30589 PyThreadState* __tstate = wxPyBeginAllowThreads();
30590 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30591
30592 wxPyEndAllowThreads(__tstate);
30593 if (PyErr_Occurred()) SWIG_fail;
30594 }
30595 {
30596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30597 }
30598 return resultobj;
30599 fail:
30600 return NULL;
30601 }
30602
30603
30604 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30605 PyObject *resultobj;
30606 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30607 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30608 bool result;
30609 PyObject * obj0 = 0 ;
30610 PyObject * obj1 = 0 ;
30611 char *kwnames[] = {
30612 (char *) "self",(char *) "other", NULL
30613 };
30614
30615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30617 if (SWIG_arg_fail(1)) SWIG_fail;
30618 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30619 if (SWIG_arg_fail(2)) SWIG_fail;
30620 {
30621 PyThreadState* __tstate = wxPyBeginAllowThreads();
30622 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30623
30624 wxPyEndAllowThreads(__tstate);
30625 if (PyErr_Occurred()) SWIG_fail;
30626 }
30627 {
30628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30629 }
30630 return resultobj;
30631 fail:
30632 return NULL;
30633 }
30634
30635
30636 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30637 PyObject *resultobj;
30638 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30639 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30640 bool result;
30641 PyObject * obj0 = 0 ;
30642 PyObject * obj1 = 0 ;
30643 char *kwnames[] = {
30644 (char *) "self",(char *) "other", NULL
30645 };
30646
30647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30649 if (SWIG_arg_fail(1)) SWIG_fail;
30650 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30651 if (SWIG_arg_fail(2)) SWIG_fail;
30652 {
30653 PyThreadState* __tstate = wxPyBeginAllowThreads();
30654 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30655
30656 wxPyEndAllowThreads(__tstate);
30657 if (PyErr_Occurred()) SWIG_fail;
30658 }
30659 {
30660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30661 }
30662 return resultobj;
30663 fail:
30664 return NULL;
30665 }
30666
30667
30668 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30669 PyObject *resultobj;
30670 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30671 int arg2 ;
30672 PyObject * obj0 = 0 ;
30673 PyObject * obj1 = 0 ;
30674 char *kwnames[] = {
30675 (char *) "self",(char *) "w", NULL
30676 };
30677
30678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30680 if (SWIG_arg_fail(1)) SWIG_fail;
30681 {
30682 arg2 = (int)(SWIG_As_int(obj1));
30683 if (SWIG_arg_fail(2)) SWIG_fail;
30684 }
30685 if (arg1) (arg1)->w = arg2;
30686
30687 Py_INCREF(Py_None); resultobj = Py_None;
30688 return resultobj;
30689 fail:
30690 return NULL;
30691 }
30692
30693
30694 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30695 PyObject *resultobj;
30696 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30697 int result;
30698 PyObject * obj0 = 0 ;
30699 char *kwnames[] = {
30700 (char *) "self", NULL
30701 };
30702
30703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30705 if (SWIG_arg_fail(1)) SWIG_fail;
30706 result = (int) ((arg1)->w);
30707
30708 {
30709 resultobj = SWIG_From_int((int)(result));
30710 }
30711 return resultobj;
30712 fail:
30713 return NULL;
30714 }
30715
30716
30717 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30718 PyObject *resultobj;
30719 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30720 int arg2 ;
30721 PyObject * obj0 = 0 ;
30722 PyObject * obj1 = 0 ;
30723 char *kwnames[] = {
30724 (char *) "self",(char *) "h", NULL
30725 };
30726
30727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30729 if (SWIG_arg_fail(1)) SWIG_fail;
30730 {
30731 arg2 = (int)(SWIG_As_int(obj1));
30732 if (SWIG_arg_fail(2)) SWIG_fail;
30733 }
30734 if (arg1) (arg1)->h = arg2;
30735
30736 Py_INCREF(Py_None); resultobj = Py_None;
30737 return resultobj;
30738 fail:
30739 return NULL;
30740 }
30741
30742
30743 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30744 PyObject *resultobj;
30745 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30746 int result;
30747 PyObject * obj0 = 0 ;
30748 char *kwnames[] = {
30749 (char *) "self", NULL
30750 };
30751
30752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30754 if (SWIG_arg_fail(1)) SWIG_fail;
30755 result = (int) ((arg1)->h);
30756
30757 {
30758 resultobj = SWIG_From_int((int)(result));
30759 }
30760 return resultobj;
30761 fail:
30762 return NULL;
30763 }
30764
30765
30766 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30767 PyObject *resultobj;
30768 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30769 int arg2 ;
30770 PyObject * obj0 = 0 ;
30771 PyObject * obj1 = 0 ;
30772 char *kwnames[] = {
30773 (char *) "self",(char *) "bpp", NULL
30774 };
30775
30776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30778 if (SWIG_arg_fail(1)) SWIG_fail;
30779 {
30780 arg2 = (int)(SWIG_As_int(obj1));
30781 if (SWIG_arg_fail(2)) SWIG_fail;
30782 }
30783 if (arg1) (arg1)->bpp = arg2;
30784
30785 Py_INCREF(Py_None); resultobj = Py_None;
30786 return resultobj;
30787 fail:
30788 return NULL;
30789 }
30790
30791
30792 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30793 PyObject *resultobj;
30794 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30795 int result;
30796 PyObject * obj0 = 0 ;
30797 char *kwnames[] = {
30798 (char *) "self", NULL
30799 };
30800
30801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30803 if (SWIG_arg_fail(1)) SWIG_fail;
30804 result = (int) ((arg1)->bpp);
30805
30806 {
30807 resultobj = SWIG_From_int((int)(result));
30808 }
30809 return resultobj;
30810 fail:
30811 return NULL;
30812 }
30813
30814
30815 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30816 PyObject *resultobj;
30817 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30818 int arg2 ;
30819 PyObject * obj0 = 0 ;
30820 PyObject * obj1 = 0 ;
30821 char *kwnames[] = {
30822 (char *) "self",(char *) "refresh", NULL
30823 };
30824
30825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30827 if (SWIG_arg_fail(1)) SWIG_fail;
30828 {
30829 arg2 = (int)(SWIG_As_int(obj1));
30830 if (SWIG_arg_fail(2)) SWIG_fail;
30831 }
30832 if (arg1) (arg1)->refresh = arg2;
30833
30834 Py_INCREF(Py_None); resultobj = Py_None;
30835 return resultobj;
30836 fail:
30837 return NULL;
30838 }
30839
30840
30841 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30842 PyObject *resultobj;
30843 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30844 int result;
30845 PyObject * obj0 = 0 ;
30846 char *kwnames[] = {
30847 (char *) "self", NULL
30848 };
30849
30850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30852 if (SWIG_arg_fail(1)) SWIG_fail;
30853 result = (int) ((arg1)->refresh);
30854
30855 {
30856 resultobj = SWIG_From_int((int)(result));
30857 }
30858 return resultobj;
30859 fail:
30860 return NULL;
30861 }
30862
30863
30864 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30865 PyObject *obj;
30866 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30867 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30868 Py_INCREF(obj);
30869 return Py_BuildValue((char *)"");
30870 }
30871 static int _wrap_DefaultVideoMode_set(PyObject *) {
30872 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30873 return 1;
30874 }
30875
30876
30877 static PyObject *_wrap_DefaultVideoMode_get(void) {
30878 PyObject *pyobj;
30879
30880 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30881 return pyobj;
30882 }
30883
30884
30885 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30886 PyObject *resultobj;
30887 size_t arg1 = (size_t) 0 ;
30888 wxDisplay *result;
30889 PyObject * obj0 = 0 ;
30890 char *kwnames[] = {
30891 (char *) "index", NULL
30892 };
30893
30894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30895 if (obj0) {
30896 {
30897 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30898 if (SWIG_arg_fail(1)) SWIG_fail;
30899 }
30900 }
30901 {
30902 PyThreadState* __tstate = wxPyBeginAllowThreads();
30903 result = (wxDisplay *)new wxDisplay(arg1);
30904
30905 wxPyEndAllowThreads(__tstate);
30906 if (PyErr_Occurred()) SWIG_fail;
30907 }
30908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30909 return resultobj;
30910 fail:
30911 return NULL;
30912 }
30913
30914
30915 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30916 PyObject *resultobj;
30917 wxDisplay *arg1 = (wxDisplay *) 0 ;
30918 PyObject * obj0 = 0 ;
30919 char *kwnames[] = {
30920 (char *) "self", NULL
30921 };
30922
30923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30925 if (SWIG_arg_fail(1)) SWIG_fail;
30926 {
30927 PyThreadState* __tstate = wxPyBeginAllowThreads();
30928 delete arg1;
30929
30930 wxPyEndAllowThreads(__tstate);
30931 if (PyErr_Occurred()) SWIG_fail;
30932 }
30933 Py_INCREF(Py_None); resultobj = Py_None;
30934 return resultobj;
30935 fail:
30936 return NULL;
30937 }
30938
30939
30940 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30941 PyObject *resultobj;
30942 size_t result;
30943 char *kwnames[] = {
30944 NULL
30945 };
30946
30947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30948 {
30949 PyThreadState* __tstate = wxPyBeginAllowThreads();
30950 result = (size_t)wxDisplay::GetCount();
30951
30952 wxPyEndAllowThreads(__tstate);
30953 if (PyErr_Occurred()) SWIG_fail;
30954 }
30955 {
30956 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30957 }
30958 return resultobj;
30959 fail:
30960 return NULL;
30961 }
30962
30963
30964 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30965 PyObject *resultobj;
30966 wxPoint *arg1 = 0 ;
30967 int result;
30968 wxPoint temp1 ;
30969 PyObject * obj0 = 0 ;
30970 char *kwnames[] = {
30971 (char *) "pt", NULL
30972 };
30973
30974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30975 {
30976 arg1 = &temp1;
30977 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30978 }
30979 {
30980 PyThreadState* __tstate = wxPyBeginAllowThreads();
30981 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30982
30983 wxPyEndAllowThreads(__tstate);
30984 if (PyErr_Occurred()) SWIG_fail;
30985 }
30986 {
30987 resultobj = SWIG_From_int((int)(result));
30988 }
30989 return resultobj;
30990 fail:
30991 return NULL;
30992 }
30993
30994
30995 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30996 PyObject *resultobj;
30997 wxWindow *arg1 = (wxWindow *) 0 ;
30998 int result;
30999 PyObject * obj0 = 0 ;
31000 char *kwnames[] = {
31001 (char *) "window", NULL
31002 };
31003
31004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
31005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31006 if (SWIG_arg_fail(1)) SWIG_fail;
31007 {
31008 PyThreadState* __tstate = wxPyBeginAllowThreads();
31009 result = (int)Display_GetFromWindow(arg1);
31010
31011 wxPyEndAllowThreads(__tstate);
31012 if (PyErr_Occurred()) SWIG_fail;
31013 }
31014 {
31015 resultobj = SWIG_From_int((int)(result));
31016 }
31017 return resultobj;
31018 fail:
31019 return NULL;
31020 }
31021
31022
31023 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
31024 PyObject *resultobj;
31025 wxDisplay *arg1 = (wxDisplay *) 0 ;
31026 bool result;
31027 PyObject * obj0 = 0 ;
31028 char *kwnames[] = {
31029 (char *) "self", NULL
31030 };
31031
31032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
31033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31034 if (SWIG_arg_fail(1)) SWIG_fail;
31035 {
31036 PyThreadState* __tstate = wxPyBeginAllowThreads();
31037 result = (bool)((wxDisplay const *)arg1)->IsOk();
31038
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 {
31043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31044 }
31045 return resultobj;
31046 fail:
31047 return NULL;
31048 }
31049
31050
31051 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
31052 PyObject *resultobj;
31053 wxDisplay *arg1 = (wxDisplay *) 0 ;
31054 wxRect result;
31055 PyObject * obj0 = 0 ;
31056 char *kwnames[] = {
31057 (char *) "self", NULL
31058 };
31059
31060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
31061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31062 if (SWIG_arg_fail(1)) SWIG_fail;
31063 {
31064 PyThreadState* __tstate = wxPyBeginAllowThreads();
31065 result = ((wxDisplay const *)arg1)->GetGeometry();
31066
31067 wxPyEndAllowThreads(__tstate);
31068 if (PyErr_Occurred()) SWIG_fail;
31069 }
31070 {
31071 wxRect * resultptr;
31072 resultptr = new wxRect((wxRect &)(result));
31073 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
31074 }
31075 return resultobj;
31076 fail:
31077 return NULL;
31078 }
31079
31080
31081 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
31082 PyObject *resultobj;
31083 wxDisplay *arg1 = (wxDisplay *) 0 ;
31084 wxString result;
31085 PyObject * obj0 = 0 ;
31086 char *kwnames[] = {
31087 (char *) "self", NULL
31088 };
31089
31090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
31091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31092 if (SWIG_arg_fail(1)) SWIG_fail;
31093 {
31094 PyThreadState* __tstate = wxPyBeginAllowThreads();
31095 result = ((wxDisplay const *)arg1)->GetName();
31096
31097 wxPyEndAllowThreads(__tstate);
31098 if (PyErr_Occurred()) SWIG_fail;
31099 }
31100 {
31101 #if wxUSE_UNICODE
31102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31103 #else
31104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31105 #endif
31106 }
31107 return resultobj;
31108 fail:
31109 return NULL;
31110 }
31111
31112
31113 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
31114 PyObject *resultobj;
31115 wxDisplay *arg1 = (wxDisplay *) 0 ;
31116 bool result;
31117 PyObject * obj0 = 0 ;
31118 char *kwnames[] = {
31119 (char *) "self", NULL
31120 };
31121
31122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
31123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31124 if (SWIG_arg_fail(1)) SWIG_fail;
31125 {
31126 PyThreadState* __tstate = wxPyBeginAllowThreads();
31127 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
31128
31129 wxPyEndAllowThreads(__tstate);
31130 if (PyErr_Occurred()) SWIG_fail;
31131 }
31132 {
31133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31134 }
31135 return resultobj;
31136 fail:
31137 return NULL;
31138 }
31139
31140
31141 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31142 PyObject *resultobj;
31143 wxDisplay *arg1 = (wxDisplay *) 0 ;
31144 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31145 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31146 PyObject *result;
31147 PyObject * obj0 = 0 ;
31148 PyObject * obj1 = 0 ;
31149 char *kwnames[] = {
31150 (char *) "self",(char *) "mode", NULL
31151 };
31152
31153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31155 if (SWIG_arg_fail(1)) SWIG_fail;
31156 if (obj1) {
31157 {
31158 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31159 if (SWIG_arg_fail(2)) SWIG_fail;
31160 if (arg2 == NULL) {
31161 SWIG_null_ref("wxVideoMode");
31162 }
31163 if (SWIG_arg_fail(2)) SWIG_fail;
31164 }
31165 }
31166 {
31167 PyThreadState* __tstate = wxPyBeginAllowThreads();
31168 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31169
31170 wxPyEndAllowThreads(__tstate);
31171 if (PyErr_Occurred()) SWIG_fail;
31172 }
31173 resultobj = result;
31174 return resultobj;
31175 fail:
31176 return NULL;
31177 }
31178
31179
31180 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31181 PyObject *resultobj;
31182 wxDisplay *arg1 = (wxDisplay *) 0 ;
31183 wxVideoMode result;
31184 PyObject * obj0 = 0 ;
31185 char *kwnames[] = {
31186 (char *) "self", NULL
31187 };
31188
31189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31191 if (SWIG_arg_fail(1)) SWIG_fail;
31192 {
31193 PyThreadState* __tstate = wxPyBeginAllowThreads();
31194 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31195
31196 wxPyEndAllowThreads(__tstate);
31197 if (PyErr_Occurred()) SWIG_fail;
31198 }
31199 {
31200 wxVideoMode * resultptr;
31201 resultptr = new wxVideoMode((wxVideoMode &)(result));
31202 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31203 }
31204 return resultobj;
31205 fail:
31206 return NULL;
31207 }
31208
31209
31210 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31211 PyObject *resultobj;
31212 wxDisplay *arg1 = (wxDisplay *) 0 ;
31213 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31214 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31215 bool result;
31216 PyObject * obj0 = 0 ;
31217 PyObject * obj1 = 0 ;
31218 char *kwnames[] = {
31219 (char *) "self",(char *) "mode", NULL
31220 };
31221
31222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31224 if (SWIG_arg_fail(1)) SWIG_fail;
31225 if (obj1) {
31226 {
31227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31228 if (SWIG_arg_fail(2)) SWIG_fail;
31229 if (arg2 == NULL) {
31230 SWIG_null_ref("wxVideoMode");
31231 }
31232 if (SWIG_arg_fail(2)) SWIG_fail;
31233 }
31234 }
31235 {
31236 PyThreadState* __tstate = wxPyBeginAllowThreads();
31237 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31238
31239 wxPyEndAllowThreads(__tstate);
31240 if (PyErr_Occurred()) SWIG_fail;
31241 }
31242 {
31243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31244 }
31245 return resultobj;
31246 fail:
31247 return NULL;
31248 }
31249
31250
31251 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31252 PyObject *resultobj;
31253 wxDisplay *arg1 = (wxDisplay *) 0 ;
31254 PyObject * obj0 = 0 ;
31255 char *kwnames[] = {
31256 (char *) "self", NULL
31257 };
31258
31259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31261 if (SWIG_arg_fail(1)) SWIG_fail;
31262 {
31263 PyThreadState* __tstate = wxPyBeginAllowThreads();
31264 (arg1)->ResetMode();
31265
31266 wxPyEndAllowThreads(__tstate);
31267 if (PyErr_Occurred()) SWIG_fail;
31268 }
31269 Py_INCREF(Py_None); resultobj = Py_None;
31270 return resultobj;
31271 fail:
31272 return NULL;
31273 }
31274
31275
31276 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31277 PyObject *obj;
31278 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31279 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31280 Py_INCREF(obj);
31281 return Py_BuildValue((char *)"");
31282 }
31283 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31284 PyObject *resultobj;
31285 wxStandardPaths *result;
31286 char *kwnames[] = {
31287 NULL
31288 };
31289
31290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31291 {
31292 PyThreadState* __tstate = wxPyBeginAllowThreads();
31293 result = (wxStandardPaths *)StandardPaths_Get();
31294
31295 wxPyEndAllowThreads(__tstate);
31296 if (PyErr_Occurred()) SWIG_fail;
31297 }
31298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31299 return resultobj;
31300 fail:
31301 return NULL;
31302 }
31303
31304
31305 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31306 PyObject *resultobj;
31307 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31308 wxString result;
31309 PyObject * obj0 = 0 ;
31310 char *kwnames[] = {
31311 (char *) "self", NULL
31312 };
31313
31314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31316 if (SWIG_arg_fail(1)) SWIG_fail;
31317 {
31318 PyThreadState* __tstate = wxPyBeginAllowThreads();
31319 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31320
31321 wxPyEndAllowThreads(__tstate);
31322 if (PyErr_Occurred()) SWIG_fail;
31323 }
31324 {
31325 #if wxUSE_UNICODE
31326 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31327 #else
31328 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31329 #endif
31330 }
31331 return resultobj;
31332 fail:
31333 return NULL;
31334 }
31335
31336
31337 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31338 PyObject *resultobj;
31339 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31340 wxString result;
31341 PyObject * obj0 = 0 ;
31342 char *kwnames[] = {
31343 (char *) "self", NULL
31344 };
31345
31346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31348 if (SWIG_arg_fail(1)) SWIG_fail;
31349 {
31350 PyThreadState* __tstate = wxPyBeginAllowThreads();
31351 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31352
31353 wxPyEndAllowThreads(__tstate);
31354 if (PyErr_Occurred()) SWIG_fail;
31355 }
31356 {
31357 #if wxUSE_UNICODE
31358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31359 #else
31360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31361 #endif
31362 }
31363 return resultobj;
31364 fail:
31365 return NULL;
31366 }
31367
31368
31369 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31370 PyObject *resultobj;
31371 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31372 wxString result;
31373 PyObject * obj0 = 0 ;
31374 char *kwnames[] = {
31375 (char *) "self", NULL
31376 };
31377
31378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31380 if (SWIG_arg_fail(1)) SWIG_fail;
31381 {
31382 PyThreadState* __tstate = wxPyBeginAllowThreads();
31383 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31384
31385 wxPyEndAllowThreads(__tstate);
31386 if (PyErr_Occurred()) SWIG_fail;
31387 }
31388 {
31389 #if wxUSE_UNICODE
31390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31391 #else
31392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31393 #endif
31394 }
31395 return resultobj;
31396 fail:
31397 return NULL;
31398 }
31399
31400
31401 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31402 PyObject *resultobj;
31403 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31404 wxString result;
31405 PyObject * obj0 = 0 ;
31406 char *kwnames[] = {
31407 (char *) "self", NULL
31408 };
31409
31410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31412 if (SWIG_arg_fail(1)) SWIG_fail;
31413 {
31414 PyThreadState* __tstate = wxPyBeginAllowThreads();
31415 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31416
31417 wxPyEndAllowThreads(__tstate);
31418 if (PyErr_Occurred()) SWIG_fail;
31419 }
31420 {
31421 #if wxUSE_UNICODE
31422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31423 #else
31424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31425 #endif
31426 }
31427 return resultobj;
31428 fail:
31429 return NULL;
31430 }
31431
31432
31433 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31434 PyObject *resultobj;
31435 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31436 wxString result;
31437 PyObject * obj0 = 0 ;
31438 char *kwnames[] = {
31439 (char *) "self", NULL
31440 };
31441
31442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31444 if (SWIG_arg_fail(1)) SWIG_fail;
31445 {
31446 PyThreadState* __tstate = wxPyBeginAllowThreads();
31447 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31448
31449 wxPyEndAllowThreads(__tstate);
31450 if (PyErr_Occurred()) SWIG_fail;
31451 }
31452 {
31453 #if wxUSE_UNICODE
31454 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31455 #else
31456 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31457 #endif
31458 }
31459 return resultobj;
31460 fail:
31461 return NULL;
31462 }
31463
31464
31465 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31466 PyObject *resultobj;
31467 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31468 wxString result;
31469 PyObject * obj0 = 0 ;
31470 char *kwnames[] = {
31471 (char *) "self", NULL
31472 };
31473
31474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31476 if (SWIG_arg_fail(1)) SWIG_fail;
31477 {
31478 PyThreadState* __tstate = wxPyBeginAllowThreads();
31479 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31480
31481 wxPyEndAllowThreads(__tstate);
31482 if (PyErr_Occurred()) SWIG_fail;
31483 }
31484 {
31485 #if wxUSE_UNICODE
31486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31487 #else
31488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31489 #endif
31490 }
31491 return resultobj;
31492 fail:
31493 return NULL;
31494 }
31495
31496
31497 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31498 PyObject *resultobj;
31499 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31500 wxString result;
31501 PyObject * obj0 = 0 ;
31502 char *kwnames[] = {
31503 (char *) "self", NULL
31504 };
31505
31506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31508 if (SWIG_arg_fail(1)) SWIG_fail;
31509 {
31510 PyThreadState* __tstate = wxPyBeginAllowThreads();
31511 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31512
31513 wxPyEndAllowThreads(__tstate);
31514 if (PyErr_Occurred()) SWIG_fail;
31515 }
31516 {
31517 #if wxUSE_UNICODE
31518 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31519 #else
31520 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31521 #endif
31522 }
31523 return resultobj;
31524 fail:
31525 return NULL;
31526 }
31527
31528
31529 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31530 PyObject *resultobj;
31531 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31532 wxString *arg2 = 0 ;
31533 bool temp2 = false ;
31534 PyObject * obj0 = 0 ;
31535 PyObject * obj1 = 0 ;
31536 char *kwnames[] = {
31537 (char *) "self",(char *) "prefix", NULL
31538 };
31539
31540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31542 if (SWIG_arg_fail(1)) SWIG_fail;
31543 {
31544 arg2 = wxString_in_helper(obj1);
31545 if (arg2 == NULL) SWIG_fail;
31546 temp2 = true;
31547 }
31548 {
31549 PyThreadState* __tstate = wxPyBeginAllowThreads();
31550 (arg1)->SetInstallPrefix((wxString const &)*arg2);
31551
31552 wxPyEndAllowThreads(__tstate);
31553 if (PyErr_Occurred()) SWIG_fail;
31554 }
31555 Py_INCREF(Py_None); resultobj = Py_None;
31556 {
31557 if (temp2)
31558 delete arg2;
31559 }
31560 return resultobj;
31561 fail:
31562 {
31563 if (temp2)
31564 delete arg2;
31565 }
31566 return NULL;
31567 }
31568
31569
31570 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31571 PyObject *resultobj;
31572 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31573 wxString result;
31574 PyObject * obj0 = 0 ;
31575 char *kwnames[] = {
31576 (char *) "self", NULL
31577 };
31578
31579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31581 if (SWIG_arg_fail(1)) SWIG_fail;
31582 {
31583 PyThreadState* __tstate = wxPyBeginAllowThreads();
31584 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
31585
31586 wxPyEndAllowThreads(__tstate);
31587 if (PyErr_Occurred()) SWIG_fail;
31588 }
31589 {
31590 #if wxUSE_UNICODE
31591 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31592 #else
31593 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31594 #endif
31595 }
31596 return resultobj;
31597 fail:
31598 return NULL;
31599 }
31600
31601
31602 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31603 PyObject *obj;
31604 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31605 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31606 Py_INCREF(obj);
31607 return Py_BuildValue((char *)"");
31608 }
31609 static PyMethodDef SwigMethods[] = {
31610 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31617 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31625 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"GetXDisplay", (PyCFunction) _wrap_GetXDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31691 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31699 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31717 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31720 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31723 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31726 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31732 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31746 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31752 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31758 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31761 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31775 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31778 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31779 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31782 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31809 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31811 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31813 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31815 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31822 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31828 { (char *)"new_LogBuffer", (PyCFunction) _wrap_new_LogBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"LogBuffer_GetBuffer", (PyCFunction) _wrap_LogBuffer_GetBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"LogBuffer_Flush", (PyCFunction) _wrap_LogBuffer_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
31832 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31846 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31850 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31853 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31870 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31878 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31925 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31943 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31953 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31969 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31985 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31999 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
32009 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
32052 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
32055 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
32058 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
32062 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32155 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32156 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32157 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32158 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32175 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32201 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32215 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32220 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32225 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32231 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32236 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32239 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32243 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32244 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32245 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32247 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32249 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32250 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32251 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32252 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32253 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32254 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32256 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32257 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32258 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32259 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32260 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32261 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32262 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32263 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32264 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32265 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32267 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32268 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32271 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32272 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32273 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32274 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32275 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32276 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32277 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32278 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32279 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32280 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32281 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32282 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32283 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32284 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32285 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32286 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32287 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32288 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32289 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32290 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32291 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32292 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32293 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32294 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32295 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32296 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32297 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32298 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32299 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32300 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32301 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32302 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32303 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32304 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32305 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32306 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32307 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32308 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32309 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32310 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32311 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32312 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32313 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32314 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32315 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32316 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32317 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32318 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32319 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32320 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32321 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32322 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32323 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32324 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32325 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32326 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32327 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32328 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32329 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32330 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32331 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32332 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32333 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32334 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32335 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32336 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32337 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32338 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32339 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32340 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32341 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32342 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32343 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32344 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32345 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32346 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32347 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32348 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32349 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32350 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32351 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32352 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32353 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32354 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32355 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32356 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32357 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32358 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32359 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32360 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32361 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32362 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32363 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32364 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32365 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32366 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32367 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32368 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32369 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32370 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32371 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32372 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32373 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32374 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32375 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32376 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32377 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32378 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32379 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32380 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32381 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32382 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32383 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32384 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32385 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32386 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32387 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32388 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32389 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32390 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32391 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32392 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32393 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32394 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32395 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32396 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32397 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32398 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32399 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32400 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32401 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32402 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32403 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32404 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32405 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32406 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32407 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32408 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32409 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32410 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32411 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32412 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32413 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32414 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32415 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32416 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32417 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32418 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32419 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32420 { NULL, NULL, 0, NULL }
32421 };
32422
32423
32424 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32425
32426 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32427 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32428 }
32429 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32430 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32431 }
32432 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32433 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32434 }
32435 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32436 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32437 }
32438 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32439 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32440 }
32441 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32442 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32443 }
32444 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32445 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32446 }
32447 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32448 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32449 }
32450 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32451 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32452 }
32453 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32454 return (void *)((wxEvent *) ((wxPyEvent *) x));
32455 }
32456 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32457 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32458 }
32459 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32460 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32461 }
32462 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32463 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32464 }
32465 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32466 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32467 }
32468 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32469 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32470 }
32471 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32472 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32473 }
32474 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32475 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32476 }
32477 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32478 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32479 }
32480 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32481 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32482 }
32483 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32484 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32485 }
32486 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32487 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32488 }
32489 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32490 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32491 }
32492 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32493 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32494 }
32495 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32496 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32497 }
32498 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32499 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32500 }
32501 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32502 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32503 }
32504 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32505 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32506 }
32507 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32508 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32509 }
32510 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32511 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32512 }
32513 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32514 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32515 }
32516 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32517 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32518 }
32519 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32520 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32521 }
32522 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32523 return (void *)((wxEvent *) ((wxShowEvent *) x));
32524 }
32525 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32526 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32527 }
32528 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32529 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32530 }
32531 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32532 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32533 }
32534 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32535 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32536 }
32537 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32538 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32539 }
32540 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32541 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32542 }
32543 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32544 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32545 }
32546 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32547 return (void *)((wxConfigBase *) ((wxConfig *) x));
32548 }
32549 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32550 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32551 }
32552 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32553 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32554 }
32555 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32556 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32557 }
32558 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32559 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32560 }
32561 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32562 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32563 }
32564 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32565 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32566 }
32567 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32568 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32569 }
32570 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32571 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32572 }
32573 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32574 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32575 }
32576 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32577 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32578 }
32579 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32580 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32581 }
32582 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32583 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32584 }
32585 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32586 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32587 }
32588 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32589 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32590 }
32591 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32592 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32593 }
32594 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32595 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32596 }
32597 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32598 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32599 }
32600 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32601 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32602 }
32603 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32604 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32605 }
32606 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32607 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32608 }
32609 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32610 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32611 }
32612 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32613 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32614 }
32615 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32616 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32617 }
32618 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32619 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32620 }
32621 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32622 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32623 }
32624 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32625 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32626 }
32627 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32628 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32629 }
32630 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32631 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32632 }
32633 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32634 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32635 }
32636 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32637 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32638 }
32639 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32640 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32641 }
32642 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32643 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32644 }
32645 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32646 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32647 }
32648 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32649 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32650 }
32651 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32652 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32653 }
32654 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32655 return (void *)((wxObject *) ((wxSizerItem *) x));
32656 }
32657 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32658 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32659 }
32660 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32661 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32662 }
32663 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32664 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32665 }
32666 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32667 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32668 }
32669 static void *_p_wxSizerTo_p_wxObject(void *x) {
32670 return (void *)((wxObject *) ((wxSizer *) x));
32671 }
32672 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32673 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32674 }
32675 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32676 return (void *)((wxObject *) ((wxFileHistory *) x));
32677 }
32678 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32679 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32680 }
32681 static void *_p_wxEventTo_p_wxObject(void *x) {
32682 return (void *)((wxObject *) ((wxEvent *) x));
32683 }
32684 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32685 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32686 }
32687 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32688 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32689 }
32690 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32691 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32692 }
32693 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32694 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32695 }
32696 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32697 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32698 }
32699 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32700 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32701 }
32702 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32703 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32704 }
32705 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32706 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32707 }
32708 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32709 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32710 }
32711 static void *_p_wxControlTo_p_wxObject(void *x) {
32712 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32713 }
32714 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32715 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32716 }
32717 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32718 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32719 }
32720 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32721 return (void *)((wxObject *) ((wxFSFile *) x));
32722 }
32723 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32724 return (void *)((wxObject *) ((wxClipboard *) x));
32725 }
32726 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32727 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32728 }
32729 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32730 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32731 }
32732 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32733 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32734 }
32735 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32736 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32737 }
32738 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32739 return (void *)((wxObject *) ((wxToolTip *) x));
32740 }
32741 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32742 return (void *)((wxObject *) ((wxMenuItem *) x));
32743 }
32744 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32745 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32746 }
32747 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32748 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32749 }
32750 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32751 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32752 }
32753 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32754 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32755 }
32756 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32757 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32758 }
32759 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32760 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32761 }
32762 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32763 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32764 }
32765 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32766 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32767 }
32768 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32769 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32770 }
32771 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32772 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32773 }
32774 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32775 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32776 }
32777 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32778 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32779 }
32780 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32781 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32782 }
32783 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32784 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32785 }
32786 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32787 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32788 }
32789 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32790 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32791 }
32792 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32793 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32794 }
32795 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32796 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32797 }
32798 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32799 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32800 }
32801 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32802 return (void *)((wxObject *) ((wxImageHandler *) x));
32803 }
32804 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32805 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32806 }
32807 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32808 return (void *)((wxObject *) ((wxEvtHandler *) x));
32809 }
32810 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32811 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32812 }
32813 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32814 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32815 }
32816 static void *_p_wxImageTo_p_wxObject(void *x) {
32817 return (void *)((wxObject *) ((wxImage *) x));
32818 }
32819 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32820 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32821 }
32822 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32823 return (void *)((wxObject *) ((wxSystemOptions *) x));
32824 }
32825 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32826 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32827 }
32828 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32829 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32830 }
32831 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32832 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32833 }
32834 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32835 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32836 }
32837 static void *_p_wxWindowTo_p_wxObject(void *x) {
32838 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32839 }
32840 static void *_p_wxMenuTo_p_wxObject(void *x) {
32841 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32842 }
32843 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32844 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32845 }
32846 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32847 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32848 }
32849 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32850 return (void *)((wxObject *) ((wxFileSystem *) x));
32851 }
32852 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32853 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32854 }
32855 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32856 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32857 }
32858 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32859 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32860 }
32861 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32862 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32863 }
32864 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32865 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32866 }
32867 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32868 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32869 }
32870 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32871 return (void *)((wxObject *) ((wxBusyInfo *) x));
32872 }
32873 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32874 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32875 }
32876 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32877 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32878 }
32879 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32880 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32881 }
32882 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32883 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32884 }
32885 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32886 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32887 }
32888 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32889 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32890 }
32891 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32892 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32893 }
32894 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32895 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32896 }
32897 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32898 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32899 }
32900 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32901 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32902 }
32903 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
32904 return (void *)((wxLog *) ((wxLogBuffer *) x));
32905 }
32906 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32907 return (void *)((wxLog *) ((wxLogStderr *) x));
32908 }
32909 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32910 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32911 }
32912 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32913 return (void *)((wxLog *) ((wxLogWindow *) x));
32914 }
32915 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32916 return (void *)((wxLog *) ((wxLogChain *) x));
32917 }
32918 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32919 return (void *)((wxLog *) ((wxLogGui *) x));
32920 }
32921 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32922 return (void *)((wxLog *) ((wxPyLog *) x));
32923 }
32924 static void *_p_wxControlTo_p_wxWindow(void *x) {
32925 return (void *)((wxWindow *) ((wxControl *) x));
32926 }
32927 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32928 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32929 }
32930 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32931 return (void *)((wxWindow *) ((wxMenuBar *) x));
32932 }
32933 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32934 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32935 }
32936 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32937 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32938 }
32939 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}};
32940 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}};
32941 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}};
32942 static swig_type_info _swigt__p_wxLog[] = {{"_p_wxLog", 0, "wxLog *", 0, 0, 0, 0},{"_p_wxLogBuffer", _p_wxLogBufferTo_p_wxLog, 0, 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}};
32943 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}};
32944 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32945 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}};
32946 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}};
32947 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}};
32948 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}};
32949 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}};
32950 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}};
32951 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}};
32952 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}};
32953 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}};
32954 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}};
32955 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}};
32956 static swig_type_info _swigt__p_void[] = {{"_p_void", 0, "void *", 0, 0, 0, 0},{"_p_void", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32957 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}};
32958 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}};
32959 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}};
32960 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}};
32961 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}};
32962 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}};
32963 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}};
32964 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}};
32965 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}};
32966 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}};
32967 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}};
32968 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}};
32969 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}};
32970 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}};
32971 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}};
32972 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}};
32973 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}};
32974 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}};
32975 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}};
32976 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}};
32977 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}};
32978 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}};
32979 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}};
32980 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}};
32981 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}};
32982 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}};
32983 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}};
32984 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}};
32985 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}};
32986 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}};
32987 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}};
32988 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}};
32989 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}};
32990 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}};
32991 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}};
32992 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}};
32993 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}};
32994 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}};
32995 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}};
32996 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}};
32997 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}};
32998 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}};
32999 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}};
33000 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}};
33001 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}};
33002 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}};
33003 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}};
33004 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}};
33005 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}};
33006 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}};
33007 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}};
33008 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}};
33009 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}};
33010 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileHistory", _p_wxFileHistoryTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClipboard", _p_wxClipboardTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToolTip", _p_wxToolTipTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSystemOptions", _p_wxSystemOptionsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyProcess", _p_wxPyProcessTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBusyInfo", _p_wxBusyInfoTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyTimer", _p_wxPyTimerTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
33011 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}};
33012 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}};
33013 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}};
33014 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}};
33015 static swig_type_info _swigt__p_wxLogBuffer[] = {{"_p_wxLogBuffer", 0, "wxLogBuffer *", 0, 0, 0, 0},{"_p_wxLogBuffer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
33016 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}};
33017 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}};
33018 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}};
33019 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}};
33020 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}};
33021 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}};
33022 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}};
33023 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}};
33024 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}};
33025 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}};
33026 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}};
33027 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}};
33028 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}};
33029 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}};
33030 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}};
33031 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}};
33032 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}};
33033 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}};
33034 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}};
33035 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}};
33036 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}};
33037
33038 static swig_type_info *swig_types_initial[] = {
33039 _swigt__p_wxLogChain,
33040 _swigt__p_wxMutexGuiLocker,
33041 _swigt__p_wxFileHistory,
33042 _swigt__p_wxLog,
33043 _swigt__p_wxMenu,
33044 _swigt__p_wxEvent,
33045 _swigt__p_wxDateTime__TimeZone,
33046 _swigt__p_wxConfigBase,
33047 _swigt__p_wxDisplay,
33048 _swigt__p_wxFileType,
33049 _swigt__p_wxLogGui,
33050 _swigt__p_wxFont,
33051 _swigt__p_wxDataFormat,
33052 _swigt__p_wxTimerEvent,
33053 _swigt__p_wxCaret,
33054 _swigt__ptrdiff_t,
33055 _swigt__std__ptrdiff_t,
33056 _swigt__p_void,
33057 _swigt__p_int,
33058 _swigt__p_wxSize,
33059 _swigt__p_wxClipboard,
33060 _swigt__p_wxStopWatch,
33061 _swigt__p_wxDC,
33062 _swigt__p_wxClipboardLocker,
33063 _swigt__p_wxIcon,
33064 _swigt__p_wxLogStderr,
33065 _swigt__p_wxLogTextCtrl,
33066 _swigt__p_wxTextCtrl,
33067 _swigt__p_wxBusyCursor,
33068 _swigt__p_wxBitmapDataObject,
33069 _swigt__p_wxTextDataObject,
33070 _swigt__p_wxDataObject,
33071 _swigt__p_wxPyTextDataObject,
33072 _swigt__p_wxPyBitmapDataObject,
33073 _swigt__p_wxFileDataObject,
33074 _swigt__p_wxCustomDataObject,
33075 _swigt__p_wxURLDataObject,
33076 _swigt__p_wxMetafileDataObject,
33077 _swigt__p_wxSound,
33078 _swigt__p_wxTimerRunner,
33079 _swigt__p_wxLogWindow,
33080 _swigt__p_wxTimeSpan,
33081 _swigt__p_wxArrayString,
33082 _swigt__p_wxWindowDisabler,
33083 _swigt__p_form_ops_t,
33084 _swigt__p_wxToolTip,
33085 _swigt__p_wxDataObjectComposite,
33086 _swigt__p_wxSystemSettings,
33087 _swigt__p_wxFileConfig,
33088 _swigt__p_wxVideoMode,
33089 _swigt__p_wxDataObjectSimple,
33090 _swigt__p_wxPyDataObjectSimple,
33091 _swigt__p_wxDuplexMode,
33092 _swigt__p_wxEvtHandler,
33093 _swigt__p_wxRect,
33094 _swigt__p_char,
33095 _swigt__p_wxSingleInstanceChecker,
33096 _swigt__p_wxStandardPaths,
33097 _swigt__p_wxFileTypeInfo,
33098 _swigt__p_wxFrame,
33099 _swigt__p_wxTimer,
33100 _swigt__p_wxPaperSize,
33101 _swigt__p_wxMimeTypesManager,
33102 _swigt__p_wxPyArtProvider,
33103 _swigt__p_wxPyTipProvider,
33104 _swigt__p_wxTipProvider,
33105 _swigt__p_wxJoystick,
33106 _swigt__p_wxSystemOptions,
33107 _swigt__p_wxPoint,
33108 _swigt__p_wxJoystickEvent,
33109 _swigt__p_wxCursor,
33110 _swigt__p_wxObject,
33111 _swigt__p_wxOutputStream,
33112 _swigt__p_wxDateTime,
33113 _swigt__p_wxPyDropSource,
33114 _swigt__p_unsigned_long,
33115 _swigt__p_wxLogBuffer,
33116 _swigt__p_wxKillError,
33117 _swigt__p_wxWindow,
33118 _swigt__p_wxString,
33119 _swigt__p_wxPyProcess,
33120 _swigt__p_wxBitmap,
33121 _swigt__unsigned_int,
33122 _swigt__p_unsigned_int,
33123 _swigt__p_wxConfig,
33124 _swigt__p_unsigned_char,
33125 _swigt__p_wxChar,
33126 _swigt__p_wxBusyInfo,
33127 _swigt__p_wxPyDropTarget,
33128 _swigt__p_wxPyTextDropTarget,
33129 _swigt__p_wxPyFileDropTarget,
33130 _swigt__p_wxProcessEvent,
33131 _swigt__p_wxPyLog,
33132 _swigt__p_wxLogNull,
33133 _swigt__p_wxColour,
33134 _swigt__p_wxPyTimer,
33135 _swigt__p_wxConfigPathChanger,
33136 _swigt__p_wxDateSpan,
33137 0
33138 };
33139
33140
33141 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33142
33143 static swig_const_info swig_const_table[] = {
33144 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
33145 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
33146 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
33147 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
33148 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
33149 {0, 0, 0, 0.0, 0, 0}};
33150
33151 #ifdef __cplusplus
33152 }
33153 #endif
33154
33155
33156 #ifdef __cplusplus
33157 extern "C" {
33158 #endif
33159
33160 /* Python-specific SWIG API */
33161 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33162 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33163 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33164
33165 /* -----------------------------------------------------------------------------
33166 * global variable support code.
33167 * ----------------------------------------------------------------------------- */
33168
33169 typedef struct swig_globalvar {
33170 char *name; /* Name of global variable */
33171 PyObject *(*get_attr)(); /* Return the current value */
33172 int (*set_attr)(PyObject *); /* Set the value */
33173 struct swig_globalvar *next;
33174 } swig_globalvar;
33175
33176 typedef struct swig_varlinkobject {
33177 PyObject_HEAD
33178 swig_globalvar *vars;
33179 } swig_varlinkobject;
33180
33181 static PyObject *
33182 swig_varlink_repr(swig_varlinkobject *v) {
33183 v = v;
33184 return PyString_FromString("<Swig global variables>");
33185 }
33186
33187 static int
33188 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33189 swig_globalvar *var;
33190 flags = flags;
33191 fprintf(fp,"Swig global variables { ");
33192 for (var = v->vars; var; var=var->next) {
33193 fprintf(fp,"%s", var->name);
33194 if (var->next) fprintf(fp,", ");
33195 }
33196 fprintf(fp," }\n");
33197 return 0;
33198 }
33199
33200 static PyObject *
33201 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33202 swig_globalvar *var = v->vars;
33203 while (var) {
33204 if (strcmp(var->name,n) == 0) {
33205 return (*var->get_attr)();
33206 }
33207 var = var->next;
33208 }
33209 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33210 return NULL;
33211 }
33212
33213 static int
33214 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33215 swig_globalvar *var = v->vars;
33216 while (var) {
33217 if (strcmp(var->name,n) == 0) {
33218 return (*var->set_attr)(p);
33219 }
33220 var = var->next;
33221 }
33222 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33223 return 1;
33224 }
33225
33226 static PyTypeObject varlinktype = {
33227 PyObject_HEAD_INIT(0)
33228 0, /* Number of items in variable part (ob_size) */
33229 (char *)"swigvarlink", /* Type name (tp_name) */
33230 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33231 0, /* Itemsize (tp_itemsize) */
33232 0, /* Deallocator (tp_dealloc) */
33233 (printfunc) swig_varlink_print, /* Print (tp_print) */
33234 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33235 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33236 0, /* tp_compare */
33237 (reprfunc) swig_varlink_repr, /* tp_repr */
33238 0, /* tp_as_number */
33239 0, /* tp_as_sequence */
33240 0, /* tp_as_mapping */
33241 0, /* tp_hash */
33242 0, /* tp_call */
33243 0, /* tp_str */
33244 0, /* tp_getattro */
33245 0, /* tp_setattro */
33246 0, /* tp_as_buffer */
33247 0, /* tp_flags */
33248 0, /* tp_doc */
33249 #if PY_VERSION_HEX >= 0x02000000
33250 0, /* tp_traverse */
33251 0, /* tp_clear */
33252 #endif
33253 #if PY_VERSION_HEX >= 0x02010000
33254 0, /* tp_richcompare */
33255 0, /* tp_weaklistoffset */
33256 #endif
33257 #if PY_VERSION_HEX >= 0x02020000
33258 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33259 #endif
33260 #if PY_VERSION_HEX >= 0x02030000
33261 0, /* tp_del */
33262 #endif
33263 #ifdef COUNT_ALLOCS
33264 0,0,0,0 /* tp_alloc -> tp_next */
33265 #endif
33266 };
33267
33268 /* Create a variable linking object for use later */
33269 static PyObject *
33270 SWIG_Python_newvarlink(void) {
33271 swig_varlinkobject *result = 0;
33272 result = PyMem_NEW(swig_varlinkobject,1);
33273 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33274 result->ob_type = &varlinktype;
33275 result->vars = 0;
33276 result->ob_refcnt = 0;
33277 Py_XINCREF((PyObject *) result);
33278 return ((PyObject*) result);
33279 }
33280
33281 static void
33282 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33283 swig_varlinkobject *v;
33284 swig_globalvar *gv;
33285 v= (swig_varlinkobject *) p;
33286 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33287 gv->name = (char *) malloc(strlen(name)+1);
33288 strcpy(gv->name,name);
33289 gv->get_attr = get_attr;
33290 gv->set_attr = set_attr;
33291 gv->next = v->vars;
33292 v->vars = gv;
33293 }
33294
33295 /* -----------------------------------------------------------------------------
33296 * constants/methods manipulation
33297 * ----------------------------------------------------------------------------- */
33298
33299 /* Install Constants */
33300 static void
33301 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33302 PyObject *obj = 0;
33303 size_t i;
33304 for (i = 0; constants[i].type; i++) {
33305 switch(constants[i].type) {
33306 case SWIG_PY_INT:
33307 obj = PyInt_FromLong(constants[i].lvalue);
33308 break;
33309 case SWIG_PY_FLOAT:
33310 obj = PyFloat_FromDouble(constants[i].dvalue);
33311 break;
33312 case SWIG_PY_STRING:
33313 if (constants[i].pvalue) {
33314 obj = PyString_FromString((char *) constants[i].pvalue);
33315 } else {
33316 Py_INCREF(Py_None);
33317 obj = Py_None;
33318 }
33319 break;
33320 case SWIG_PY_POINTER:
33321 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33322 break;
33323 case SWIG_PY_BINARY:
33324 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33325 break;
33326 default:
33327 obj = 0;
33328 break;
33329 }
33330 if (obj) {
33331 PyDict_SetItemString(d,constants[i].name,obj);
33332 Py_DECREF(obj);
33333 }
33334 }
33335 }
33336
33337 /* -----------------------------------------------------------------------------*/
33338 /* Fix SwigMethods to carry the callback ptrs when needed */
33339 /* -----------------------------------------------------------------------------*/
33340
33341 static void
33342 SWIG_Python_FixMethods(PyMethodDef *methods,
33343 swig_const_info *const_table,
33344 swig_type_info **types,
33345 swig_type_info **types_initial) {
33346 size_t i;
33347 for (i = 0; methods[i].ml_name; ++i) {
33348 char *c = methods[i].ml_doc;
33349 if (c && (c = strstr(c, "swig_ptr: "))) {
33350 int j;
33351 swig_const_info *ci = 0;
33352 char *name = c + 10;
33353 for (j = 0; const_table[j].type; j++) {
33354 if (strncmp(const_table[j].name, name,
33355 strlen(const_table[j].name)) == 0) {
33356 ci = &(const_table[j]);
33357 break;
33358 }
33359 }
33360 if (ci) {
33361 size_t shift = (ci->ptype) - types;
33362 swig_type_info *ty = types_initial[shift];
33363 size_t ldoc = (c - methods[i].ml_doc);
33364 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33365 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33366 char *buff = ndoc;
33367 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33368 strncpy(buff, methods[i].ml_doc, ldoc);
33369 buff += ldoc;
33370 strncpy(buff, "swig_ptr: ", 10);
33371 buff += 10;
33372 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33373 methods[i].ml_doc = ndoc;
33374 }
33375 }
33376 }
33377 }
33378
33379 /* -----------------------------------------------------------------------------*
33380 * Initialize type list
33381 * -----------------------------------------------------------------------------*/
33382
33383 #if PY_MAJOR_VERSION < 2
33384 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33385 is copied out of Python/modsupport.c in python version 2.3.4 */
33386 static int
33387 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33388 {
33389 PyObject *dict;
33390 if (!PyModule_Check(m)) {
33391 PyErr_SetString(PyExc_TypeError,
33392 "PyModule_AddObject() needs module as first arg");
33393 return -1;
33394 }
33395 if (!o) {
33396 PyErr_SetString(PyExc_TypeError,
33397 "PyModule_AddObject() needs non-NULL value");
33398 return -1;
33399 }
33400
33401 dict = PyModule_GetDict(m);
33402 if (dict == NULL) {
33403 /* Internal error -- modules must have a dict! */
33404 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33405 PyModule_GetName(m));
33406 return -1;
33407 }
33408 if (PyDict_SetItemString(dict, name, o))
33409 return -1;
33410 Py_DECREF(o);
33411 return 0;
33412 }
33413 #endif
33414
33415 static swig_type_info **
33416 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33417 static PyMethodDef swig_empty_runtime_method_table[] = {
33418 {
33419 NULL, NULL, 0, NULL
33420 }
33421 };/* Sentinel */
33422
33423 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33424 swig_empty_runtime_method_table);
33425 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33426 if (pointer && module) {
33427 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33428 }
33429 return type_list_handle;
33430 }
33431
33432 static swig_type_info **
33433 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33434 swig_type_info **type_pointer;
33435
33436 /* first check if module already created */
33437 type_pointer = SWIG_Python_GetTypeListHandle();
33438 if (type_pointer) {
33439 return type_pointer;
33440 } else {
33441 /* create a new module and variable */
33442 return SWIG_Python_SetTypeListHandle(type_list_handle);
33443 }
33444 }
33445
33446 #ifdef __cplusplus
33447 }
33448 #endif
33449
33450 /* -----------------------------------------------------------------------------*
33451 * Partial Init method
33452 * -----------------------------------------------------------------------------*/
33453
33454 #ifdef SWIG_LINK_RUNTIME
33455 #ifdef __cplusplus
33456 extern "C"
33457 #endif
33458 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33459 #endif
33460
33461 #ifdef __cplusplus
33462 extern "C"
33463 #endif
33464 SWIGEXPORT(void) SWIG_init(void) {
33465 static PyObject *SWIG_globals = 0;
33466 static int typeinit = 0;
33467 PyObject *m, *d;
33468 int i;
33469 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33470
33471 /* Fix SwigMethods to carry the callback ptrs when needed */
33472 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33473
33474 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33475 d = PyModule_GetDict(m);
33476
33477 if (!typeinit) {
33478 #ifdef SWIG_LINK_RUNTIME
33479 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33480 #else
33481 # ifndef SWIG_STATIC_RUNTIME
33482 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33483 # endif
33484 #endif
33485 for (i = 0; swig_types_initial[i]; i++) {
33486 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33487 }
33488 typeinit = 1;
33489 }
33490 SWIG_InstallConstants(d,swig_const_table);
33491
33492 {
33493 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33494 }
33495 {
33496 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33497 }
33498 {
33499 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33500 }
33501 {
33502 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33503 }
33504 {
33505 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33506 }
33507 {
33508 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33509 }
33510 {
33511 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33512 }
33513 {
33514 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33515 }
33516 {
33517 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33518 }
33519 {
33520 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33521 }
33522 {
33523 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33524 }
33525 {
33526 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33527 }
33528 {
33529 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33530 }
33531 {
33532 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33533 }
33534 {
33535 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33536 }
33537 {
33538 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33539 }
33540 {
33541 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33542 }
33543 {
33544 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33545 }
33546 {
33547 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33548 }
33549 {
33550 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33551 }
33552 {
33553 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33554 }
33555 {
33556 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33557 }
33558 {
33559 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33560 }
33561 {
33562 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33563 }
33564 {
33565 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33566 }
33567 {
33568 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33569 }
33570 {
33571 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33572 }
33573 {
33574 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33575 }
33576 {
33577 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33578 }
33579 {
33580 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33581 }
33582 {
33583 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33584 }
33585 {
33586 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33587 }
33588 {
33589 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33590 }
33591 {
33592 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33593 }
33594 {
33595 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33596 }
33597 {
33598 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33599 }
33600 {
33601 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33602 }
33603 {
33604 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33605 }
33606 {
33607 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33608 }
33609 {
33610 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33611 }
33612 {
33613 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33614 }
33615 {
33616 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33617 }
33618 {
33619 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33620 }
33621 {
33622 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33623 }
33624 {
33625 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33626 }
33627 {
33628 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33629 }
33630 {
33631 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33632 }
33633 {
33634 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33635 }
33636 {
33637 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33638 }
33639 {
33640 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33641 }
33642 {
33643 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33644 }
33645 {
33646 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33647 }
33648 {
33649 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33650 }
33651 {
33652 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33653 }
33654 {
33655 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33656 }
33657 {
33658 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33659 }
33660 {
33661 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33662 }
33663 {
33664 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33665 }
33666 {
33667 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33668 }
33669 {
33670 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33671 }
33672 {
33673 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33674 }
33675 {
33676 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33677 }
33678 {
33679 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33680 }
33681 {
33682 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33683 }
33684 {
33685 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33686 }
33687 {
33688 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33689 }
33690 {
33691 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33692 }
33693 {
33694 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33695 }
33696 {
33697 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33698 }
33699 {
33700 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33701 }
33702 {
33703 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33704 }
33705 {
33706 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33707 }
33708 {
33709 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33710 }
33711 {
33712 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33713 }
33714 {
33715 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33716 }
33717 {
33718 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33719 }
33720 {
33721 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33722 }
33723 {
33724 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33725 }
33726 {
33727 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33728 }
33729 {
33730 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33731 }
33732 {
33733 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33734 }
33735 {
33736 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33737 }
33738 {
33739 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33740 }
33741 {
33742 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33743 }
33744 {
33745 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33746 }
33747 {
33748 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33749 }
33750 {
33751 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33752 }
33753 {
33754 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33755 }
33756 {
33757 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33758 }
33759 {
33760 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33761 }
33762 {
33763 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33764 }
33765 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33766 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33767 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33768 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33769 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33770 {
33771 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33778 }
33779 {
33780 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33781 }
33782 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33783
33784 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33785
33786 {
33787 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33788 }
33789 {
33790 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33791 }
33792 {
33793 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33794 }
33795 {
33796 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33797 }
33798 {
33799 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33800 }
33801 {
33802 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33803 }
33804 {
33805 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33812 }
33813 {
33814 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33815 }
33816 {
33817 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33818 }
33819 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33820 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33821 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33822 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33823 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33824 {
33825 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33826 }
33827 {
33828 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33829 }
33830 {
33831 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33832 }
33833 {
33834 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33835 }
33836 {
33837 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33838 }
33839 {
33840 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33841 }
33842 {
33843 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33844 }
33845 {
33846 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33847 }
33848 {
33849 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33850 }
33851 {
33852 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33853 }
33854 {
33855 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33856 }
33857 {
33858 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33859 }
33860 {
33861 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33862 }
33863 {
33864 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33865 }
33866 {
33867 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33868 }
33869 {
33870 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33871 }
33872 {
33873 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33874 }
33875 {
33876 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33877 }
33878 {
33879 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33880 }
33881 {
33882 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33883 }
33884 {
33885 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33886 }
33887 {
33888 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33889 }
33890 {
33891 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33892 }
33893 {
33894 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33895 }
33896 {
33897 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33898 }
33899 {
33900 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33901 }
33902 {
33903 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33904 }
33905 {
33906 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33907 }
33908 {
33909 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33910 }
33911 {
33912 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33913 }
33914 {
33915 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33916 }
33917 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33918 {
33919 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33920 }
33921 {
33922 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33923 }
33924 {
33925 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33926 }
33927 {
33928 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33929 }
33930 {
33931 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33932 }
33933
33934 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33935
33936 {
33937 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33938 }
33939 {
33940 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33941 }
33942 {
33943 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33944 }
33945 {
33946 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33947 }
33948 {
33949 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33950 }
33951 {
33952 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33953 }
33954 {
33955 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33956 }
33957 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33958 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33959 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33960 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33961 {
33962 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33963 }
33964 {
33965 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33966 }
33967 {
33968 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33969 }
33970 {
33971 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33972 }
33973 {
33974 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33975 }
33976 {
33977 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33978 }
33979 {
33980 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33981 }
33982 {
33983 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33984 }
33985 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33986 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33987 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33988 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33989 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33990 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33991 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33992 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33993 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33994 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33995 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33996 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33997 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33998 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33999 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
34000 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
34001 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
34002 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
34003 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
34004 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
34005 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
34006 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
34007 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
34008 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
34009 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
34010 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
34011 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
34012 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
34013 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
34014 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
34015 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
34016 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
34017 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
34018 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
34019 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
34020 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
34021 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
34022 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
34023 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
34024 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
34025 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
34026 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
34027 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
34028 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
34029 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
34030 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
34031 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
34032 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
34033 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
34034 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
34035 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
34036 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW",_wrap_ART_NEW_get, _wrap_ART_NEW_set);
34037 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
34038 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
34039 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
34040 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
34041 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
34042
34043 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
34044
34045 {
34046 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
34047 }
34048 {
34049 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
34050 }
34051 {
34052 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
34053 }
34054 {
34055 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
34056 }
34057 {
34058 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
34059 }
34060 {
34061 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
34062 }
34063 {
34064 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
34065 }
34066 {
34067 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
34068 }
34069 {
34070 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
34071 }
34072 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
34073 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
34074 {
34075 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
34076 }
34077 {
34078 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
34079 }
34080 {
34081 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
34082 }
34083 {
34084 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
34085 }
34086 {
34087 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
34088 }
34089 {
34090 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
34091 }
34092 {
34093 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
34094 }
34095 {
34096 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
34097 }
34098 {
34099 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
34100 }
34101 {
34102 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
34103 }
34104 {
34105 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
34106 }
34107 {
34108 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
34109 }
34110 {
34111 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
34112 }
34113 {
34114 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
34115 }
34116 {
34117 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
34118 }
34119 {
34120 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
34121 }
34122 {
34123 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
34124 }
34125 {
34126 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
34127 }
34128 {
34129 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
34130 }
34131 {
34132 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
34133 }
34134 {
34135 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
34136 }
34137 {
34138 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
34139 }
34140 {
34141 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
34142 }
34143 {
34144 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
34145 }
34146 {
34147 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
34148 }
34149 {
34150 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
34151 }
34152 {
34153 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34154 }
34155 {
34156 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34157 }
34158 {
34159 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34160 }
34161 {
34162 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34163 }
34164 {
34165 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34166 }
34167 {
34168 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34169 }
34170 {
34171 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34172 }
34173 {
34174 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34175 }
34176 {
34177 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34178 }
34179 {
34180 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34181 }
34182 {
34183 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34184 }
34185 {
34186 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34187 }
34188 {
34189 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34190 }
34191 {
34192 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34193 }
34194 {
34195 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34196 }
34197 {
34198 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34199 }
34200 {
34201 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34202 }
34203 {
34204 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34205 }
34206 {
34207 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34208 }
34209 {
34210 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34211 }
34212 {
34213 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34214 }
34215 {
34216 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34217 }
34218 {
34219 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34220 }
34221 {
34222 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34223 }
34224 {
34225 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34226 }
34227 {
34228 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34229 }
34230 {
34231 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34232 }
34233 {
34234 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34235 }
34236 {
34237 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34238 }
34239 {
34240 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34241 }
34242 {
34243 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34244 }
34245 {
34246 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34247 }
34248 {
34249 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34250 }
34251 {
34252 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34253 }
34254 {
34255 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34256 }
34257 {
34258 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34259 }
34260 {
34261 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34262 }
34263 {
34264 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34265 }
34266 {
34267 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34268 }
34269 {
34270 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34271 }
34272 {
34273 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34274 }
34275 {
34276 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34277 }
34278 {
34279 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34280 }
34281 {
34282 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34283 }
34284 {
34285 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34286 }
34287 {
34288 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34289 }
34290 {
34291 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34292 }
34293 {
34294 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34295 }
34296 {
34297 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34298 }
34299 {
34300 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34301 }
34302 {
34303 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34304 }
34305 {
34306 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34307 }
34308 {
34309 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34310 }
34311 {
34312 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34313 }
34314 {
34315 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34316 }
34317 {
34318 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34319 }
34320 {
34321 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34322 }
34323 {
34324 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34325 }
34326 {
34327 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34328 }
34329 {
34330 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34331 }
34332 {
34333 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34334 }
34335 {
34336 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34337 }
34338 {
34339 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34340 }
34341 {
34342 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34343 }
34344 {
34345 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34346 }
34347 {
34348 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34349 }
34350 {
34351 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34352 }
34353 {
34354 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34355 }
34356 {
34357 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34358 }
34359 {
34360 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34361 }
34362 {
34363 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34364 }
34365 {
34366 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34367 }
34368 {
34369 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34370 }
34371 {
34372 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34373 }
34374 {
34375 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34376 }
34377 {
34378 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34379 }
34380 {
34381 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34382 }
34383 {
34384 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34385 }
34386 {
34387 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34388 }
34389 {
34390 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34391 }
34392 {
34393 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34394 }
34395 {
34396 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34397 }
34398 {
34399 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34400 }
34401 {
34402 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34403 }
34404 {
34405 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34406 }
34407 {
34408 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34409 }
34410 {
34411 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34412 }
34413 {
34414 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34415 }
34416 {
34417 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34418 }
34419 {
34420 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34421 }
34422 {
34423 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34424 }
34425 {
34426 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34427 }
34428 {
34429 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34430 }
34431 {
34432 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34433 }
34434 {
34435 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34436 }
34437 {
34438 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34439 }
34440 {
34441 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34442 }
34443 {
34444 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34445 }
34446 {
34447 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34448 }
34449 {
34450 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34451 }
34452 {
34453 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34454 }
34455 {
34456 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34457 }
34458 {
34459 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34460 }
34461 {
34462 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34463 }
34464 {
34465 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34466 }
34467 {
34468 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34469 }
34470 {
34471 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34472 }
34473 {
34474 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34475 }
34476 {
34477 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34478 }
34479 {
34480 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34481 }
34482 {
34483 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34484 }
34485 {
34486 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34487 }
34488 {
34489 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34490 }
34491 {
34492 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34493 }
34494 {
34495 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34496 }
34497 {
34498 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34499 }
34500 {
34501 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34502 }
34503 {
34504 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34505 }
34506 {
34507 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34508 }
34509 {
34510 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34511 }
34512 {
34513 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34514 }
34515 {
34516 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34517 }
34518 {
34519 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34520 }
34521 {
34522 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34523 }
34524 {
34525 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34526 }
34527 {
34528 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34529 }
34530 {
34531 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34532 }
34533 {
34534 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34535 }
34536 {
34537 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34538 }
34539 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34540 {
34541 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34542 }
34543 {
34544 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34545 }
34546 {
34547 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34548 }
34549 {
34550 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34551 }
34552 {
34553 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34554 }
34555 {
34556 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34557 }
34558 {
34559 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34560 }
34561 {
34562 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34563 }
34564 {
34565 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34566 }
34567 {
34568 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34569 }
34570 {
34571 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34572 }
34573 {
34574 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34575 }
34576 {
34577 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34578 }
34579 {
34580 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34581 }
34582 {
34583 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34584 }
34585 {
34586 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34587 }
34588 {
34589 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34590 }
34591 {
34592 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34593 }
34594 {
34595 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34596 }
34597 {
34598 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34599 }
34600 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34601 {
34602 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34603 }
34604 {
34605 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34606 }
34607 {
34608 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34609 }
34610 {
34611 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34612 }
34613 {
34614 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34615 }
34616 {
34617 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34618 }
34619 {
34620 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34621 }
34622 {
34623 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34624 }
34625 {
34626 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34627 }
34628 {
34629 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34630 }
34631 {
34632 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34633 }
34634 {
34635 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34636 }
34637
34638 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34639 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34640 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34641 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34642
34643 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34644 }
34645
wxWidgets (Impactor)