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


8f7c9fe1bd0753675065e0270b0922ea9be18dce
[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_int swig_types[17]
1360 #define SWIGTYPE_p_wxSize swig_types[18]
1361 #define SWIGTYPE_p_wxClipboard swig_types[19]
1362 #define SWIGTYPE_p_wxStopWatch swig_types[20]
1363 #define SWIGTYPE_p_wxDC swig_types[21]
1364 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
1365 #define SWIGTYPE_p_wxIcon swig_types[23]
1366 #define SWIGTYPE_p_wxLogStderr swig_types[24]
1367 #define SWIGTYPE_p_wxLogTextCtrl swig_types[25]
1368 #define SWIGTYPE_p_wxTextCtrl swig_types[26]
1369 #define SWIGTYPE_p_wxBusyCursor swig_types[27]
1370 #define SWIGTYPE_p_wxBitmapDataObject swig_types[28]
1371 #define SWIGTYPE_p_wxTextDataObject swig_types[29]
1372 #define SWIGTYPE_p_wxDataObject swig_types[30]
1373 #define SWIGTYPE_p_wxPyTextDataObject swig_types[31]
1374 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[32]
1375 #define SWIGTYPE_p_wxFileDataObject swig_types[33]
1376 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
1377 #define SWIGTYPE_p_wxURLDataObject swig_types[35]
1378 #define SWIGTYPE_p_wxMetafileDataObject swig_types[36]
1379 #define SWIGTYPE_p_wxSound swig_types[37]
1380 #define SWIGTYPE_p_wxTimerRunner swig_types[38]
1381 #define SWIGTYPE_p_wxLogWindow swig_types[39]
1382 #define SWIGTYPE_p_wxTimeSpan swig_types[40]
1383 #define SWIGTYPE_p_wxArrayString swig_types[41]
1384 #define SWIGTYPE_p_wxWindowDisabler swig_types[42]
1385 #define SWIGTYPE_p_form_ops_t swig_types[43]
1386 #define SWIGTYPE_p_wxToolTip swig_types[44]
1387 #define SWIGTYPE_p_wxDataObjectComposite swig_types[45]
1388 #define SWIGTYPE_p_wxSystemSettings swig_types[46]
1389 #define SWIGTYPE_p_wxFileConfig swig_types[47]
1390 #define SWIGTYPE_p_wxVideoMode swig_types[48]
1391 #define SWIGTYPE_p_wxDataObjectSimple swig_types[49]
1392 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[50]
1393 #define SWIGTYPE_p_wxDuplexMode swig_types[51]
1394 #define SWIGTYPE_p_wxEvtHandler swig_types[52]
1395 #define SWIGTYPE_p_wxRect swig_types[53]
1396 #define SWIGTYPE_p_char swig_types[54]
1397 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[55]
1398 #define SWIGTYPE_p_wxStandardPaths swig_types[56]
1399 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
1400 #define SWIGTYPE_p_wxFrame swig_types[58]
1401 #define SWIGTYPE_p_wxTimer swig_types[59]
1402 #define SWIGTYPE_p_wxPaperSize swig_types[60]
1403 #define SWIGTYPE_p_wxMimeTypesManager swig_types[61]
1404 #define SWIGTYPE_p_wxPyArtProvider swig_types[62]
1405 #define SWIGTYPE_p_wxPyTipProvider swig_types[63]
1406 #define SWIGTYPE_p_wxTipProvider swig_types[64]
1407 #define SWIGTYPE_p_wxJoystick swig_types[65]
1408 #define SWIGTYPE_p_wxSystemOptions swig_types[66]
1409 #define SWIGTYPE_p_wxPoint swig_types[67]
1410 #define SWIGTYPE_p_wxJoystickEvent swig_types[68]
1411 #define SWIGTYPE_p_wxCursor swig_types[69]
1412 #define SWIGTYPE_p_wxObject swig_types[70]
1413 #define SWIGTYPE_p_wxOutputStream swig_types[71]
1414 #define SWIGTYPE_p_wxDateTime swig_types[72]
1415 #define SWIGTYPE_p_wxPyDropSource swig_types[73]
1416 #define SWIGTYPE_p_unsigned_long swig_types[74]
1417 #define SWIGTYPE_p_wxKillError swig_types[75]
1418 #define SWIGTYPE_p_wxWindow swig_types[76]
1419 #define SWIGTYPE_p_wxString swig_types[77]
1420 #define SWIGTYPE_p_wxPyProcess swig_types[78]
1421 #define SWIGTYPE_p_wxBitmap swig_types[79]
1422 #define SWIGTYPE_p_wxConfig swig_types[80]
1423 #define SWIGTYPE_unsigned_int swig_types[81]
1424 #define SWIGTYPE_p_unsigned_int swig_types[82]
1425 #define SWIGTYPE_p_unsigned_char swig_types[83]
1426 #define SWIGTYPE_p_wxChar swig_types[84]
1427 #define SWIGTYPE_p_wxBusyInfo swig_types[85]
1428 #define SWIGTYPE_p_wxPyDropTarget swig_types[86]
1429 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[87]
1430 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[88]
1431 #define SWIGTYPE_p_wxProcessEvent swig_types[89]
1432 #define SWIGTYPE_p_wxPyLog swig_types[90]
1433 #define SWIGTYPE_p_wxLogNull swig_types[91]
1434 #define SWIGTYPE_p_wxColour swig_types[92]
1435 #define SWIGTYPE_p_wxPyTimer swig_types[93]
1436 #define SWIGTYPE_p_wxConfigPathChanger swig_types[94]
1437 #define SWIGTYPE_p_wxDateSpan swig_types[95]
1438 static swig_type_info *swig_types[97];
1439
1440 /* -------- TYPES TABLE (END) -------- */
1441
1442
1443 /*-----------------------------------------------
1444 @(target):= _misc_.so
1445 ------------------------------------------------*/
1446 #define SWIG_init init_misc_
1447
1448 #define SWIG_name "_misc_"
1449
1450 #include "wx/wxPython/wxPython.h"
1451 #include "wx/wxPython/pyclasses.h"
1452 #include "wx/wxPython/pyistream.h"
1453
1454 static const wxString wxPyEmptyString(wxEmptyString);
1455
1456
1457
1458 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1459 #define SWIG_From_int PyInt_FromLong
1460 /*@@*/
1461
1462
1463 #include <limits.h>
1464
1465
1466 SWIGINTERN int
1467 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1468 const char *errmsg)
1469 {
1470 if (value < min_value) {
1471 if (errmsg) {
1472 PyErr_Format(PyExc_OverflowError,
1473 "value %ld is less than '%s' minimum %ld",
1474 value, errmsg, min_value);
1475 }
1476 return 0;
1477 } else if (value > max_value) {
1478 if (errmsg) {
1479 PyErr_Format(PyExc_OverflowError,
1480 "value %ld is greater than '%s' maximum %ld",
1481 value, errmsg, max_value);
1482 }
1483 return 0;
1484 }
1485 return 1;
1486 }
1487
1488
1489 SWIGINTERN int
1490 SWIG_AsVal_long(PyObject* obj, long* val)
1491 {
1492 if (PyNumber_Check(obj)) {
1493 if (val) *val = PyInt_AsLong(obj);
1494 return 1;
1495 }
1496 else {
1497 SWIG_type_error("number", obj);
1498 }
1499 return 0;
1500 }
1501
1502
1503 #if INT_MAX != LONG_MAX
1504 SWIGINTERN int
1505 SWIG_AsVal_int(PyObject *obj, int *val)
1506 {
1507 const char* errmsg = val ? "int" : (char*)0;
1508 long v;
1509 if (SWIG_AsVal_long(obj, &v)) {
1510 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1511 if (val) *val = (int)(v);
1512 return 1;
1513 } else {
1514 return 0;
1515 }
1516 } else {
1517 PyErr_Clear();
1518 }
1519 if (val) {
1520 SWIG_type_error(errmsg, obj);
1521 }
1522 return 0;
1523 }
1524 #else
1525 SWIGINTERNSHORT int
1526 SWIG_AsVal_int(PyObject *obj, int *val)
1527 {
1528 return SWIG_AsVal_long(obj,(long*)val);
1529 }
1530 #endif
1531
1532
1533 SWIGINTERNSHORT int
1534 SWIG_As_int(PyObject* obj)
1535 {
1536 int v;
1537 if (!SWIG_AsVal_int(obj, &v)) {
1538 /*
1539 this is needed to make valgrind/purify happier.
1540 */
1541 memset((void*)&v, 0, sizeof(int));
1542 }
1543 return v;
1544 }
1545
1546
1547 SWIGINTERNSHORT int
1548 SWIG_Check_int(PyObject* obj)
1549 {
1550 return SWIG_AsVal_int(obj, (int*)0);
1551 }
1552
1553 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1554
1555 #include <wx/stockitem.h>
1556
1557 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1558 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1559 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1560
1561 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1562 #define SWIG_From_long PyInt_FromLong
1563 /*@@*/
1564
1565
1566 SWIGINTERNSHORT long
1567 SWIG_As_long(PyObject* obj)
1568 {
1569 long v;
1570 if (!SWIG_AsVal_long(obj, &v)) {
1571 /*
1572 this is needed to make valgrind/purify happier.
1573 */
1574 memset((void*)&v, 0, sizeof(long));
1575 }
1576 return v;
1577 }
1578
1579
1580 SWIGINTERNSHORT int
1581 SWIG_Check_long(PyObject* obj)
1582 {
1583 return SWIG_AsVal_long(obj, (long*)0);
1584 }
1585
1586
1587 SWIGINTERN int
1588 SWIG_AsVal_bool(PyObject *obj, bool *val)
1589 {
1590 if (obj == Py_True) {
1591 if (val) *val = true;
1592 return 1;
1593 }
1594 if (obj == Py_False) {
1595 if (val) *val = false;
1596 return 1;
1597 }
1598 int res = 0;
1599 if (SWIG_AsVal_int(obj, &res)) {
1600 if (val) *val = res ? true : false;
1601 return 1;
1602 } else {
1603 PyErr_Clear();
1604 }
1605 if (val) {
1606 SWIG_type_error("bool", obj);
1607 }
1608 return 0;
1609 }
1610
1611
1612 SWIGINTERNSHORT bool
1613 SWIG_As_bool(PyObject* obj)
1614 {
1615 bool v;
1616 if (!SWIG_AsVal_bool(obj, &v)) {
1617 /*
1618 this is needed to make valgrind/purify happier.
1619 */
1620 memset((void*)&v, 0, sizeof(bool));
1621 }
1622 return v;
1623 }
1624
1625
1626 SWIGINTERNSHORT int
1627 SWIG_Check_bool(PyObject* obj)
1628 {
1629 return SWIG_AsVal_bool(obj, (bool*)0);
1630 }
1631
1632
1633 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1634 PyObject* o2;
1635 PyObject* o3;
1636
1637 if (!target) {
1638 target = o;
1639 } else if (target == Py_None) {
1640 Py_DECREF(Py_None);
1641 target = o;
1642 } else {
1643 if (!PyTuple_Check(target)) {
1644 o2 = target;
1645 target = PyTuple_New(1);
1646 PyTuple_SetItem(target, 0, o2);
1647 }
1648 o3 = PyTuple_New(1);
1649 PyTuple_SetItem(o3, 0, o);
1650
1651 o2 = target;
1652 target = PySequence_Concat(o2, o3);
1653 Py_DECREF(o2);
1654 Py_DECREF(o3);
1655 }
1656 return target;
1657 }
1658
1659
1660
1661 long wxGetFreeMemory()
1662 { wxPyRaiseNotImplemented(); return 0; }
1663
1664
1665 SWIGINTERN int
1666 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1667 {
1668 long v = 0;
1669 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1670 SWIG_type_error("unsigned number", obj);
1671 }
1672 else if (val)
1673 *val = (unsigned long)v;
1674 return 1;
1675 }
1676
1677
1678 SWIGINTERNSHORT unsigned long
1679 SWIG_As_unsigned_SS_long(PyObject* obj)
1680 {
1681 unsigned long v;
1682 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1683 /*
1684 this is needed to make valgrind/purify happier.
1685 */
1686 memset((void*)&v, 0, sizeof(unsigned long));
1687 }
1688 return v;
1689 }
1690
1691
1692 SWIGINTERNSHORT int
1693 SWIG_Check_unsigned_SS_long(PyObject* obj)
1694 {
1695 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1696 }
1697
1698
1699 SWIGINTERNSHORT PyObject*
1700 SWIG_From_unsigned_SS_long(unsigned long value)
1701 {
1702 return (value > LONG_MAX) ?
1703 PyLong_FromUnsignedLong(value)
1704 : PyInt_FromLong((long)(value));
1705 }
1706
1707
1708 void wxWakeUpMainThread() {}
1709
1710
1711 bool wxThread_IsMain() {
1712 #ifdef WXP_WITH_THREAD
1713 return wxThread::IsMain();
1714 #else
1715 return true;
1716 #endif
1717 }
1718
1719 static void wxCaret_Destroy(wxCaret *self){
1720 delete self;
1721 }
1722
1723 #include <wx/snglinst.h>
1724
1725
1726 #ifdef __WXMSW__
1727 #include <wx/msw/private.h>
1728 #include <wx/dynload.h>
1729 #endif
1730
1731
1732
1733 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1734 #if 0
1735 , int method
1736 #endif
1737 )
1738 {
1739 #ifdef __WXMSW__
1740 #if 0
1741 switch (method)
1742 {
1743 case 1:
1744 // This one only partially works. Appears to be an undocumented
1745 // "standard" convention that not all widgets adhear to. For
1746 // example, for some widgets backgrounds or non-client areas may
1747 // not be painted.
1748 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1749 break;
1750
1751 case 2:
1752 #endif
1753 // This one works much better, nearly all widgets and their
1754 // children are captured correctly[**]. Prior to the big
1755 // background erase changes that Vadim did in 2004-2005 this
1756 // method failed badly on XP with Themes activated, most native
1757 // widgets draw only partially, if at all. Without themes it
1758 // worked just like on Win2k. After those changes this method
1759 // works very well.
1760 //
1761 // ** For example the radio buttons in a wxRadioBox are not its
1762 // children by default, but you can capture it via the panel
1763 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1764 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1765 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1766 PRF_ERASEBKGND | PRF_OWNED );
1767 return true;
1768 #if 0
1769 break;
1770
1771 case 3:
1772 // This one is only defined in the latest SDK and is only
1773 // available on XP. MSDN says it is similar to sending WM_PRINT
1774 // so I expect that it will work similar to the above. Since it
1775 // is avaialble only on XP, it can't be compiled like this and
1776 // will have to be loaded dynamically.
1777 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1778
1779 // fall through
1780
1781 case 4:
1782 // Use PrintWindow if available, or fallback to WM_PRINT
1783 // otherwise. Unfortunately using PrintWindow is even worse than
1784 // WM_PRINT. For most native widgets nothing is drawn to the dc
1785 // at all, with or without Themes.
1786 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1787 static bool s_triedToLoad = false;
1788 static PrintWindow_t pfnPrintWindow = NULL;
1789 if ( !s_triedToLoad )
1790 {
1791
1792 s_triedToLoad = true;
1793 wxDynamicLibrary dllUser32(_T("user32.dll"));
1794 if ( dllUser32.IsLoaded() )
1795 {
1796 wxLogNull nolog; // Don't report errors here
1797 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1798 }
1799 }
1800 if (pfnPrintWindow)
1801 {
1802 //printf("Using PrintWindow\n");
1803 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1804 }
1805 else
1806 {
1807 //printf("Using WM_PRINT\n");
1808 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1809 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1810 PRF_ERASEBKGND | PRF_OWNED );
1811 }
1812 }
1813 #endif // 0
1814 #else
1815 return false;
1816 #endif // __WXMSW__
1817 }
1818
1819
1820
1821 #include <wx/tipdlg.h>
1822
1823
1824 class wxPyTipProvider : public wxTipProvider {
1825 public:
1826 wxPyTipProvider(size_t currentTip)
1827 : wxTipProvider(currentTip) {}
1828
1829 DEC_PYCALLBACK_STRING__pure(GetTip);
1830 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1831 PYPRIVATE;
1832 };
1833
1834 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1835 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1836
1837
1838 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1839
1840 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1841
1842 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1843 : wxTimer(owner, id)
1844 {
1845 if (owner == NULL) SetOwner(this);
1846 }
1847
1848
1849 void wxPyTimer::Notify() {
1850 bool found;
1851 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1852 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1853 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1854 wxPyEndBlockThreads(blocked);
1855 if (! found)
1856 wxTimer::Notify();
1857 }
1858 void wxPyTimer::base_Notify() {
1859 wxTimer::Notify();
1860 }
1861
1862
1863
1864 SWIGINTERN PyObject *
1865 SWIG_FromCharPtr(const char* cptr)
1866 {
1867 if (cptr) {
1868 size_t size = strlen(cptr);
1869 if (size > INT_MAX) {
1870 return SWIG_NewPointerObj((char*)(cptr),
1871 SWIG_TypeQuery("char *"), 0);
1872 } else {
1873 if (size != 0) {
1874 return PyString_FromStringAndSize(cptr, size);
1875 } else {
1876 return PyString_FromString(cptr);
1877 }
1878 }
1879 }
1880 Py_INCREF(Py_None);
1881 return Py_None;
1882 }
1883
1884
1885 SWIGINTERNSHORT int
1886 SWIG_CheckUnsignedLongInRange(unsigned long value,
1887 unsigned long max_value,
1888 const char *errmsg)
1889 {
1890 if (value > max_value) {
1891 if (errmsg) {
1892 PyErr_Format(PyExc_OverflowError,
1893 "value %lu is greater than '%s' minimum %lu",
1894 value, errmsg, max_value);
1895 }
1896 return 0;
1897 }
1898 return 1;
1899 }
1900
1901
1902 #if UINT_MAX != ULONG_MAX
1903 SWIGINTERN int
1904 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1905 {
1906 const char* errmsg = val ? "unsigned int" : (char*)0;
1907 unsigned long v;
1908 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1909 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1910 if (val) *val = (unsigned int)(v);
1911 return 1;
1912 }
1913 } else {
1914 PyErr_Clear();
1915 }
1916 if (val) {
1917 SWIG_type_error(errmsg, obj);
1918 }
1919 return 0;
1920 }
1921 #else
1922 SWIGINTERNSHORT unsigned int
1923 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1924 {
1925 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1926 }
1927 #endif
1928
1929
1930 SWIGINTERNSHORT unsigned int
1931 SWIG_As_unsigned_SS_int(PyObject* obj)
1932 {
1933 unsigned int v;
1934 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1935 /*
1936 this is needed to make valgrind/purify happier.
1937 */
1938 memset((void*)&v, 0, sizeof(unsigned int));
1939 }
1940 return v;
1941 }
1942
1943
1944 SWIGINTERNSHORT int
1945 SWIG_Check_unsigned_SS_int(PyObject* obj)
1946 {
1947 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1948 }
1949
1950 static wxString Log_TimeStamp(){
1951 wxString msg;
1952 wxLog::TimeStamp(&msg);
1953 return msg;
1954 }
1955 static void wxLog_Destroy(wxLog *self){ delete self; }
1956 // Make somce wrappers that double any % signs so they are 'escaped'
1957 void wxPyLogFatalError(const wxString& msg)
1958 {
1959 wxString m(msg);
1960 m.Replace(wxT("%"), wxT("%%"));
1961 wxLogFatalError(m);
1962 }
1963
1964 void wxPyLogError(const wxString& msg)
1965 {
1966 wxString m(msg);
1967 m.Replace(wxT("%"), wxT("%%"));
1968 wxLogError(m);
1969 }
1970
1971 void wxPyLogWarning(const wxString& msg)
1972 {
1973 wxString m(msg);
1974 m.Replace(wxT("%"), wxT("%%"));
1975 wxLogWarning(m);
1976 }
1977
1978 void wxPyLogMessage(const wxString& msg)
1979 {
1980 wxString m(msg);
1981 m.Replace(wxT("%"), wxT("%%"));
1982 wxLogMessage(m);
1983 }
1984
1985 void wxPyLogInfo(const wxString& msg)
1986 {
1987 wxString m(msg);
1988 m.Replace(wxT("%"), wxT("%%"));
1989 wxLogInfo(m);
1990 }
1991
1992 void wxPyLogDebug(const wxString& msg)
1993 {
1994 wxString m(msg);
1995 m.Replace(wxT("%"), wxT("%%"));
1996 wxLogDebug(m);
1997 }
1998
1999 void wxPyLogVerbose(const wxString& msg)
2000 {
2001 wxString m(msg);
2002 m.Replace(wxT("%"), wxT("%%"));
2003 wxLogVerbose(m);
2004 }
2005
2006 void wxPyLogStatus(const wxString& msg)
2007 {
2008 wxString m(msg);
2009 m.Replace(wxT("%"), wxT("%%"));
2010 wxLogStatus(m);
2011 }
2012
2013 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2014 {
2015 wxString m(msg);
2016 m.Replace(wxT("%"), wxT("%%"));
2017 wxLogStatus(pFrame, m);
2018 }
2019
2020 void wxPyLogSysError(const wxString& msg)
2021 {
2022 wxString m(msg);
2023 m.Replace(wxT("%"), wxT("%%"));
2024 wxLogSysError(m);
2025 }
2026
2027 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2028 {
2029 wxString m(msg);
2030 m.Replace(wxT("%"), wxT("%%"));
2031 wxLogGeneric(level, m);
2032 }
2033
2034 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2035 {
2036 wxString m(msg);
2037 m.Replace(wxT("%"), wxT("%%"));
2038 wxLogTrace(mask, m);
2039 }
2040
2041 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2042 {
2043 wxString m(msg);
2044 m.Replace(wxT("%"), wxT("%%"));
2045 wxLogTrace(mask, m);
2046 }
2047
2048
2049
2050 // A wxLog class that can be derived from in wxPython
2051 class wxPyLog : public wxLog {
2052 public:
2053 wxPyLog() : wxLog() {}
2054
2055 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2056 bool found;
2057 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2058 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2059 PyObject* s = wx2PyString(szString);
2060 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2061 Py_DECREF(s);
2062 }
2063 wxPyEndBlockThreads(blocked);
2064 if (! found)
2065 wxLog::DoLog(level, szString, t);
2066 }
2067
2068 virtual void DoLogString(const wxChar *szString, time_t t) {
2069 bool found;
2070 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2071 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2072 PyObject* s = wx2PyString(szString);
2073 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2074 Py_DECREF(s);
2075 }
2076 wxPyEndBlockThreads(blocked);
2077 if (! found)
2078 wxLog::DoLogString(szString, t);
2079 }
2080
2081 PYPRIVATE;
2082 };
2083
2084
2085
2086
2087 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2088
2089
2090 #include <wx/joystick.h>
2091
2092
2093 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2094 // A C++ stub class for wxJoystick for platforms that don't have it.
2095 class wxJoystick : public wxObject {
2096 public:
2097 wxJoystick(int joystick = wxJOYSTICK1) {
2098 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2099 PyErr_SetString(PyExc_NotImplementedError,
2100 "wxJoystick is not available on this platform.");
2101 wxPyEndBlockThreads(blocked);
2102 }
2103 wxPoint GetPosition() { return wxPoint(-1,-1); }
2104 int GetZPosition() { return -1; }
2105 int GetButtonState() { return -1; }
2106 int GetPOVPosition() { return -1; }
2107 int GetPOVCTSPosition() { return -1; }
2108 int GetRudderPosition() { return -1; }
2109 int GetUPosition() { return -1; }
2110 int GetVPosition() { return -1; }
2111 int GetMovementThreshold() { return -1; }
2112 void SetMovementThreshold(int threshold) {}
2113
2114 bool IsOk(void) { return false; }
2115 int GetNumberJoysticks() { return -1; }
2116 int GetManufacturerId() { return -1; }
2117 int GetProductId() { return -1; }
2118 wxString GetProductName() { return wxEmptyString; }
2119 int GetXMin() { return -1; }
2120 int GetYMin() { return -1; }
2121 int GetZMin() { return -1; }
2122 int GetXMax() { return -1; }
2123 int GetYMax() { return -1; }
2124 int GetZMax() { return -1; }
2125 int GetNumberButtons() { return -1; }
2126 int GetNumberAxes() { return -1; }
2127 int GetMaxButtons() { return -1; }
2128 int GetMaxAxes() { return -1; }
2129 int GetPollingMin() { return -1; }
2130 int GetPollingMax() { return -1; }
2131 int GetRudderMin() { return -1; }
2132 int GetRudderMax() { return -1; }
2133 int GetUMin() { return -1; }
2134 int GetUMax() { return -1; }
2135 int GetVMin() { return -1; }
2136 int GetVMax() { return -1; }
2137
2138 bool HasRudder() { return false; }
2139 bool HasZ() { return false; }
2140 bool HasU() { return false; }
2141 bool HasV() { return false; }
2142 bool HasPOV() { return false; }
2143 bool HasPOV4Dir() { return false; }
2144 bool HasPOVCTS() { return false; }
2145
2146 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2147 bool ReleaseCapture() { return false; }
2148 };
2149 #endif
2150
2151
2152 #include <wx/sound.h>
2153
2154
2155 #if !wxUSE_SOUND
2156 // A C++ stub class for wxWave for platforms that don't have it.
2157 class wxSound : public wxObject
2158 {
2159 public:
2160 wxSound() {
2161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2162 PyErr_SetString(PyExc_NotImplementedError,
2163 "wxSound is not available on this platform.");
2164 wxPyEndBlockThreads(blocked);
2165 }
2166 wxSound(const wxString&/*, bool*/) {
2167 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2168 PyErr_SetString(PyExc_NotImplementedError,
2169 "wxSound is not available on this platform.");
2170 wxPyEndBlockThreads(blocked);
2171 }
2172 wxSound(int, const wxByte*) {
2173 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2174 PyErr_SetString(PyExc_NotImplementedError,
2175 "wxSound is not available on this platform.");
2176 wxPyEndBlockThreads(blocked);
2177 }
2178
2179 ~wxSound() {};
2180
2181 bool Create(const wxString&/*, bool*/) { return false; }
2182 bool Create(int, const wxByte*) { return false; };
2183 bool IsOk() { return false; };
2184 bool Play(unsigned) const { return false; }
2185 static bool Play(const wxString&, unsigned) { return false; }
2186 static void Stop() {}
2187 };
2188
2189 #endif
2190
2191 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2192 if (fileName.Length() == 0)
2193 return new wxSound;
2194 else
2195 return new wxSound(fileName);
2196 }
2197 static wxSound *new_wxSound(PyObject *data){
2198 unsigned char* buffer; int size;
2199 wxSound *sound = NULL;
2200
2201 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2202 if (!PyArg_Parse(data, "t#", &buffer, &size))
2203 goto done;
2204 sound = new wxSound(size, buffer);
2205 done:
2206 wxPyEndBlockThreads(blocked);
2207 return sound;
2208 }
2209 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2210 #ifndef __WXMAC__
2211 unsigned char* buffer;
2212 int size;
2213 bool rv = false;
2214
2215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2216 if (!PyArg_Parse(data, "t#", &buffer, &size))
2217 goto done;
2218 rv = self->Create(size, buffer);
2219 done:
2220 wxPyEndBlockThreads(blocked);
2221 return rv;
2222 #else
2223 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2224 PyErr_SetString(PyExc_NotImplementedError,
2225 "Create from data is not available on this platform.");
2226 wxPyEndBlockThreads(blocked);
2227 return false;
2228 #endif
2229 }
2230
2231 #include <wx/mimetype.h>
2232
2233 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2234 wxString str;
2235 if (self->GetMimeType(&str))
2236 return wx2PyString(str);
2237 else
2238 RETURN_NONE();
2239 }
2240 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2241 wxArrayString arr;
2242 if (self->GetMimeTypes(arr))
2243 return wxArrayString2PyList_helper(arr);
2244 else
2245 RETURN_NONE();
2246 }
2247 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2248 wxArrayString arr;
2249 if (self->GetExtensions(arr))
2250 return wxArrayString2PyList_helper(arr);
2251 else
2252 RETURN_NONE();
2253 }
2254 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2255 wxIconLocation loc;
2256 if (self->GetIcon(&loc))
2257 return new wxIcon(loc);
2258 else
2259 return NULL;
2260 }
2261 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2262 wxIconLocation loc;
2263 if (self->GetIcon(&loc)) {
2264 wxString iconFile = loc.GetFileName();
2265 int iconIndex = -1;
2266
2267
2268
2269 // Make a tuple and put the values in it
2270 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2271 PyObject* tuple = PyTuple_New(3);
2272 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2273 wxT("wxIcon"), true));
2274 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2275 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2276 wxPyEndBlockThreads(blocked);
2277 return tuple;
2278 }
2279 else
2280 RETURN_NONE();
2281 }
2282 static PyObject *wxFileType_GetDescription(wxFileType *self){
2283 wxString str;
2284 if (self->GetDescription(&str))
2285 return wx2PyString(str);
2286 else
2287 RETURN_NONE();
2288 }
2289 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2290 wxString str;
2291 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2292 return wx2PyString(str);
2293 else
2294 RETURN_NONE();
2295 }
2296 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2297 wxString str;
2298 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2299 return wx2PyString(str);
2300 else
2301 RETURN_NONE();
2302 }
2303 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2304 wxArrayString verbs;
2305 wxArrayString commands;
2306 if (self->GetAllCommands(&verbs, &commands,
2307 wxFileType::MessageParameters(filename, mimetype))) {
2308 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2309 PyObject* tuple = PyTuple_New(2);
2310 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2311 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2312 wxPyEndBlockThreads(blocked);
2313 return tuple;
2314 }
2315 else
2316 RETURN_NONE();
2317 }
2318 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2319 return wxFileType::ExpandCommand(command,
2320 wxFileType::MessageParameters(filename, mimetype));
2321 }
2322 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2323 wxArrayString arr;
2324 self->EnumAllFileTypes(arr);
2325 return wxArrayString2PyList_helper(arr);
2326 }
2327
2328 #include <wx/artprov.h>
2329
2330 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2331 static const wxString wxPyART_MENU(wxART_MENU);
2332 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2333 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2334 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2335 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2336 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2337 static const wxString wxPyART_OTHER(wxART_OTHER);
2338 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2339 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2340 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2341 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2342 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2343 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2344 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2345 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2346 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2347 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2348 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2349 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2350 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2351 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2352 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2353 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2354 static const wxString wxPyART_PRINT(wxART_PRINT);
2355 static const wxString wxPyART_HELP(wxART_HELP);
2356 static const wxString wxPyART_TIP(wxART_TIP);
2357 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2358 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2359 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2360 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2361 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2362 static const wxString wxPyART_CDROM(wxART_CDROM);
2363 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2364 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2365 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2366 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2367 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2368 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2369 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2370 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2371 static const wxString wxPyART_ERROR(wxART_ERROR);
2372 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2373 static const wxString wxPyART_WARNING(wxART_WARNING);
2374 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2375 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2376 static const wxString wxPyART_COPY(wxART_COPY);
2377 static const wxString wxPyART_CUT(wxART_CUT);
2378 static const wxString wxPyART_PASTE(wxART_PASTE);
2379 static const wxString wxPyART_DELETE(wxART_DELETE);
2380 static const wxString wxPyART_UNDO(wxART_UNDO);
2381 static const wxString wxPyART_REDO(wxART_REDO);
2382 static const wxString wxPyART_QUIT(wxART_QUIT);
2383 static const wxString wxPyART_FIND(wxART_FIND);
2384 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2385 // Python aware wxArtProvider
2386 class wxPyArtProvider : public wxArtProvider {
2387 public:
2388
2389 virtual wxBitmap CreateBitmap(const wxArtID& id,
2390 const wxArtClient& client,
2391 const wxSize& size) {
2392 wxBitmap rval = wxNullBitmap;
2393 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2394 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2395 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2396 PyObject* ro;
2397 wxBitmap* ptr;
2398 PyObject* s1, *s2;
2399 s1 = wx2PyString(id);
2400 s2 = wx2PyString(client);
2401 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2402 Py_DECREF(so);
2403 Py_DECREF(s1);
2404 Py_DECREF(s2);
2405 if (ro) {
2406 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2407 rval = *ptr;
2408 Py_DECREF(ro);
2409 }
2410 }
2411 wxPyEndBlockThreads(blocked);
2412 return rval;
2413 }
2414
2415 PYPRIVATE;
2416 };
2417
2418 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2419
2420
2421
2422 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2423 PyObject* ret = PyTuple_New(3);
2424 if (ret) {
2425 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2426 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2427 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2428 }
2429 return ret;
2430 }
2431
2432 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2433 bool cont;
2434 long index = 0;
2435 wxString value;
2436
2437 cont = self->GetFirstGroup(value, index);
2438 return __EnumerationHelper(cont, value, index);
2439 }
2440 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2441 bool cont;
2442 wxString value;
2443
2444 cont = self->GetNextGroup(value, index);
2445 return __EnumerationHelper(cont, value, index);
2446 }
2447 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2448 bool cont;
2449 long index = 0;
2450 wxString value;
2451
2452 cont = self->GetFirstEntry(value, index);
2453 return __EnumerationHelper(cont, value, index);
2454 }
2455 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2456 bool cont;
2457 wxString value;
2458
2459 cont = self->GetNextEntry(value, index);
2460 return __EnumerationHelper(cont, value, index);
2461 }
2462 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2463 long rv;
2464 self->Read(key, &rv, defaultVal);
2465 return rv;
2466 }
2467
2468 SWIGINTERN int
2469 SWIG_AsVal_double(PyObject *obj, double* val)
2470 {
2471 if (PyNumber_Check(obj)) {
2472 if (val) *val = PyFloat_AsDouble(obj);
2473 return 1;
2474 }
2475 else {
2476 SWIG_type_error("number", obj);
2477 }
2478 return 0;
2479 }
2480
2481
2482 SWIGINTERNSHORT double
2483 SWIG_As_double(PyObject* obj)
2484 {
2485 double v;
2486 if (!SWIG_AsVal_double(obj, &v)) {
2487 /*
2488 this is needed to make valgrind/purify happier.
2489 */
2490 memset((void*)&v, 0, sizeof(double));
2491 }
2492 return v;
2493 }
2494
2495
2496 SWIGINTERNSHORT int
2497 SWIG_Check_double(PyObject* obj)
2498 {
2499 return SWIG_AsVal_double(obj, (double*)0);
2500 }
2501
2502 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2503 double rv;
2504 self->Read(key, &rv, defaultVal);
2505 return rv;
2506 }
2507
2508 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2509 #define SWIG_From_double PyFloat_FromDouble
2510 /*@@*/
2511
2512 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2513 bool rv;
2514 self->Read(key, &rv, defaultVal);
2515 return rv;
2516 }
2517
2518 #include <wx/datetime.h>
2519
2520 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2521 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2522
2523 #define LOCAL_TZ wxDateTime::Local
2524
2525 static PyObject *DateTime_GetAmPmStrings(){
2526 wxString am;
2527 wxString pm;
2528 wxDateTime::GetAmPmStrings(&am, &pm);
2529 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2530 PyObject* tup = PyTuple_New(2);
2531 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2532 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2533 wxPyEndBlockThreads(blocked);
2534 return tup;
2535 }
2536
2537 #if UINT_MAX < LONG_MAX
2538 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2539 #define SWIG_From_unsigned_SS_int SWIG_From_long
2540 /*@@*/
2541 #else
2542 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2543 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2544 /*@@*/
2545 #endif
2546
2547 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2548 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2549 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2550 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2551 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2552 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2553 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2554 return (*self < *other);
2555 }
2556 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2557 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2558 return (*self <= *other);
2559 }
2560 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2561 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2562 return (*self > *other);
2563 }
2564 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2565 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2566 return (*self >= *other);
2567 }
2568 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2569 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2570 return (*self == *other);
2571 }
2572 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2573 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2574 return (*self != *other);
2575 }
2576 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2577 const wxChar* rv;
2578 const wxChar* _date = date;
2579 rv = self->ParseRfc822Date(_date);
2580 if (rv == NULL) return -1;
2581 return rv - _date;
2582 }
2583 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2584 const wxChar* rv;
2585 const wxChar* _date = date;
2586 rv = self->ParseFormat(_date, format, dateDef);
2587 if (rv == NULL) return -1;
2588 return rv - _date;
2589 }
2590 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2591 const wxChar* rv;
2592 const wxChar* _datetime = datetime;
2593 rv = self->ParseDateTime(_datetime);
2594 if (rv == NULL) return -1;
2595 return rv - _datetime;
2596 }
2597 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2598 const wxChar* rv;
2599 const wxChar* _date = date;
2600 rv = self->ParseDate(_date);
2601 if (rv == NULL) return -1;
2602 return rv - _date;
2603 }
2604 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2605 const wxChar* rv;
2606 const wxChar* _time = time;
2607 rv = self->ParseTime(_time);
2608 if (rv == NULL) return -1;
2609 return rv - _time;
2610 }
2611 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2612 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2613 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2614 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2615 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2616 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2617 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2618 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2619 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2620 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2621 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2622 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2623 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2624 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2625 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2626 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2627
2628 #include <wx/dataobj.h>
2629
2630 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2631 size_t count = self->GetFormatCount(dir);
2632 wxDataFormat* formats = new wxDataFormat[count];
2633 self->GetAllFormats(formats, dir);
2634
2635 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2636 PyObject* list = PyList_New(count);
2637 for (size_t i=0; i<count; i++) {
2638 wxDataFormat* format = new wxDataFormat(formats[i]);
2639 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2640 PyList_Append(list, obj);
2641 Py_DECREF(obj);
2642 }
2643 wxPyEndBlockThreads(blocked);
2644 delete [] formats;
2645 return list;
2646 }
2647 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2648 PyObject* rval = NULL;
2649 size_t size = self->GetDataSize(format);
2650 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2651 if (size) {
2652 char* buf = new char[size];
2653 if (self->GetDataHere(format, buf))
2654 rval = PyString_FromStringAndSize(buf, size);
2655 delete [] buf;
2656 }
2657 if (! rval) {
2658 rval = Py_None;
2659 Py_INCREF(rval);
2660 }
2661 wxPyEndBlockThreads(blocked);
2662 return rval;
2663 }
2664 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2665 bool rval;
2666 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2667 if (PyString_Check(data)) {
2668 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2669 }
2670 else {
2671 // raise a TypeError if not a string
2672 PyErr_SetString(PyExc_TypeError, "String expected.");
2673 rval = false;
2674 }
2675 wxPyEndBlockThreads(blocked);
2676 return rval;
2677 }
2678 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2679 PyObject* rval = NULL;
2680 size_t size = self->GetDataSize();
2681 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2682 if (size) {
2683 char* buf = new char[size];
2684 if (self->GetDataHere(buf))
2685 rval = PyString_FromStringAndSize(buf, size);
2686 delete [] buf;
2687 }
2688 if (! rval) {
2689 rval = Py_None;
2690 Py_INCREF(rval);
2691 }
2692 wxPyEndBlockThreads(blocked);
2693 return rval;
2694 }
2695 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2696 bool rval;
2697 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2698 if (PyString_Check(data)) {
2699 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2700 }
2701 else {
2702 // raise a TypeError if not a string
2703 PyErr_SetString(PyExc_TypeError, "String expected.");
2704 rval = false;
2705 }
2706 wxPyEndBlockThreads(blocked);
2707 return rval;
2708 }
2709 // Create a new class for wxPython to use
2710 class wxPyDataObjectSimple : public wxDataObjectSimple {
2711 public:
2712 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2713 : wxDataObjectSimple(format) {}
2714
2715 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2716 bool GetDataHere(void *buf) const;
2717 bool SetData(size_t len, const void *buf) const;
2718 PYPRIVATE;
2719 };
2720
2721 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2722
2723 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2724 // We need to get the data for this object and write it to buf. I think
2725 // the best way to do this for wxPython is to have the Python method
2726 // return either a string or None and then act appropriately with the
2727 // C++ version.
2728
2729 bool rval = false;
2730 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2731 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2732 PyObject* ro;
2733 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2734 if (ro) {
2735 rval = (ro != Py_None && PyString_Check(ro));
2736 if (rval)
2737 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2738 Py_DECREF(ro);
2739 }
2740 }
2741 wxPyEndBlockThreads(blocked);
2742 return rval;
2743 }
2744
2745 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2746 // For this one we simply need to make a string from buf and len
2747 // and send it to the Python method.
2748 bool rval = false;
2749 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2750 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2751 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2752 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2753 Py_DECREF(data);
2754 }
2755 wxPyEndBlockThreads(blocked);
2756 return rval;
2757 }
2758
2759 // Create a new class for wxPython to use
2760 class wxPyTextDataObject : public wxTextDataObject {
2761 public:
2762 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2763 : wxTextDataObject(text) {}
2764
2765 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2766 DEC_PYCALLBACK_STRING__const(GetText);
2767 DEC_PYCALLBACK__STRING(SetText);
2768 PYPRIVATE;
2769 };
2770
2771 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2772 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2773 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2774
2775
2776 // Create a new class for wxPython to use
2777 class wxPyBitmapDataObject : public wxBitmapDataObject {
2778 public:
2779 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2780 : wxBitmapDataObject(bitmap) {}
2781
2782 wxBitmap GetBitmap() const;
2783 void SetBitmap(const wxBitmap& bitmap);
2784 PYPRIVATE;
2785 };
2786
2787 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2788 wxBitmap* rval = &wxNullBitmap;
2789 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2790 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2791 PyObject* ro;
2792 wxBitmap* ptr;
2793 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2794 if (ro) {
2795 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2796 rval = ptr;
2797 Py_DECREF(ro);
2798 }
2799 }
2800 wxPyEndBlockThreads(blocked);
2801 return *rval;
2802 }
2803
2804 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2805 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2806 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2807 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2808 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2809 Py_DECREF(bo);
2810 }
2811 wxPyEndBlockThreads(blocked);
2812 }
2813
2814 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2815 return new wxCustomDataObject(wxDataFormat(formatName));
2816 }
2817 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2818 bool rval;
2819 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2820 if (PyString_Check(data)) {
2821 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2822 }
2823 else {
2824 // raise a TypeError if not a string
2825 PyErr_SetString(PyExc_TypeError, "String expected.");
2826 rval = false;
2827 }
2828 wxPyEndBlockThreads(blocked);
2829 return rval;
2830 }
2831 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2832 PyObject* obj;
2833 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2834 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2835 wxPyEndBlockThreads(blocked);
2836 return obj;
2837 }
2838
2839 class wxMetafileDataObject : public wxDataObjectSimple
2840 {
2841 public:
2842 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
2843 };
2844
2845
2846 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2847
2848
2849 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2850 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2851 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2852 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2853 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2854
2855
2856 class wxPyTextDropTarget : public wxTextDropTarget {
2857 public:
2858 wxPyTextDropTarget() {}
2859
2860 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2861
2862 DEC_PYCALLBACK__(OnLeave);
2863 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2864 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2865 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2866 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2867
2868 PYPRIVATE;
2869 };
2870
2871 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2872 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2873 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2874 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2875 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2876 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2877
2878
2879
2880 class wxPyFileDropTarget : public wxFileDropTarget {
2881 public:
2882 wxPyFileDropTarget() {}
2883
2884 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2885
2886 DEC_PYCALLBACK__(OnLeave);
2887 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2888 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2889 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2890 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2891
2892 PYPRIVATE;
2893 };
2894
2895 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2896 const wxArrayString& filenames) {
2897 bool rval = false;
2898 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2899 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2900 PyObject* list = wxArrayString2PyList_helper(filenames);
2901 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2902 Py_DECREF(list);
2903 }
2904 wxPyEndBlockThreads(blocked);
2905 return rval;
2906 }
2907
2908
2909
2910 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2911 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2912 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2913 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2914 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2915
2916
2917
2918
2919 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2920
2921 #include <wx/display.h>
2922
2923 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2924 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2925
2926 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2927 #if !wxUSE_DISPLAY
2928 #include <wx/dynarray.h>
2929 #include <wx/vidmode.h>
2930
2931 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2932 #include "wx/arrimpl.cpp"
2933 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2934 const wxVideoMode wxDefaultVideoMode;
2935
2936 class wxDisplay
2937 {
2938 public:
2939 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2940 ~wxDisplay() {}
2941
2942 static size_t GetCount()
2943 { wxPyRaiseNotImplemented(); return 0; }
2944
2945 static int GetFromPoint(const wxPoint& pt)
2946 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2947 static int GetFromWindow(wxWindow *window)
2948 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2949
2950 virtual bool IsOk() const { return false; }
2951 virtual wxRect GetGeometry() const { wxRect r; return r; }
2952 virtual wxString GetName() const { return wxEmptyString; }
2953 bool IsPrimary() const { return false; }
2954
2955 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2956 { wxArrayVideoModes a; return a; }
2957
2958 virtual wxVideoMode GetCurrentMode() const
2959 { return wxDefaultVideoMode; }
2960
2961 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2962 { return false; }
2963
2964 void ResetMode() {}
2965 };
2966 #endif
2967
2968 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2969 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2970 PyObject* pyList = NULL;
2971 wxArrayVideoModes arr = self->GetModes(mode);
2972 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2973 pyList = PyList_New(0);
2974 for (int i=0; i < arr.GetCount(); i++) {
2975 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2976 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2977 PyList_Append(pyList, pyObj);
2978 Py_DECREF(pyObj);
2979 }
2980 wxPyEndBlockThreads(blocked);
2981 return pyList;
2982 }
2983
2984 #include <wx/stdpaths.h>
2985
2986 static wxStandardPaths *StandardPaths_Get(){
2987 return (wxStandardPaths*) &wxStandardPaths::Get();
2988 }
2989 #ifdef __cplusplus
2990 extern "C" {
2991 #endif
2992 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2993 PyObject *resultobj;
2994 wxSystemColour arg1 ;
2995 wxColour result;
2996 PyObject * obj0 = 0 ;
2997 char *kwnames[] = {
2998 (char *) "index", NULL
2999 };
3000
3001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3002 {
3003 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
3004 if (SWIG_arg_fail(1)) SWIG_fail;
3005 }
3006 {
3007 if (!wxPyCheckForApp()) SWIG_fail;
3008 PyThreadState* __tstate = wxPyBeginAllowThreads();
3009 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3010
3011 wxPyEndAllowThreads(__tstate);
3012 if (PyErr_Occurred()) SWIG_fail;
3013 }
3014 {
3015 wxColour * resultptr;
3016 resultptr = new wxColour((wxColour &)(result));
3017 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3018 }
3019 return resultobj;
3020 fail:
3021 return NULL;
3022 }
3023
3024
3025 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3026 PyObject *resultobj;
3027 wxSystemFont arg1 ;
3028 wxFont result;
3029 PyObject * obj0 = 0 ;
3030 char *kwnames[] = {
3031 (char *) "index", NULL
3032 };
3033
3034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3035 {
3036 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3037 if (SWIG_arg_fail(1)) SWIG_fail;
3038 }
3039 {
3040 if (!wxPyCheckForApp()) SWIG_fail;
3041 PyThreadState* __tstate = wxPyBeginAllowThreads();
3042 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3043
3044 wxPyEndAllowThreads(__tstate);
3045 if (PyErr_Occurred()) SWIG_fail;
3046 }
3047 {
3048 wxFont * resultptr;
3049 resultptr = new wxFont((wxFont &)(result));
3050 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3051 }
3052 return resultobj;
3053 fail:
3054 return NULL;
3055 }
3056
3057
3058 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3059 PyObject *resultobj;
3060 wxSystemMetric arg1 ;
3061 wxWindow *arg2 = (wxWindow *) NULL ;
3062 int result;
3063 PyObject * obj0 = 0 ;
3064 PyObject * obj1 = 0 ;
3065 char *kwnames[] = {
3066 (char *) "index",(char *) "win", NULL
3067 };
3068
3069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3070 {
3071 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3072 if (SWIG_arg_fail(1)) SWIG_fail;
3073 }
3074 if (obj1) {
3075 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3076 if (SWIG_arg_fail(2)) SWIG_fail;
3077 }
3078 {
3079 if (!wxPyCheckForApp()) SWIG_fail;
3080 PyThreadState* __tstate = wxPyBeginAllowThreads();
3081 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3082
3083 wxPyEndAllowThreads(__tstate);
3084 if (PyErr_Occurred()) SWIG_fail;
3085 }
3086 {
3087 resultobj = SWIG_From_int((int)(result));
3088 }
3089 return resultobj;
3090 fail:
3091 return NULL;
3092 }
3093
3094
3095 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3096 PyObject *resultobj;
3097 wxSystemFeature arg1 ;
3098 bool result;
3099 PyObject * obj0 = 0 ;
3100 char *kwnames[] = {
3101 (char *) "index", NULL
3102 };
3103
3104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3105 {
3106 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3107 if (SWIG_arg_fail(1)) SWIG_fail;
3108 }
3109 {
3110 if (!wxPyCheckForApp()) SWIG_fail;
3111 PyThreadState* __tstate = wxPyBeginAllowThreads();
3112 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3113
3114 wxPyEndAllowThreads(__tstate);
3115 if (PyErr_Occurred()) SWIG_fail;
3116 }
3117 {
3118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3119 }
3120 return resultobj;
3121 fail:
3122 return NULL;
3123 }
3124
3125
3126 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3127 PyObject *resultobj;
3128 wxSystemScreenType result;
3129 char *kwnames[] = {
3130 NULL
3131 };
3132
3133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3134 {
3135 if (!wxPyCheckForApp()) SWIG_fail;
3136 PyThreadState* __tstate = wxPyBeginAllowThreads();
3137 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3138
3139 wxPyEndAllowThreads(__tstate);
3140 if (PyErr_Occurred()) SWIG_fail;
3141 }
3142 resultobj = SWIG_From_int((result));
3143 return resultobj;
3144 fail:
3145 return NULL;
3146 }
3147
3148
3149 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3150 PyObject *resultobj;
3151 wxSystemScreenType arg1 ;
3152 PyObject * obj0 = 0 ;
3153 char *kwnames[] = {
3154 (char *) "screen", NULL
3155 };
3156
3157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3158 {
3159 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3160 if (SWIG_arg_fail(1)) SWIG_fail;
3161 }
3162 {
3163 if (!wxPyCheckForApp()) SWIG_fail;
3164 PyThreadState* __tstate = wxPyBeginAllowThreads();
3165 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3166
3167 wxPyEndAllowThreads(__tstate);
3168 if (PyErr_Occurred()) SWIG_fail;
3169 }
3170 Py_INCREF(Py_None); resultobj = Py_None;
3171 return resultobj;
3172 fail:
3173 return NULL;
3174 }
3175
3176
3177 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3178 PyObject *obj;
3179 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3180 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3181 Py_INCREF(obj);
3182 return Py_BuildValue((char *)"");
3183 }
3184 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3185 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3186 return 1;
3187 }
3188
3189
3190 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3191 PyObject *pyobj;
3192
3193 {
3194 #if wxUSE_UNICODE
3195 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3196 #else
3197 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3198 #endif
3199 }
3200 return pyobj;
3201 }
3202
3203
3204 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3205 PyObject *resultobj;
3206 wxSystemOptions *result;
3207 char *kwnames[] = {
3208 NULL
3209 };
3210
3211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3212 {
3213 PyThreadState* __tstate = wxPyBeginAllowThreads();
3214 result = (wxSystemOptions *)new wxSystemOptions();
3215
3216 wxPyEndAllowThreads(__tstate);
3217 if (PyErr_Occurred()) SWIG_fail;
3218 }
3219 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3220 return resultobj;
3221 fail:
3222 return NULL;
3223 }
3224
3225
3226 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3227 PyObject *resultobj;
3228 wxString *arg1 = 0 ;
3229 wxString *arg2 = 0 ;
3230 bool temp1 = false ;
3231 bool temp2 = false ;
3232 PyObject * obj0 = 0 ;
3233 PyObject * obj1 = 0 ;
3234 char *kwnames[] = {
3235 (char *) "name",(char *) "value", NULL
3236 };
3237
3238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3239 {
3240 arg1 = wxString_in_helper(obj0);
3241 if (arg1 == NULL) SWIG_fail;
3242 temp1 = true;
3243 }
3244 {
3245 arg2 = wxString_in_helper(obj1);
3246 if (arg2 == NULL) SWIG_fail;
3247 temp2 = true;
3248 }
3249 {
3250 PyThreadState* __tstate = wxPyBeginAllowThreads();
3251 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3252
3253 wxPyEndAllowThreads(__tstate);
3254 if (PyErr_Occurred()) SWIG_fail;
3255 }
3256 Py_INCREF(Py_None); resultobj = Py_None;
3257 {
3258 if (temp1)
3259 delete arg1;
3260 }
3261 {
3262 if (temp2)
3263 delete arg2;
3264 }
3265 return resultobj;
3266 fail:
3267 {
3268 if (temp1)
3269 delete arg1;
3270 }
3271 {
3272 if (temp2)
3273 delete arg2;
3274 }
3275 return NULL;
3276 }
3277
3278
3279 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3280 PyObject *resultobj;
3281 wxString *arg1 = 0 ;
3282 int arg2 ;
3283 bool temp1 = false ;
3284 PyObject * obj0 = 0 ;
3285 PyObject * obj1 = 0 ;
3286 char *kwnames[] = {
3287 (char *) "name",(char *) "value", NULL
3288 };
3289
3290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3291 {
3292 arg1 = wxString_in_helper(obj0);
3293 if (arg1 == NULL) SWIG_fail;
3294 temp1 = true;
3295 }
3296 {
3297 arg2 = (int)(SWIG_As_int(obj1));
3298 if (SWIG_arg_fail(2)) SWIG_fail;
3299 }
3300 {
3301 PyThreadState* __tstate = wxPyBeginAllowThreads();
3302 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3303
3304 wxPyEndAllowThreads(__tstate);
3305 if (PyErr_Occurred()) SWIG_fail;
3306 }
3307 Py_INCREF(Py_None); resultobj = Py_None;
3308 {
3309 if (temp1)
3310 delete arg1;
3311 }
3312 return resultobj;
3313 fail:
3314 {
3315 if (temp1)
3316 delete arg1;
3317 }
3318 return NULL;
3319 }
3320
3321
3322 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3323 PyObject *resultobj;
3324 wxString *arg1 = 0 ;
3325 wxString result;
3326 bool temp1 = false ;
3327 PyObject * obj0 = 0 ;
3328 char *kwnames[] = {
3329 (char *) "name", NULL
3330 };
3331
3332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3333 {
3334 arg1 = wxString_in_helper(obj0);
3335 if (arg1 == NULL) SWIG_fail;
3336 temp1 = true;
3337 }
3338 {
3339 PyThreadState* __tstate = wxPyBeginAllowThreads();
3340 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3341
3342 wxPyEndAllowThreads(__tstate);
3343 if (PyErr_Occurred()) SWIG_fail;
3344 }
3345 {
3346 #if wxUSE_UNICODE
3347 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3348 #else
3349 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3350 #endif
3351 }
3352 {
3353 if (temp1)
3354 delete arg1;
3355 }
3356 return resultobj;
3357 fail:
3358 {
3359 if (temp1)
3360 delete arg1;
3361 }
3362 return NULL;
3363 }
3364
3365
3366 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3367 PyObject *resultobj;
3368 wxString *arg1 = 0 ;
3369 int result;
3370 bool temp1 = false ;
3371 PyObject * obj0 = 0 ;
3372 char *kwnames[] = {
3373 (char *) "name", NULL
3374 };
3375
3376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3377 {
3378 arg1 = wxString_in_helper(obj0);
3379 if (arg1 == NULL) SWIG_fail;
3380 temp1 = true;
3381 }
3382 {
3383 PyThreadState* __tstate = wxPyBeginAllowThreads();
3384 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3385
3386 wxPyEndAllowThreads(__tstate);
3387 if (PyErr_Occurred()) SWIG_fail;
3388 }
3389 {
3390 resultobj = SWIG_From_int((int)(result));
3391 }
3392 {
3393 if (temp1)
3394 delete arg1;
3395 }
3396 return resultobj;
3397 fail:
3398 {
3399 if (temp1)
3400 delete arg1;
3401 }
3402 return NULL;
3403 }
3404
3405
3406 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3407 PyObject *resultobj;
3408 wxString *arg1 = 0 ;
3409 bool result;
3410 bool temp1 = false ;
3411 PyObject * obj0 = 0 ;
3412 char *kwnames[] = {
3413 (char *) "name", NULL
3414 };
3415
3416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3417 {
3418 arg1 = wxString_in_helper(obj0);
3419 if (arg1 == NULL) SWIG_fail;
3420 temp1 = true;
3421 }
3422 {
3423 PyThreadState* __tstate = wxPyBeginAllowThreads();
3424 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3425
3426 wxPyEndAllowThreads(__tstate);
3427 if (PyErr_Occurred()) SWIG_fail;
3428 }
3429 {
3430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3431 }
3432 {
3433 if (temp1)
3434 delete arg1;
3435 }
3436 return resultobj;
3437 fail:
3438 {
3439 if (temp1)
3440 delete arg1;
3441 }
3442 return NULL;
3443 }
3444
3445
3446 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3447 PyObject *resultobj;
3448 wxString *arg1 = 0 ;
3449 bool result;
3450 bool temp1 = false ;
3451 PyObject * obj0 = 0 ;
3452 char *kwnames[] = {
3453 (char *) "name", NULL
3454 };
3455
3456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3457 {
3458 arg1 = wxString_in_helper(obj0);
3459 if (arg1 == NULL) SWIG_fail;
3460 temp1 = true;
3461 }
3462 {
3463 PyThreadState* __tstate = wxPyBeginAllowThreads();
3464 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3465
3466 wxPyEndAllowThreads(__tstate);
3467 if (PyErr_Occurred()) SWIG_fail;
3468 }
3469 {
3470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3471 }
3472 {
3473 if (temp1)
3474 delete arg1;
3475 }
3476 return resultobj;
3477 fail:
3478 {
3479 if (temp1)
3480 delete arg1;
3481 }
3482 return NULL;
3483 }
3484
3485
3486 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3487 PyObject *obj;
3488 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3489 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3490 Py_INCREF(obj);
3491 return Py_BuildValue((char *)"");
3492 }
3493 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3494 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3495 return 1;
3496 }
3497
3498
3499 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3500 PyObject *pyobj;
3501
3502 {
3503 #if wxUSE_UNICODE
3504 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3505 #else
3506 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3507 #endif
3508 }
3509 return pyobj;
3510 }
3511
3512
3513 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3514 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3515 return 1;
3516 }
3517
3518
3519 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3520 PyObject *pyobj;
3521
3522 {
3523 #if wxUSE_UNICODE
3524 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3525 #else
3526 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3527 #endif
3528 }
3529 return pyobj;
3530 }
3531
3532
3533 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3534 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3535 return 1;
3536 }
3537
3538
3539 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3540 PyObject *pyobj;
3541
3542 {
3543 #if wxUSE_UNICODE
3544 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3545 #else
3546 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3547 #endif
3548 }
3549 return pyobj;
3550 }
3551
3552
3553 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3554 PyObject *resultobj;
3555 long result;
3556 char *kwnames[] = {
3557 NULL
3558 };
3559
3560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3561 {
3562 PyThreadState* __tstate = wxPyBeginAllowThreads();
3563 result = (long)wxNewId();
3564
3565 wxPyEndAllowThreads(__tstate);
3566 if (PyErr_Occurred()) SWIG_fail;
3567 }
3568 {
3569 resultobj = SWIG_From_long((long)(result));
3570 }
3571 return resultobj;
3572 fail:
3573 return NULL;
3574 }
3575
3576
3577 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3578 PyObject *resultobj;
3579 long arg1 ;
3580 PyObject * obj0 = 0 ;
3581 char *kwnames[] = {
3582 (char *) "id", NULL
3583 };
3584
3585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3586 {
3587 arg1 = (long)(SWIG_As_long(obj0));
3588 if (SWIG_arg_fail(1)) SWIG_fail;
3589 }
3590 {
3591 PyThreadState* __tstate = wxPyBeginAllowThreads();
3592 wxRegisterId(arg1);
3593
3594 wxPyEndAllowThreads(__tstate);
3595 if (PyErr_Occurred()) SWIG_fail;
3596 }
3597 Py_INCREF(Py_None); resultobj = Py_None;
3598 return resultobj;
3599 fail:
3600 return NULL;
3601 }
3602
3603
3604 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3605 PyObject *resultobj;
3606 long result;
3607 char *kwnames[] = {
3608 NULL
3609 };
3610
3611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3612 {
3613 PyThreadState* __tstate = wxPyBeginAllowThreads();
3614 result = (long)wxGetCurrentId();
3615
3616 wxPyEndAllowThreads(__tstate);
3617 if (PyErr_Occurred()) SWIG_fail;
3618 }
3619 {
3620 resultobj = SWIG_From_long((long)(result));
3621 }
3622 return resultobj;
3623 fail:
3624 return NULL;
3625 }
3626
3627
3628 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3629 PyObject *resultobj;
3630 int arg1 ;
3631 bool result;
3632 PyObject * obj0 = 0 ;
3633 char *kwnames[] = {
3634 (char *) "id", NULL
3635 };
3636
3637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3638 {
3639 arg1 = (int)(SWIG_As_int(obj0));
3640 if (SWIG_arg_fail(1)) SWIG_fail;
3641 }
3642 {
3643 PyThreadState* __tstate = wxPyBeginAllowThreads();
3644 result = (bool)wxIsStockID(arg1);
3645
3646 wxPyEndAllowThreads(__tstate);
3647 if (PyErr_Occurred()) SWIG_fail;
3648 }
3649 {
3650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3651 }
3652 return resultobj;
3653 fail:
3654 return NULL;
3655 }
3656
3657
3658 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3659 PyObject *resultobj;
3660 int arg1 ;
3661 wxString *arg2 = 0 ;
3662 bool result;
3663 bool temp2 = false ;
3664 PyObject * obj0 = 0 ;
3665 PyObject * obj1 = 0 ;
3666 char *kwnames[] = {
3667 (char *) "id",(char *) "label", NULL
3668 };
3669
3670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3671 {
3672 arg1 = (int)(SWIG_As_int(obj0));
3673 if (SWIG_arg_fail(1)) SWIG_fail;
3674 }
3675 {
3676 arg2 = wxString_in_helper(obj1);
3677 if (arg2 == NULL) SWIG_fail;
3678 temp2 = true;
3679 }
3680 {
3681 PyThreadState* __tstate = wxPyBeginAllowThreads();
3682 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3683
3684 wxPyEndAllowThreads(__tstate);
3685 if (PyErr_Occurred()) SWIG_fail;
3686 }
3687 {
3688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3689 }
3690 {
3691 if (temp2)
3692 delete arg2;
3693 }
3694 return resultobj;
3695 fail:
3696 {
3697 if (temp2)
3698 delete arg2;
3699 }
3700 return NULL;
3701 }
3702
3703
3704 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3705 PyObject *resultobj;
3706 int arg1 ;
3707 bool arg2 = (bool) true ;
3708 wxString arg3 = (wxString) wxPyEmptyString ;
3709 wxString result;
3710 PyObject * obj0 = 0 ;
3711 PyObject * obj1 = 0 ;
3712 PyObject * obj2 = 0 ;
3713 char *kwnames[] = {
3714 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3715 };
3716
3717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3718 {
3719 arg1 = (int)(SWIG_As_int(obj0));
3720 if (SWIG_arg_fail(1)) SWIG_fail;
3721 }
3722 if (obj1) {
3723 {
3724 arg2 = (bool)(SWIG_As_bool(obj1));
3725 if (SWIG_arg_fail(2)) SWIG_fail;
3726 }
3727 }
3728 if (obj2) {
3729 {
3730 wxString* sptr = wxString_in_helper(obj2);
3731 if (sptr == NULL) SWIG_fail;
3732 arg3 = *sptr;
3733 delete sptr;
3734 }
3735 }
3736 {
3737 PyThreadState* __tstate = wxPyBeginAllowThreads();
3738 result = wxGetStockLabel(arg1,arg2,arg3);
3739
3740 wxPyEndAllowThreads(__tstate);
3741 if (PyErr_Occurred()) SWIG_fail;
3742 }
3743 {
3744 #if wxUSE_UNICODE
3745 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3746 #else
3747 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3748 #endif
3749 }
3750 return resultobj;
3751 fail:
3752 return NULL;
3753 }
3754
3755
3756 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3757 PyObject *resultobj;
3758 char *kwnames[] = {
3759 NULL
3760 };
3761
3762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3763 {
3764 if (!wxPyCheckForApp()) SWIG_fail;
3765 PyThreadState* __tstate = wxPyBeginAllowThreads();
3766 wxBell();
3767
3768 wxPyEndAllowThreads(__tstate);
3769 if (PyErr_Occurred()) SWIG_fail;
3770 }
3771 Py_INCREF(Py_None); resultobj = Py_None;
3772 return resultobj;
3773 fail:
3774 return NULL;
3775 }
3776
3777
3778 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3779 PyObject *resultobj;
3780 char *kwnames[] = {
3781 NULL
3782 };
3783
3784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3785 {
3786 if (!wxPyCheckForApp()) SWIG_fail;
3787 PyThreadState* __tstate = wxPyBeginAllowThreads();
3788 wxEndBusyCursor();
3789
3790 wxPyEndAllowThreads(__tstate);
3791 if (PyErr_Occurred()) SWIG_fail;
3792 }
3793 Py_INCREF(Py_None); resultobj = Py_None;
3794 return resultobj;
3795 fail:
3796 return NULL;
3797 }
3798
3799
3800 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3801 PyObject *resultobj;
3802 bool arg1 = (bool) true ;
3803 long result;
3804 PyObject * obj0 = 0 ;
3805 char *kwnames[] = {
3806 (char *) "resetTimer", NULL
3807 };
3808
3809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3810 if (obj0) {
3811 {
3812 arg1 = (bool)(SWIG_As_bool(obj0));
3813 if (SWIG_arg_fail(1)) SWIG_fail;
3814 }
3815 }
3816 {
3817 PyThreadState* __tstate = wxPyBeginAllowThreads();
3818 result = (long)wxGetElapsedTime(arg1);
3819
3820 wxPyEndAllowThreads(__tstate);
3821 if (PyErr_Occurred()) SWIG_fail;
3822 }
3823 {
3824 resultobj = SWIG_From_long((long)(result));
3825 }
3826 return resultobj;
3827 fail:
3828 return NULL;
3829 }
3830
3831
3832 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3833 PyObject *resultobj;
3834 int *arg1 = (int *) 0 ;
3835 int *arg2 = (int *) 0 ;
3836 int temp1 ;
3837 int res1 = 0 ;
3838 int temp2 ;
3839 int res2 = 0 ;
3840 char *kwnames[] = {
3841 NULL
3842 };
3843
3844 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3845 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3847 {
3848 if (!wxPyCheckForApp()) SWIG_fail;
3849 PyThreadState* __tstate = wxPyBeginAllowThreads();
3850 wxGetMousePosition(arg1,arg2);
3851
3852 wxPyEndAllowThreads(__tstate);
3853 if (PyErr_Occurred()) SWIG_fail;
3854 }
3855 Py_INCREF(Py_None); resultobj = Py_None;
3856 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3857 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3858 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3859 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3860 return resultobj;
3861 fail:
3862 return NULL;
3863 }
3864
3865
3866 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3867 PyObject *resultobj;
3868 bool result;
3869 char *kwnames[] = {
3870 NULL
3871 };
3872
3873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3874 {
3875 PyThreadState* __tstate = wxPyBeginAllowThreads();
3876 result = (bool)wxIsBusy();
3877
3878 wxPyEndAllowThreads(__tstate);
3879 if (PyErr_Occurred()) SWIG_fail;
3880 }
3881 {
3882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3883 }
3884 return resultobj;
3885 fail:
3886 return NULL;
3887 }
3888
3889
3890 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3891 PyObject *resultobj;
3892 wxString result;
3893 char *kwnames[] = {
3894 NULL
3895 };
3896
3897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3898 {
3899 PyThreadState* __tstate = wxPyBeginAllowThreads();
3900 result = wxNow();
3901
3902 wxPyEndAllowThreads(__tstate);
3903 if (PyErr_Occurred()) SWIG_fail;
3904 }
3905 {
3906 #if wxUSE_UNICODE
3907 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3908 #else
3909 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3910 #endif
3911 }
3912 return resultobj;
3913 fail:
3914 return NULL;
3915 }
3916
3917
3918 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3919 PyObject *resultobj;
3920 wxString const &arg1_defvalue = wxPyEmptyString ;
3921 wxString *arg1 = (wxString *) &arg1_defvalue ;
3922 bool result;
3923 bool temp1 = false ;
3924 PyObject * obj0 = 0 ;
3925 char *kwnames[] = {
3926 (char *) "command", NULL
3927 };
3928
3929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3930 if (obj0) {
3931 {
3932 arg1 = wxString_in_helper(obj0);
3933 if (arg1 == NULL) SWIG_fail;
3934 temp1 = true;
3935 }
3936 }
3937 {
3938 PyThreadState* __tstate = wxPyBeginAllowThreads();
3939 result = (bool)wxShell((wxString const &)*arg1);
3940
3941 wxPyEndAllowThreads(__tstate);
3942 if (PyErr_Occurred()) SWIG_fail;
3943 }
3944 {
3945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3946 }
3947 {
3948 if (temp1)
3949 delete arg1;
3950 }
3951 return resultobj;
3952 fail:
3953 {
3954 if (temp1)
3955 delete arg1;
3956 }
3957 return NULL;
3958 }
3959
3960
3961 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3962 PyObject *resultobj;
3963 char *kwnames[] = {
3964 NULL
3965 };
3966
3967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3968 {
3969 PyThreadState* __tstate = wxPyBeginAllowThreads();
3970 wxStartTimer();
3971
3972 wxPyEndAllowThreads(__tstate);
3973 if (PyErr_Occurred()) SWIG_fail;
3974 }
3975 Py_INCREF(Py_None); resultobj = Py_None;
3976 return resultobj;
3977 fail:
3978 return NULL;
3979 }
3980
3981
3982 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3983 PyObject *resultobj;
3984 int *arg1 = (int *) 0 ;
3985 int *arg2 = (int *) 0 ;
3986 int result;
3987 int temp1 ;
3988 int res1 = 0 ;
3989 int temp2 ;
3990 int res2 = 0 ;
3991 char *kwnames[] = {
3992 NULL
3993 };
3994
3995 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3996 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3998 {
3999 PyThreadState* __tstate = wxPyBeginAllowThreads();
4000 result = (int)wxGetOsVersion(arg1,arg2);
4001
4002 wxPyEndAllowThreads(__tstate);
4003 if (PyErr_Occurred()) SWIG_fail;
4004 }
4005 {
4006 resultobj = SWIG_From_int((int)(result));
4007 }
4008 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4009 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4010 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4011 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4012 return resultobj;
4013 fail:
4014 return NULL;
4015 }
4016
4017
4018 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4019 PyObject *resultobj;
4020 wxString result;
4021 char *kwnames[] = {
4022 NULL
4023 };
4024
4025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4026 {
4027 PyThreadState* __tstate = wxPyBeginAllowThreads();
4028 result = wxGetOsDescription();
4029
4030 wxPyEndAllowThreads(__tstate);
4031 if (PyErr_Occurred()) SWIG_fail;
4032 }
4033 {
4034 #if wxUSE_UNICODE
4035 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4036 #else
4037 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4038 #endif
4039 }
4040 return resultobj;
4041 fail:
4042 return NULL;
4043 }
4044
4045
4046 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4047 PyObject *resultobj;
4048 long result;
4049 char *kwnames[] = {
4050 NULL
4051 };
4052
4053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4054 {
4055 PyThreadState* __tstate = wxPyBeginAllowThreads();
4056 result = (long)wxGetFreeMemory();
4057
4058 wxPyEndAllowThreads(__tstate);
4059 if (PyErr_Occurred()) SWIG_fail;
4060 }
4061 {
4062 resultobj = SWIG_From_long((long)(result));
4063 }
4064 return resultobj;
4065 fail:
4066 return NULL;
4067 }
4068
4069
4070 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4071 PyObject *resultobj;
4072 wxShutdownFlags arg1 ;
4073 bool result;
4074 PyObject * obj0 = 0 ;
4075 char *kwnames[] = {
4076 (char *) "wFlags", NULL
4077 };
4078
4079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4080 {
4081 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4082 if (SWIG_arg_fail(1)) SWIG_fail;
4083 }
4084 {
4085 if (!wxPyCheckForApp()) SWIG_fail;
4086 PyThreadState* __tstate = wxPyBeginAllowThreads();
4087 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4088
4089 wxPyEndAllowThreads(__tstate);
4090 if (PyErr_Occurred()) SWIG_fail;
4091 }
4092 {
4093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4094 }
4095 return resultobj;
4096 fail:
4097 return NULL;
4098 }
4099
4100
4101 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4102 PyObject *resultobj;
4103 int arg1 ;
4104 PyObject * obj0 = 0 ;
4105 char *kwnames[] = {
4106 (char *) "secs", NULL
4107 };
4108
4109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4110 {
4111 arg1 = (int)(SWIG_As_int(obj0));
4112 if (SWIG_arg_fail(1)) SWIG_fail;
4113 }
4114 {
4115 PyThreadState* __tstate = wxPyBeginAllowThreads();
4116 wxSleep(arg1);
4117
4118 wxPyEndAllowThreads(__tstate);
4119 if (PyErr_Occurred()) SWIG_fail;
4120 }
4121 Py_INCREF(Py_None); resultobj = Py_None;
4122 return resultobj;
4123 fail:
4124 return NULL;
4125 }
4126
4127
4128 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4129 PyObject *resultobj;
4130 unsigned long arg1 ;
4131 PyObject * obj0 = 0 ;
4132 char *kwnames[] = {
4133 (char *) "milliseconds", NULL
4134 };
4135
4136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4137 {
4138 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4139 if (SWIG_arg_fail(1)) SWIG_fail;
4140 }
4141 {
4142 PyThreadState* __tstate = wxPyBeginAllowThreads();
4143 wxMilliSleep(arg1);
4144
4145 wxPyEndAllowThreads(__tstate);
4146 if (PyErr_Occurred()) SWIG_fail;
4147 }
4148 Py_INCREF(Py_None); resultobj = Py_None;
4149 return resultobj;
4150 fail:
4151 return NULL;
4152 }
4153
4154
4155 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4156 PyObject *resultobj;
4157 unsigned long arg1 ;
4158 PyObject * obj0 = 0 ;
4159 char *kwnames[] = {
4160 (char *) "microseconds", NULL
4161 };
4162
4163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4164 {
4165 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4166 if (SWIG_arg_fail(1)) SWIG_fail;
4167 }
4168 {
4169 PyThreadState* __tstate = wxPyBeginAllowThreads();
4170 wxMicroSleep(arg1);
4171
4172 wxPyEndAllowThreads(__tstate);
4173 if (PyErr_Occurred()) SWIG_fail;
4174 }
4175 Py_INCREF(Py_None); resultobj = Py_None;
4176 return resultobj;
4177 fail:
4178 return NULL;
4179 }
4180
4181
4182 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4183 PyObject *resultobj;
4184 bool arg1 ;
4185 PyObject * obj0 = 0 ;
4186 char *kwnames[] = {
4187 (char *) "enable", NULL
4188 };
4189
4190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4191 {
4192 arg1 = (bool)(SWIG_As_bool(obj0));
4193 if (SWIG_arg_fail(1)) SWIG_fail;
4194 }
4195 {
4196 PyThreadState* __tstate = wxPyBeginAllowThreads();
4197 wxEnableTopLevelWindows(arg1);
4198
4199 wxPyEndAllowThreads(__tstate);
4200 if (PyErr_Occurred()) SWIG_fail;
4201 }
4202 Py_INCREF(Py_None); resultobj = Py_None;
4203 return resultobj;
4204 fail:
4205 return NULL;
4206 }
4207
4208
4209 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4210 PyObject *resultobj;
4211 wxString *arg1 = 0 ;
4212 wxString result;
4213 bool temp1 = false ;
4214 PyObject * obj0 = 0 ;
4215 char *kwnames[] = {
4216 (char *) "in", NULL
4217 };
4218
4219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4220 {
4221 arg1 = wxString_in_helper(obj0);
4222 if (arg1 == NULL) SWIG_fail;
4223 temp1 = true;
4224 }
4225 {
4226 PyThreadState* __tstate = wxPyBeginAllowThreads();
4227 result = wxStripMenuCodes((wxString const &)*arg1);
4228
4229 wxPyEndAllowThreads(__tstate);
4230 if (PyErr_Occurred()) SWIG_fail;
4231 }
4232 {
4233 #if wxUSE_UNICODE
4234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4235 #else
4236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4237 #endif
4238 }
4239 {
4240 if (temp1)
4241 delete arg1;
4242 }
4243 return resultobj;
4244 fail:
4245 {
4246 if (temp1)
4247 delete arg1;
4248 }
4249 return NULL;
4250 }
4251
4252
4253 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4254 PyObject *resultobj;
4255 wxString result;
4256 char *kwnames[] = {
4257 NULL
4258 };
4259
4260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4261 {
4262 PyThreadState* __tstate = wxPyBeginAllowThreads();
4263 result = wxGetEmailAddress();
4264
4265 wxPyEndAllowThreads(__tstate);
4266 if (PyErr_Occurred()) SWIG_fail;
4267 }
4268 {
4269 #if wxUSE_UNICODE
4270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4271 #else
4272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4273 #endif
4274 }
4275 return resultobj;
4276 fail:
4277 return NULL;
4278 }
4279
4280
4281 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4282 PyObject *resultobj;
4283 wxString result;
4284 char *kwnames[] = {
4285 NULL
4286 };
4287
4288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4289 {
4290 PyThreadState* __tstate = wxPyBeginAllowThreads();
4291 result = wxGetHostName();
4292
4293 wxPyEndAllowThreads(__tstate);
4294 if (PyErr_Occurred()) SWIG_fail;
4295 }
4296 {
4297 #if wxUSE_UNICODE
4298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4299 #else
4300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4301 #endif
4302 }
4303 return resultobj;
4304 fail:
4305 return NULL;
4306 }
4307
4308
4309 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4310 PyObject *resultobj;
4311 wxString result;
4312 char *kwnames[] = {
4313 NULL
4314 };
4315
4316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4317 {
4318 PyThreadState* __tstate = wxPyBeginAllowThreads();
4319 result = wxGetFullHostName();
4320
4321 wxPyEndAllowThreads(__tstate);
4322 if (PyErr_Occurred()) SWIG_fail;
4323 }
4324 {
4325 #if wxUSE_UNICODE
4326 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4327 #else
4328 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4329 #endif
4330 }
4331 return resultobj;
4332 fail:
4333 return NULL;
4334 }
4335
4336
4337 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4338 PyObject *resultobj;
4339 wxString result;
4340 char *kwnames[] = {
4341 NULL
4342 };
4343
4344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4345 {
4346 PyThreadState* __tstate = wxPyBeginAllowThreads();
4347 result = wxGetUserId();
4348
4349 wxPyEndAllowThreads(__tstate);
4350 if (PyErr_Occurred()) SWIG_fail;
4351 }
4352 {
4353 #if wxUSE_UNICODE
4354 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4355 #else
4356 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4357 #endif
4358 }
4359 return resultobj;
4360 fail:
4361 return NULL;
4362 }
4363
4364
4365 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4366 PyObject *resultobj;
4367 wxString result;
4368 char *kwnames[] = {
4369 NULL
4370 };
4371
4372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4373 {
4374 PyThreadState* __tstate = wxPyBeginAllowThreads();
4375 result = wxGetUserName();
4376
4377 wxPyEndAllowThreads(__tstate);
4378 if (PyErr_Occurred()) SWIG_fail;
4379 }
4380 {
4381 #if wxUSE_UNICODE
4382 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4383 #else
4384 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4385 #endif
4386 }
4387 return resultobj;
4388 fail:
4389 return NULL;
4390 }
4391
4392
4393 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4394 PyObject *resultobj;
4395 wxString result;
4396 char *kwnames[] = {
4397 NULL
4398 };
4399
4400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4401 {
4402 PyThreadState* __tstate = wxPyBeginAllowThreads();
4403 result = wxGetHomeDir();
4404
4405 wxPyEndAllowThreads(__tstate);
4406 if (PyErr_Occurred()) SWIG_fail;
4407 }
4408 {
4409 #if wxUSE_UNICODE
4410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4411 #else
4412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4413 #endif
4414 }
4415 return resultobj;
4416 fail:
4417 return NULL;
4418 }
4419
4420
4421 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4422 PyObject *resultobj;
4423 wxString const &arg1_defvalue = wxPyEmptyString ;
4424 wxString *arg1 = (wxString *) &arg1_defvalue ;
4425 wxString result;
4426 bool temp1 = false ;
4427 PyObject * obj0 = 0 ;
4428 char *kwnames[] = {
4429 (char *) "user", NULL
4430 };
4431
4432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4433 if (obj0) {
4434 {
4435 arg1 = wxString_in_helper(obj0);
4436 if (arg1 == NULL) SWIG_fail;
4437 temp1 = true;
4438 }
4439 }
4440 {
4441 PyThreadState* __tstate = wxPyBeginAllowThreads();
4442 result = wxGetUserHome((wxString const &)*arg1);
4443
4444 wxPyEndAllowThreads(__tstate);
4445 if (PyErr_Occurred()) SWIG_fail;
4446 }
4447 {
4448 #if wxUSE_UNICODE
4449 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4450 #else
4451 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4452 #endif
4453 }
4454 {
4455 if (temp1)
4456 delete arg1;
4457 }
4458 return resultobj;
4459 fail:
4460 {
4461 if (temp1)
4462 delete arg1;
4463 }
4464 return NULL;
4465 }
4466
4467
4468 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4469 PyObject *resultobj;
4470 unsigned long result;
4471 char *kwnames[] = {
4472 NULL
4473 };
4474
4475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4476 {
4477 PyThreadState* __tstate = wxPyBeginAllowThreads();
4478 result = (unsigned long)wxGetProcessId();
4479
4480 wxPyEndAllowThreads(__tstate);
4481 if (PyErr_Occurred()) SWIG_fail;
4482 }
4483 {
4484 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4485 }
4486 return resultobj;
4487 fail:
4488 return NULL;
4489 }
4490
4491
4492 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4493 PyObject *resultobj;
4494 char *kwnames[] = {
4495 NULL
4496 };
4497
4498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4499 {
4500 PyThreadState* __tstate = wxPyBeginAllowThreads();
4501 wxTrap();
4502
4503 wxPyEndAllowThreads(__tstate);
4504 if (PyErr_Occurred()) SWIG_fail;
4505 }
4506 Py_INCREF(Py_None); resultobj = Py_None;
4507 return resultobj;
4508 fail:
4509 return NULL;
4510 }
4511
4512
4513 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4514 PyObject *resultobj;
4515 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4516 wxString *arg1 = (wxString *) &arg1_defvalue ;
4517 wxString const &arg2_defvalue = wxPyEmptyString ;
4518 wxString *arg2 = (wxString *) &arg2_defvalue ;
4519 wxString const &arg3_defvalue = wxPyEmptyString ;
4520 wxString *arg3 = (wxString *) &arg3_defvalue ;
4521 wxString const &arg4_defvalue = wxPyEmptyString ;
4522 wxString *arg4 = (wxString *) &arg4_defvalue ;
4523 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4524 wxString *arg5 = (wxString *) &arg5_defvalue ;
4525 int arg6 = (int) 0 ;
4526 wxWindow *arg7 = (wxWindow *) NULL ;
4527 int arg8 = (int) -1 ;
4528 int arg9 = (int) -1 ;
4529 wxString result;
4530 bool temp1 = false ;
4531 bool temp2 = false ;
4532 bool temp3 = false ;
4533 bool temp4 = false ;
4534 bool temp5 = false ;
4535 PyObject * obj0 = 0 ;
4536 PyObject * obj1 = 0 ;
4537 PyObject * obj2 = 0 ;
4538 PyObject * obj3 = 0 ;
4539 PyObject * obj4 = 0 ;
4540 PyObject * obj5 = 0 ;
4541 PyObject * obj6 = 0 ;
4542 PyObject * obj7 = 0 ;
4543 PyObject * obj8 = 0 ;
4544 char *kwnames[] = {
4545 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4546 };
4547
4548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4549 if (obj0) {
4550 {
4551 arg1 = wxString_in_helper(obj0);
4552 if (arg1 == NULL) SWIG_fail;
4553 temp1 = true;
4554 }
4555 }
4556 if (obj1) {
4557 {
4558 arg2 = wxString_in_helper(obj1);
4559 if (arg2 == NULL) SWIG_fail;
4560 temp2 = true;
4561 }
4562 }
4563 if (obj2) {
4564 {
4565 arg3 = wxString_in_helper(obj2);
4566 if (arg3 == NULL) SWIG_fail;
4567 temp3 = true;
4568 }
4569 }
4570 if (obj3) {
4571 {
4572 arg4 = wxString_in_helper(obj3);
4573 if (arg4 == NULL) SWIG_fail;
4574 temp4 = true;
4575 }
4576 }
4577 if (obj4) {
4578 {
4579 arg5 = wxString_in_helper(obj4);
4580 if (arg5 == NULL) SWIG_fail;
4581 temp5 = true;
4582 }
4583 }
4584 if (obj5) {
4585 {
4586 arg6 = (int)(SWIG_As_int(obj5));
4587 if (SWIG_arg_fail(6)) SWIG_fail;
4588 }
4589 }
4590 if (obj6) {
4591 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4592 if (SWIG_arg_fail(7)) SWIG_fail;
4593 }
4594 if (obj7) {
4595 {
4596 arg8 = (int)(SWIG_As_int(obj7));
4597 if (SWIG_arg_fail(8)) SWIG_fail;
4598 }
4599 }
4600 if (obj8) {
4601 {
4602 arg9 = (int)(SWIG_As_int(obj8));
4603 if (SWIG_arg_fail(9)) SWIG_fail;
4604 }
4605 }
4606 {
4607 if (!wxPyCheckForApp()) SWIG_fail;
4608 PyThreadState* __tstate = wxPyBeginAllowThreads();
4609 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4610
4611 wxPyEndAllowThreads(__tstate);
4612 if (PyErr_Occurred()) SWIG_fail;
4613 }
4614 {
4615 #if wxUSE_UNICODE
4616 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4617 #else
4618 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4619 #endif
4620 }
4621 {
4622 if (temp1)
4623 delete arg1;
4624 }
4625 {
4626 if (temp2)
4627 delete arg2;
4628 }
4629 {
4630 if (temp3)
4631 delete arg3;
4632 }
4633 {
4634 if (temp4)
4635 delete arg4;
4636 }
4637 {
4638 if (temp5)
4639 delete arg5;
4640 }
4641 return resultobj;
4642 fail:
4643 {
4644 if (temp1)
4645 delete arg1;
4646 }
4647 {
4648 if (temp2)
4649 delete arg2;
4650 }
4651 {
4652 if (temp3)
4653 delete arg3;
4654 }
4655 {
4656 if (temp4)
4657 delete arg4;
4658 }
4659 {
4660 if (temp5)
4661 delete arg5;
4662 }
4663 return NULL;
4664 }
4665
4666
4667 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4668 PyObject *resultobj;
4669 wxString *arg1 = 0 ;
4670 wxString *arg2 = 0 ;
4671 wxString const &arg3_defvalue = wxPyEmptyString ;
4672 wxString *arg3 = (wxString *) &arg3_defvalue ;
4673 wxWindow *arg4 = (wxWindow *) NULL ;
4674 wxString result;
4675 bool temp1 = false ;
4676 bool temp2 = false ;
4677 bool temp3 = false ;
4678 PyObject * obj0 = 0 ;
4679 PyObject * obj1 = 0 ;
4680 PyObject * obj2 = 0 ;
4681 PyObject * obj3 = 0 ;
4682 char *kwnames[] = {
4683 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4684 };
4685
4686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4687 {
4688 arg1 = wxString_in_helper(obj0);
4689 if (arg1 == NULL) SWIG_fail;
4690 temp1 = true;
4691 }
4692 {
4693 arg2 = wxString_in_helper(obj1);
4694 if (arg2 == NULL) SWIG_fail;
4695 temp2 = true;
4696 }
4697 if (obj2) {
4698 {
4699 arg3 = wxString_in_helper(obj2);
4700 if (arg3 == NULL) SWIG_fail;
4701 temp3 = true;
4702 }
4703 }
4704 if (obj3) {
4705 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4706 if (SWIG_arg_fail(4)) SWIG_fail;
4707 }
4708 {
4709 if (!wxPyCheckForApp()) SWIG_fail;
4710 PyThreadState* __tstate = wxPyBeginAllowThreads();
4711 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4712
4713 wxPyEndAllowThreads(__tstate);
4714 if (PyErr_Occurred()) SWIG_fail;
4715 }
4716 {
4717 #if wxUSE_UNICODE
4718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4719 #else
4720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4721 #endif
4722 }
4723 {
4724 if (temp1)
4725 delete arg1;
4726 }
4727 {
4728 if (temp2)
4729 delete arg2;
4730 }
4731 {
4732 if (temp3)
4733 delete arg3;
4734 }
4735 return resultobj;
4736 fail:
4737 {
4738 if (temp1)
4739 delete arg1;
4740 }
4741 {
4742 if (temp2)
4743 delete arg2;
4744 }
4745 {
4746 if (temp3)
4747 delete arg3;
4748 }
4749 return NULL;
4750 }
4751
4752
4753 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4754 PyObject *resultobj;
4755 wxString *arg1 = 0 ;
4756 wxString *arg2 = 0 ;
4757 wxString const &arg3_defvalue = wxPyEmptyString ;
4758 wxString *arg3 = (wxString *) &arg3_defvalue ;
4759 wxWindow *arg4 = (wxWindow *) NULL ;
4760 wxString result;
4761 bool temp1 = false ;
4762 bool temp2 = false ;
4763 bool temp3 = false ;
4764 PyObject * obj0 = 0 ;
4765 PyObject * obj1 = 0 ;
4766 PyObject * obj2 = 0 ;
4767 PyObject * obj3 = 0 ;
4768 char *kwnames[] = {
4769 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4770 };
4771
4772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4773 {
4774 arg1 = wxString_in_helper(obj0);
4775 if (arg1 == NULL) SWIG_fail;
4776 temp1 = true;
4777 }
4778 {
4779 arg2 = wxString_in_helper(obj1);
4780 if (arg2 == NULL) SWIG_fail;
4781 temp2 = true;
4782 }
4783 if (obj2) {
4784 {
4785 arg3 = wxString_in_helper(obj2);
4786 if (arg3 == NULL) SWIG_fail;
4787 temp3 = true;
4788 }
4789 }
4790 if (obj3) {
4791 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4792 if (SWIG_arg_fail(4)) SWIG_fail;
4793 }
4794 {
4795 if (!wxPyCheckForApp()) SWIG_fail;
4796 PyThreadState* __tstate = wxPyBeginAllowThreads();
4797 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4798
4799 wxPyEndAllowThreads(__tstate);
4800 if (PyErr_Occurred()) SWIG_fail;
4801 }
4802 {
4803 #if wxUSE_UNICODE
4804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4805 #else
4806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4807 #endif
4808 }
4809 {
4810 if (temp1)
4811 delete arg1;
4812 }
4813 {
4814 if (temp2)
4815 delete arg2;
4816 }
4817 {
4818 if (temp3)
4819 delete arg3;
4820 }
4821 return resultobj;
4822 fail:
4823 {
4824 if (temp1)
4825 delete arg1;
4826 }
4827 {
4828 if (temp2)
4829 delete arg2;
4830 }
4831 {
4832 if (temp3)
4833 delete arg3;
4834 }
4835 return NULL;
4836 }
4837
4838
4839 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4840 PyObject *resultobj;
4841 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4842 wxString *arg1 = (wxString *) &arg1_defvalue ;
4843 wxString const &arg2_defvalue = wxPyEmptyString ;
4844 wxString *arg2 = (wxString *) &arg2_defvalue ;
4845 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4846 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4847 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4848 wxWindow *arg5 = (wxWindow *) NULL ;
4849 wxString result;
4850 bool temp1 = false ;
4851 bool temp2 = false ;
4852 wxPoint temp4 ;
4853 PyObject * obj0 = 0 ;
4854 PyObject * obj1 = 0 ;
4855 PyObject * obj2 = 0 ;
4856 PyObject * obj3 = 0 ;
4857 PyObject * obj4 = 0 ;
4858 char *kwnames[] = {
4859 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4860 };
4861
4862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4863 if (obj0) {
4864 {
4865 arg1 = wxString_in_helper(obj0);
4866 if (arg1 == NULL) SWIG_fail;
4867 temp1 = true;
4868 }
4869 }
4870 if (obj1) {
4871 {
4872 arg2 = wxString_in_helper(obj1);
4873 if (arg2 == NULL) SWIG_fail;
4874 temp2 = true;
4875 }
4876 }
4877 if (obj2) {
4878 {
4879 arg3 = (long)(SWIG_As_long(obj2));
4880 if (SWIG_arg_fail(3)) SWIG_fail;
4881 }
4882 }
4883 if (obj3) {
4884 {
4885 arg4 = &temp4;
4886 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4887 }
4888 }
4889 if (obj4) {
4890 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4891 if (SWIG_arg_fail(5)) SWIG_fail;
4892 }
4893 {
4894 if (!wxPyCheckForApp()) SWIG_fail;
4895 PyThreadState* __tstate = wxPyBeginAllowThreads();
4896 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4897
4898 wxPyEndAllowThreads(__tstate);
4899 if (PyErr_Occurred()) SWIG_fail;
4900 }
4901 {
4902 #if wxUSE_UNICODE
4903 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4904 #else
4905 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4906 #endif
4907 }
4908 {
4909 if (temp1)
4910 delete arg1;
4911 }
4912 {
4913 if (temp2)
4914 delete arg2;
4915 }
4916 return resultobj;
4917 fail:
4918 {
4919 if (temp1)
4920 delete arg1;
4921 }
4922 {
4923 if (temp2)
4924 delete arg2;
4925 }
4926 return NULL;
4927 }
4928
4929
4930 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4931 PyObject *resultobj;
4932 wxString *arg1 = 0 ;
4933 wxString const &arg2_defvalue = wxPyEmptyString ;
4934 wxString *arg2 = (wxString *) &arg2_defvalue ;
4935 wxString const &arg3_defvalue = wxPyEmptyString ;
4936 wxString *arg3 = (wxString *) &arg3_defvalue ;
4937 wxWindow *arg4 = (wxWindow *) NULL ;
4938 int arg5 = (int) -1 ;
4939 int arg6 = (int) -1 ;
4940 bool arg7 = (bool) true ;
4941 wxString result;
4942 bool temp1 = false ;
4943 bool temp2 = false ;
4944 bool temp3 = false ;
4945 PyObject * obj0 = 0 ;
4946 PyObject * obj1 = 0 ;
4947 PyObject * obj2 = 0 ;
4948 PyObject * obj3 = 0 ;
4949 PyObject * obj4 = 0 ;
4950 PyObject * obj5 = 0 ;
4951 PyObject * obj6 = 0 ;
4952 char *kwnames[] = {
4953 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4954 };
4955
4956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4957 {
4958 arg1 = wxString_in_helper(obj0);
4959 if (arg1 == NULL) SWIG_fail;
4960 temp1 = true;
4961 }
4962 if (obj1) {
4963 {
4964 arg2 = wxString_in_helper(obj1);
4965 if (arg2 == NULL) SWIG_fail;
4966 temp2 = true;
4967 }
4968 }
4969 if (obj2) {
4970 {
4971 arg3 = wxString_in_helper(obj2);
4972 if (arg3 == NULL) SWIG_fail;
4973 temp3 = true;
4974 }
4975 }
4976 if (obj3) {
4977 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4978 if (SWIG_arg_fail(4)) SWIG_fail;
4979 }
4980 if (obj4) {
4981 {
4982 arg5 = (int)(SWIG_As_int(obj4));
4983 if (SWIG_arg_fail(5)) SWIG_fail;
4984 }
4985 }
4986 if (obj5) {
4987 {
4988 arg6 = (int)(SWIG_As_int(obj5));
4989 if (SWIG_arg_fail(6)) SWIG_fail;
4990 }
4991 }
4992 if (obj6) {
4993 {
4994 arg7 = (bool)(SWIG_As_bool(obj6));
4995 if (SWIG_arg_fail(7)) SWIG_fail;
4996 }
4997 }
4998 {
4999 if (!wxPyCheckForApp()) SWIG_fail;
5000 PyThreadState* __tstate = wxPyBeginAllowThreads();
5001 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
5002
5003 wxPyEndAllowThreads(__tstate);
5004 if (PyErr_Occurred()) SWIG_fail;
5005 }
5006 {
5007 #if wxUSE_UNICODE
5008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5009 #else
5010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5011 #endif
5012 }
5013 {
5014 if (temp1)
5015 delete arg1;
5016 }
5017 {
5018 if (temp2)
5019 delete arg2;
5020 }
5021 {
5022 if (temp3)
5023 delete arg3;
5024 }
5025 return resultobj;
5026 fail:
5027 {
5028 if (temp1)
5029 delete arg1;
5030 }
5031 {
5032 if (temp2)
5033 delete arg2;
5034 }
5035 {
5036 if (temp3)
5037 delete arg3;
5038 }
5039 return NULL;
5040 }
5041
5042
5043 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5044 PyObject *resultobj;
5045 wxString *arg1 = 0 ;
5046 wxString const &arg2_defvalue = wxPyEmptyString ;
5047 wxString *arg2 = (wxString *) &arg2_defvalue ;
5048 wxString const &arg3_defvalue = wxPyEmptyString ;
5049 wxString *arg3 = (wxString *) &arg3_defvalue ;
5050 wxWindow *arg4 = (wxWindow *) NULL ;
5051 wxString result;
5052 bool temp1 = false ;
5053 bool temp2 = false ;
5054 bool temp3 = false ;
5055 PyObject * obj0 = 0 ;
5056 PyObject * obj1 = 0 ;
5057 PyObject * obj2 = 0 ;
5058 PyObject * obj3 = 0 ;
5059 char *kwnames[] = {
5060 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5061 };
5062
5063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5064 {
5065 arg1 = wxString_in_helper(obj0);
5066 if (arg1 == NULL) SWIG_fail;
5067 temp1 = true;
5068 }
5069 if (obj1) {
5070 {
5071 arg2 = wxString_in_helper(obj1);
5072 if (arg2 == NULL) SWIG_fail;
5073 temp2 = true;
5074 }
5075 }
5076 if (obj2) {
5077 {
5078 arg3 = wxString_in_helper(obj2);
5079 if (arg3 == NULL) SWIG_fail;
5080 temp3 = true;
5081 }
5082 }
5083 if (obj3) {
5084 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5085 if (SWIG_arg_fail(4)) SWIG_fail;
5086 }
5087 {
5088 if (!wxPyCheckForApp()) SWIG_fail;
5089 PyThreadState* __tstate = wxPyBeginAllowThreads();
5090 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5091
5092 wxPyEndAllowThreads(__tstate);
5093 if (PyErr_Occurred()) SWIG_fail;
5094 }
5095 {
5096 #if wxUSE_UNICODE
5097 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5098 #else
5099 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5100 #endif
5101 }
5102 {
5103 if (temp1)
5104 delete arg1;
5105 }
5106 {
5107 if (temp2)
5108 delete arg2;
5109 }
5110 {
5111 if (temp3)
5112 delete arg3;
5113 }
5114 return resultobj;
5115 fail:
5116 {
5117 if (temp1)
5118 delete arg1;
5119 }
5120 {
5121 if (temp2)
5122 delete arg2;
5123 }
5124 {
5125 if (temp3)
5126 delete arg3;
5127 }
5128 return NULL;
5129 }
5130
5131
5132 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5133 PyObject *resultobj;
5134 wxString *arg1 = 0 ;
5135 wxString *arg2 = 0 ;
5136 int arg3 ;
5137 wxString *arg4 = (wxString *) 0 ;
5138 wxWindow *arg5 = (wxWindow *) NULL ;
5139 int arg6 = (int) -1 ;
5140 int arg7 = (int) -1 ;
5141 bool arg8 = (bool) true ;
5142 int arg9 = (int) 150 ;
5143 int arg10 = (int) 200 ;
5144 wxString result;
5145 bool temp1 = false ;
5146 bool temp2 = false ;
5147 PyObject * obj0 = 0 ;
5148 PyObject * obj1 = 0 ;
5149 PyObject * obj2 = 0 ;
5150 PyObject * obj3 = 0 ;
5151 PyObject * obj4 = 0 ;
5152 PyObject * obj5 = 0 ;
5153 PyObject * obj6 = 0 ;
5154 PyObject * obj7 = 0 ;
5155 PyObject * obj8 = 0 ;
5156 char *kwnames[] = {
5157 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5158 };
5159
5160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5161 {
5162 arg1 = wxString_in_helper(obj0);
5163 if (arg1 == NULL) SWIG_fail;
5164 temp1 = true;
5165 }
5166 {
5167 arg2 = wxString_in_helper(obj1);
5168 if (arg2 == NULL) SWIG_fail;
5169 temp2 = true;
5170 }
5171 {
5172 arg3 = PyList_Size(obj2);
5173 arg4 = wxString_LIST_helper(obj2);
5174 if (arg4 == NULL) SWIG_fail;
5175 }
5176 if (obj3) {
5177 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5178 if (SWIG_arg_fail(5)) SWIG_fail;
5179 }
5180 if (obj4) {
5181 {
5182 arg6 = (int)(SWIG_As_int(obj4));
5183 if (SWIG_arg_fail(6)) SWIG_fail;
5184 }
5185 }
5186 if (obj5) {
5187 {
5188 arg7 = (int)(SWIG_As_int(obj5));
5189 if (SWIG_arg_fail(7)) SWIG_fail;
5190 }
5191 }
5192 if (obj6) {
5193 {
5194 arg8 = (bool)(SWIG_As_bool(obj6));
5195 if (SWIG_arg_fail(8)) SWIG_fail;
5196 }
5197 }
5198 if (obj7) {
5199 {
5200 arg9 = (int)(SWIG_As_int(obj7));
5201 if (SWIG_arg_fail(9)) SWIG_fail;
5202 }
5203 }
5204 if (obj8) {
5205 {
5206 arg10 = (int)(SWIG_As_int(obj8));
5207 if (SWIG_arg_fail(10)) SWIG_fail;
5208 }
5209 }
5210 {
5211 if (!wxPyCheckForApp()) SWIG_fail;
5212 PyThreadState* __tstate = wxPyBeginAllowThreads();
5213 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5214
5215 wxPyEndAllowThreads(__tstate);
5216 if (PyErr_Occurred()) SWIG_fail;
5217 }
5218 {
5219 #if wxUSE_UNICODE
5220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5221 #else
5222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5223 #endif
5224 }
5225 {
5226 if (temp1)
5227 delete arg1;
5228 }
5229 {
5230 if (temp2)
5231 delete arg2;
5232 }
5233 {
5234 if (arg4) delete [] arg4;
5235 }
5236 return resultobj;
5237 fail:
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 NULL;
5250 }
5251
5252
5253 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5254 PyObject *resultobj;
5255 wxString *arg1 = 0 ;
5256 wxString *arg2 = 0 ;
5257 int arg3 ;
5258 wxString *arg4 = (wxString *) 0 ;
5259 wxWindow *arg5 = (wxWindow *) NULL ;
5260 int arg6 = (int) -1 ;
5261 int arg7 = (int) -1 ;
5262 bool arg8 = (bool) true ;
5263 int arg9 = (int) 150 ;
5264 int arg10 = (int) 200 ;
5265 int result;
5266 bool temp1 = false ;
5267 bool temp2 = false ;
5268 PyObject * obj0 = 0 ;
5269 PyObject * obj1 = 0 ;
5270 PyObject * obj2 = 0 ;
5271 PyObject * obj3 = 0 ;
5272 PyObject * obj4 = 0 ;
5273 PyObject * obj5 = 0 ;
5274 PyObject * obj6 = 0 ;
5275 PyObject * obj7 = 0 ;
5276 PyObject * obj8 = 0 ;
5277 char *kwnames[] = {
5278 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5279 };
5280
5281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5282 {
5283 arg1 = wxString_in_helper(obj0);
5284 if (arg1 == NULL) SWIG_fail;
5285 temp1 = true;
5286 }
5287 {
5288 arg2 = wxString_in_helper(obj1);
5289 if (arg2 == NULL) SWIG_fail;
5290 temp2 = true;
5291 }
5292 {
5293 arg3 = PyList_Size(obj2);
5294 arg4 = wxString_LIST_helper(obj2);
5295 if (arg4 == NULL) SWIG_fail;
5296 }
5297 if (obj3) {
5298 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5299 if (SWIG_arg_fail(5)) SWIG_fail;
5300 }
5301 if (obj4) {
5302 {
5303 arg6 = (int)(SWIG_As_int(obj4));
5304 if (SWIG_arg_fail(6)) SWIG_fail;
5305 }
5306 }
5307 if (obj5) {
5308 {
5309 arg7 = (int)(SWIG_As_int(obj5));
5310 if (SWIG_arg_fail(7)) SWIG_fail;
5311 }
5312 }
5313 if (obj6) {
5314 {
5315 arg8 = (bool)(SWIG_As_bool(obj6));
5316 if (SWIG_arg_fail(8)) SWIG_fail;
5317 }
5318 }
5319 if (obj7) {
5320 {
5321 arg9 = (int)(SWIG_As_int(obj7));
5322 if (SWIG_arg_fail(9)) SWIG_fail;
5323 }
5324 }
5325 if (obj8) {
5326 {
5327 arg10 = (int)(SWIG_As_int(obj8));
5328 if (SWIG_arg_fail(10)) SWIG_fail;
5329 }
5330 }
5331 {
5332 if (!wxPyCheckForApp()) SWIG_fail;
5333 PyThreadState* __tstate = wxPyBeginAllowThreads();
5334 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5335
5336 wxPyEndAllowThreads(__tstate);
5337 if (PyErr_Occurred()) SWIG_fail;
5338 }
5339 {
5340 resultobj = SWIG_From_int((int)(result));
5341 }
5342 {
5343 if (temp1)
5344 delete arg1;
5345 }
5346 {
5347 if (temp2)
5348 delete arg2;
5349 }
5350 {
5351 if (arg4) delete [] arg4;
5352 }
5353 return resultobj;
5354 fail:
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 NULL;
5367 }
5368
5369
5370 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5371 PyObject *resultobj;
5372 wxString *arg1 = 0 ;
5373 wxString const &arg2_defvalue = wxPyEmptyString ;
5374 wxString *arg2 = (wxString *) &arg2_defvalue ;
5375 int arg3 = (int) wxOK|wxCENTRE ;
5376 wxWindow *arg4 = (wxWindow *) NULL ;
5377 int arg5 = (int) -1 ;
5378 int arg6 = (int) -1 ;
5379 int result;
5380 bool temp1 = false ;
5381 bool temp2 = false ;
5382 PyObject * obj0 = 0 ;
5383 PyObject * obj1 = 0 ;
5384 PyObject * obj2 = 0 ;
5385 PyObject * obj3 = 0 ;
5386 PyObject * obj4 = 0 ;
5387 PyObject * obj5 = 0 ;
5388 char *kwnames[] = {
5389 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5390 };
5391
5392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5393 {
5394 arg1 = wxString_in_helper(obj0);
5395 if (arg1 == NULL) SWIG_fail;
5396 temp1 = true;
5397 }
5398 if (obj1) {
5399 {
5400 arg2 = wxString_in_helper(obj1);
5401 if (arg2 == NULL) SWIG_fail;
5402 temp2 = true;
5403 }
5404 }
5405 if (obj2) {
5406 {
5407 arg3 = (int)(SWIG_As_int(obj2));
5408 if (SWIG_arg_fail(3)) SWIG_fail;
5409 }
5410 }
5411 if (obj3) {
5412 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5413 if (SWIG_arg_fail(4)) SWIG_fail;
5414 }
5415 if (obj4) {
5416 {
5417 arg5 = (int)(SWIG_As_int(obj4));
5418 if (SWIG_arg_fail(5)) SWIG_fail;
5419 }
5420 }
5421 if (obj5) {
5422 {
5423 arg6 = (int)(SWIG_As_int(obj5));
5424 if (SWIG_arg_fail(6)) SWIG_fail;
5425 }
5426 }
5427 {
5428 if (!wxPyCheckForApp()) SWIG_fail;
5429 PyThreadState* __tstate = wxPyBeginAllowThreads();
5430 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5431
5432 wxPyEndAllowThreads(__tstate);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 {
5436 resultobj = SWIG_From_int((int)(result));
5437 }
5438 {
5439 if (temp1)
5440 delete arg1;
5441 }
5442 {
5443 if (temp2)
5444 delete arg2;
5445 }
5446 return resultobj;
5447 fail:
5448 {
5449 if (temp1)
5450 delete arg1;
5451 }
5452 {
5453 if (temp2)
5454 delete arg2;
5455 }
5456 return NULL;
5457 }
5458
5459
5460 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5461 PyObject *resultobj;
5462 wxString *arg1 = 0 ;
5463 wxString *arg2 = 0 ;
5464 wxString *arg3 = 0 ;
5465 long arg4 ;
5466 long arg5 = (long) 0 ;
5467 long arg6 = (long) 100 ;
5468 wxWindow *arg7 = (wxWindow *) NULL ;
5469 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5470 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5471 long result;
5472 bool temp1 = false ;
5473 bool temp2 = false ;
5474 bool temp3 = false ;
5475 wxPoint temp8 ;
5476 PyObject * obj0 = 0 ;
5477 PyObject * obj1 = 0 ;
5478 PyObject * obj2 = 0 ;
5479 PyObject * obj3 = 0 ;
5480 PyObject * obj4 = 0 ;
5481 PyObject * obj5 = 0 ;
5482 PyObject * obj6 = 0 ;
5483 PyObject * obj7 = 0 ;
5484 char *kwnames[] = {
5485 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5486 };
5487
5488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5489 {
5490 arg1 = wxString_in_helper(obj0);
5491 if (arg1 == NULL) SWIG_fail;
5492 temp1 = true;
5493 }
5494 {
5495 arg2 = wxString_in_helper(obj1);
5496 if (arg2 == NULL) SWIG_fail;
5497 temp2 = true;
5498 }
5499 {
5500 arg3 = wxString_in_helper(obj2);
5501 if (arg3 == NULL) SWIG_fail;
5502 temp3 = true;
5503 }
5504 {
5505 arg4 = (long)(SWIG_As_long(obj3));
5506 if (SWIG_arg_fail(4)) SWIG_fail;
5507 }
5508 if (obj4) {
5509 {
5510 arg5 = (long)(SWIG_As_long(obj4));
5511 if (SWIG_arg_fail(5)) SWIG_fail;
5512 }
5513 }
5514 if (obj5) {
5515 {
5516 arg6 = (long)(SWIG_As_long(obj5));
5517 if (SWIG_arg_fail(6)) SWIG_fail;
5518 }
5519 }
5520 if (obj6) {
5521 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5522 if (SWIG_arg_fail(7)) SWIG_fail;
5523 }
5524 if (obj7) {
5525 {
5526 arg8 = &temp8;
5527 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5528 }
5529 }
5530 {
5531 if (!wxPyCheckForApp()) SWIG_fail;
5532 PyThreadState* __tstate = wxPyBeginAllowThreads();
5533 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5534
5535 wxPyEndAllowThreads(__tstate);
5536 if (PyErr_Occurred()) SWIG_fail;
5537 }
5538 {
5539 resultobj = SWIG_From_long((long)(result));
5540 }
5541 {
5542 if (temp1)
5543 delete arg1;
5544 }
5545 {
5546 if (temp2)
5547 delete arg2;
5548 }
5549 {
5550 if (temp3)
5551 delete arg3;
5552 }
5553 return resultobj;
5554 fail:
5555 {
5556 if (temp1)
5557 delete arg1;
5558 }
5559 {
5560 if (temp2)
5561 delete arg2;
5562 }
5563 {
5564 if (temp3)
5565 delete arg3;
5566 }
5567 return NULL;
5568 }
5569
5570
5571 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5572 PyObject *resultobj;
5573 bool result;
5574 char *kwnames[] = {
5575 NULL
5576 };
5577
5578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5579 {
5580 if (!wxPyCheckForApp()) SWIG_fail;
5581 PyThreadState* __tstate = wxPyBeginAllowThreads();
5582 result = (bool)wxColourDisplay();
5583
5584 wxPyEndAllowThreads(__tstate);
5585 if (PyErr_Occurred()) SWIG_fail;
5586 }
5587 {
5588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5589 }
5590 return resultobj;
5591 fail:
5592 return NULL;
5593 }
5594
5595
5596 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5597 PyObject *resultobj;
5598 int result;
5599 char *kwnames[] = {
5600 NULL
5601 };
5602
5603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5604 {
5605 if (!wxPyCheckForApp()) SWIG_fail;
5606 PyThreadState* __tstate = wxPyBeginAllowThreads();
5607 result = (int)wxDisplayDepth();
5608
5609 wxPyEndAllowThreads(__tstate);
5610 if (PyErr_Occurred()) SWIG_fail;
5611 }
5612 {
5613 resultobj = SWIG_From_int((int)(result));
5614 }
5615 return resultobj;
5616 fail:
5617 return NULL;
5618 }
5619
5620
5621 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5622 PyObject *resultobj;
5623 int result;
5624 char *kwnames[] = {
5625 NULL
5626 };
5627
5628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5629 {
5630 if (!wxPyCheckForApp()) SWIG_fail;
5631 PyThreadState* __tstate = wxPyBeginAllowThreads();
5632 result = (int)wxGetDisplayDepth();
5633
5634 wxPyEndAllowThreads(__tstate);
5635 if (PyErr_Occurred()) SWIG_fail;
5636 }
5637 {
5638 resultobj = SWIG_From_int((int)(result));
5639 }
5640 return resultobj;
5641 fail:
5642 return NULL;
5643 }
5644
5645
5646 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5647 PyObject *resultobj;
5648 int *arg1 = (int *) 0 ;
5649 int *arg2 = (int *) 0 ;
5650 int temp1 ;
5651 int res1 = 0 ;
5652 int temp2 ;
5653 int res2 = 0 ;
5654 char *kwnames[] = {
5655 NULL
5656 };
5657
5658 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5659 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5661 {
5662 if (!wxPyCheckForApp()) SWIG_fail;
5663 PyThreadState* __tstate = wxPyBeginAllowThreads();
5664 wxDisplaySize(arg1,arg2);
5665
5666 wxPyEndAllowThreads(__tstate);
5667 if (PyErr_Occurred()) SWIG_fail;
5668 }
5669 Py_INCREF(Py_None); resultobj = Py_None;
5670 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5671 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5672 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5673 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5674 return resultobj;
5675 fail:
5676 return NULL;
5677 }
5678
5679
5680 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5681 PyObject *resultobj;
5682 wxSize result;
5683 char *kwnames[] = {
5684 NULL
5685 };
5686
5687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5688 {
5689 if (!wxPyCheckForApp()) SWIG_fail;
5690 PyThreadState* __tstate = wxPyBeginAllowThreads();
5691 result = wxGetDisplaySize();
5692
5693 wxPyEndAllowThreads(__tstate);
5694 if (PyErr_Occurred()) SWIG_fail;
5695 }
5696 {
5697 wxSize * resultptr;
5698 resultptr = new wxSize((wxSize &)(result));
5699 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5700 }
5701 return resultobj;
5702 fail:
5703 return NULL;
5704 }
5705
5706
5707 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5708 PyObject *resultobj;
5709 int *arg1 = (int *) 0 ;
5710 int *arg2 = (int *) 0 ;
5711 int temp1 ;
5712 int res1 = 0 ;
5713 int temp2 ;
5714 int res2 = 0 ;
5715 char *kwnames[] = {
5716 NULL
5717 };
5718
5719 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5720 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5722 {
5723 if (!wxPyCheckForApp()) SWIG_fail;
5724 PyThreadState* __tstate = wxPyBeginAllowThreads();
5725 wxDisplaySizeMM(arg1,arg2);
5726
5727 wxPyEndAllowThreads(__tstate);
5728 if (PyErr_Occurred()) SWIG_fail;
5729 }
5730 Py_INCREF(Py_None); resultobj = Py_None;
5731 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5732 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5733 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5734 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5735 return resultobj;
5736 fail:
5737 return NULL;
5738 }
5739
5740
5741 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5742 PyObject *resultobj;
5743 wxSize result;
5744 char *kwnames[] = {
5745 NULL
5746 };
5747
5748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5749 {
5750 if (!wxPyCheckForApp()) SWIG_fail;
5751 PyThreadState* __tstate = wxPyBeginAllowThreads();
5752 result = wxGetDisplaySizeMM();
5753
5754 wxPyEndAllowThreads(__tstate);
5755 if (PyErr_Occurred()) SWIG_fail;
5756 }
5757 {
5758 wxSize * resultptr;
5759 resultptr = new wxSize((wxSize &)(result));
5760 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5761 }
5762 return resultobj;
5763 fail:
5764 return NULL;
5765 }
5766
5767
5768 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5769 PyObject *resultobj;
5770 int *arg1 = (int *) 0 ;
5771 int *arg2 = (int *) 0 ;
5772 int *arg3 = (int *) 0 ;
5773 int *arg4 = (int *) 0 ;
5774 int temp1 ;
5775 int res1 = 0 ;
5776 int temp2 ;
5777 int res2 = 0 ;
5778 int temp3 ;
5779 int res3 = 0 ;
5780 int temp4 ;
5781 int res4 = 0 ;
5782 char *kwnames[] = {
5783 NULL
5784 };
5785
5786 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5787 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5788 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5789 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5791 {
5792 if (!wxPyCheckForApp()) SWIG_fail;
5793 PyThreadState* __tstate = wxPyBeginAllowThreads();
5794 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5795
5796 wxPyEndAllowThreads(__tstate);
5797 if (PyErr_Occurred()) SWIG_fail;
5798 }
5799 Py_INCREF(Py_None); resultobj = Py_None;
5800 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5801 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5802 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5803 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5804 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5805 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5806 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5807 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5808 return resultobj;
5809 fail:
5810 return NULL;
5811 }
5812
5813
5814 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5815 PyObject *resultobj;
5816 wxRect result;
5817 char *kwnames[] = {
5818 NULL
5819 };
5820
5821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5822 {
5823 if (!wxPyCheckForApp()) SWIG_fail;
5824 PyThreadState* __tstate = wxPyBeginAllowThreads();
5825 result = wxGetClientDisplayRect();
5826
5827 wxPyEndAllowThreads(__tstate);
5828 if (PyErr_Occurred()) SWIG_fail;
5829 }
5830 {
5831 wxRect * resultptr;
5832 resultptr = new wxRect((wxRect &)(result));
5833 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5834 }
5835 return resultobj;
5836 fail:
5837 return NULL;
5838 }
5839
5840
5841 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5842 PyObject *resultobj;
5843 wxCursor *arg1 = 0 ;
5844 PyObject * obj0 = 0 ;
5845 char *kwnames[] = {
5846 (char *) "cursor", NULL
5847 };
5848
5849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5850 {
5851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5852 if (SWIG_arg_fail(1)) SWIG_fail;
5853 if (arg1 == NULL) {
5854 SWIG_null_ref("wxCursor");
5855 }
5856 if (SWIG_arg_fail(1)) SWIG_fail;
5857 }
5858 {
5859 if (!wxPyCheckForApp()) SWIG_fail;
5860 PyThreadState* __tstate = wxPyBeginAllowThreads();
5861 wxSetCursor(*arg1);
5862
5863 wxPyEndAllowThreads(__tstate);
5864 if (PyErr_Occurred()) SWIG_fail;
5865 }
5866 Py_INCREF(Py_None); resultobj = Py_None;
5867 return resultobj;
5868 fail:
5869 return NULL;
5870 }
5871
5872
5873 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5874 PyObject *resultobj;
5875 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5876 PyObject * obj0 = 0 ;
5877 char *kwnames[] = {
5878 (char *) "cursor", NULL
5879 };
5880
5881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5882 if (obj0) {
5883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5884 if (SWIG_arg_fail(1)) SWIG_fail;
5885 }
5886 {
5887 if (!wxPyCheckForApp()) SWIG_fail;
5888 PyThreadState* __tstate = wxPyBeginAllowThreads();
5889 wxBeginBusyCursor(arg1);
5890
5891 wxPyEndAllowThreads(__tstate);
5892 if (PyErr_Occurred()) SWIG_fail;
5893 }
5894 Py_INCREF(Py_None); resultobj = Py_None;
5895 return resultobj;
5896 fail:
5897 return NULL;
5898 }
5899
5900
5901 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5902 PyObject *resultobj;
5903 wxWindow *result;
5904 char *kwnames[] = {
5905 NULL
5906 };
5907
5908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5909 {
5910 if (!wxPyCheckForApp()) SWIG_fail;
5911 PyThreadState* __tstate = wxPyBeginAllowThreads();
5912 result = (wxWindow *)wxGetActiveWindow();
5913
5914 wxPyEndAllowThreads(__tstate);
5915 if (PyErr_Occurred()) SWIG_fail;
5916 }
5917 {
5918 resultobj = wxPyMake_wxObject(result, 0);
5919 }
5920 return resultobj;
5921 fail:
5922 return NULL;
5923 }
5924
5925
5926 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5927 PyObject *resultobj;
5928 wxPoint *arg1 = 0 ;
5929 wxWindow *result;
5930 wxPoint temp1 ;
5931 PyObject * obj0 = 0 ;
5932 char *kwnames[] = {
5933 (char *) "pt", NULL
5934 };
5935
5936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5937 {
5938 arg1 = &temp1;
5939 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5940 }
5941 {
5942 if (!wxPyCheckForApp()) SWIG_fail;
5943 PyThreadState* __tstate = wxPyBeginAllowThreads();
5944 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5945
5946 wxPyEndAllowThreads(__tstate);
5947 if (PyErr_Occurred()) SWIG_fail;
5948 }
5949 {
5950 resultobj = wxPyMake_wxObject(result, 0);
5951 }
5952 return resultobj;
5953 fail:
5954 return NULL;
5955 }
5956
5957
5958 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5959 PyObject *resultobj;
5960 wxPoint *arg1 = 0 ;
5961 wxWindow *result;
5962 wxPoint temp1 ;
5963 PyObject * obj0 = 0 ;
5964 char *kwnames[] = {
5965 (char *) "pt", NULL
5966 };
5967
5968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5969 {
5970 arg1 = &temp1;
5971 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5972 }
5973 {
5974 if (!wxPyCheckForApp()) SWIG_fail;
5975 PyThreadState* __tstate = wxPyBeginAllowThreads();
5976 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5977
5978 wxPyEndAllowThreads(__tstate);
5979 if (PyErr_Occurred()) SWIG_fail;
5980 }
5981 {
5982 resultobj = wxPyMake_wxObject(result, 0);
5983 }
5984 return resultobj;
5985 fail:
5986 return NULL;
5987 }
5988
5989
5990 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5991 PyObject *resultobj;
5992 wxWindow *arg1 = (wxWindow *) 0 ;
5993 wxWindow *result;
5994 PyObject * obj0 = 0 ;
5995 char *kwnames[] = {
5996 (char *) "win", NULL
5997 };
5998
5999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
6000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6001 if (SWIG_arg_fail(1)) SWIG_fail;
6002 {
6003 if (!wxPyCheckForApp()) SWIG_fail;
6004 PyThreadState* __tstate = wxPyBeginAllowThreads();
6005 result = (wxWindow *)wxGetTopLevelParent(arg1);
6006
6007 wxPyEndAllowThreads(__tstate);
6008 if (PyErr_Occurred()) SWIG_fail;
6009 }
6010 {
6011 resultobj = wxPyMake_wxObject(result, 0);
6012 }
6013 return resultobj;
6014 fail:
6015 return NULL;
6016 }
6017
6018
6019 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
6020 PyObject *resultobj;
6021 wxString *arg1 = 0 ;
6022 bool result;
6023 bool temp1 = false ;
6024 PyObject * obj0 = 0 ;
6025 char *kwnames[] = {
6026 (char *) "url", NULL
6027 };
6028
6029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
6030 {
6031 arg1 = wxString_in_helper(obj0);
6032 if (arg1 == NULL) SWIG_fail;
6033 temp1 = true;
6034 }
6035 {
6036 PyThreadState* __tstate = wxPyBeginAllowThreads();
6037 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
6038
6039 wxPyEndAllowThreads(__tstate);
6040 if (PyErr_Occurred()) SWIG_fail;
6041 }
6042 {
6043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6044 }
6045 {
6046 if (temp1)
6047 delete arg1;
6048 }
6049 return resultobj;
6050 fail:
6051 {
6052 if (temp1)
6053 delete arg1;
6054 }
6055 return NULL;
6056 }
6057
6058
6059 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6060 PyObject *resultobj;
6061 wxKeyCode arg1 ;
6062 bool result;
6063 PyObject * obj0 = 0 ;
6064 char *kwnames[] = {
6065 (char *) "key", NULL
6066 };
6067
6068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6069 {
6070 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6071 if (SWIG_arg_fail(1)) SWIG_fail;
6072 }
6073 {
6074 if (!wxPyCheckForApp()) SWIG_fail;
6075 PyThreadState* __tstate = wxPyBeginAllowThreads();
6076 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6077
6078 wxPyEndAllowThreads(__tstate);
6079 if (PyErr_Occurred()) SWIG_fail;
6080 }
6081 {
6082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6083 }
6084 return resultobj;
6085 fail:
6086 return NULL;
6087 }
6088
6089
6090 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6091 PyObject *resultobj;
6092 char *kwnames[] = {
6093 NULL
6094 };
6095
6096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6097 {
6098 if (!wxPyCheckForApp()) SWIG_fail;
6099 PyThreadState* __tstate = wxPyBeginAllowThreads();
6100 wxWakeUpMainThread();
6101
6102 wxPyEndAllowThreads(__tstate);
6103 if (PyErr_Occurred()) SWIG_fail;
6104 }
6105 Py_INCREF(Py_None); resultobj = Py_None;
6106 return resultobj;
6107 fail:
6108 return NULL;
6109 }
6110
6111
6112 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6113 PyObject *resultobj;
6114 char *kwnames[] = {
6115 NULL
6116 };
6117
6118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6119 {
6120 if (!wxPyCheckForApp()) SWIG_fail;
6121 PyThreadState* __tstate = wxPyBeginAllowThreads();
6122 wxMutexGuiEnter();
6123
6124 wxPyEndAllowThreads(__tstate);
6125 if (PyErr_Occurred()) SWIG_fail;
6126 }
6127 Py_INCREF(Py_None); resultobj = Py_None;
6128 return resultobj;
6129 fail:
6130 return NULL;
6131 }
6132
6133
6134 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6135 PyObject *resultobj;
6136 char *kwnames[] = {
6137 NULL
6138 };
6139
6140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6141 {
6142 if (!wxPyCheckForApp()) SWIG_fail;
6143 PyThreadState* __tstate = wxPyBeginAllowThreads();
6144 wxMutexGuiLeave();
6145
6146 wxPyEndAllowThreads(__tstate);
6147 if (PyErr_Occurred()) SWIG_fail;
6148 }
6149 Py_INCREF(Py_None); resultobj = Py_None;
6150 return resultobj;
6151 fail:
6152 return NULL;
6153 }
6154
6155
6156 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6157 PyObject *resultobj;
6158 wxMutexGuiLocker *result;
6159 char *kwnames[] = {
6160 NULL
6161 };
6162
6163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6164 {
6165 if (!wxPyCheckForApp()) SWIG_fail;
6166 PyThreadState* __tstate = wxPyBeginAllowThreads();
6167 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6168
6169 wxPyEndAllowThreads(__tstate);
6170 if (PyErr_Occurred()) SWIG_fail;
6171 }
6172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6173 return resultobj;
6174 fail:
6175 return NULL;
6176 }
6177
6178
6179 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6180 PyObject *resultobj;
6181 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6182 PyObject * obj0 = 0 ;
6183 char *kwnames[] = {
6184 (char *) "self", NULL
6185 };
6186
6187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6189 if (SWIG_arg_fail(1)) SWIG_fail;
6190 {
6191 PyThreadState* __tstate = wxPyBeginAllowThreads();
6192 delete arg1;
6193
6194 wxPyEndAllowThreads(__tstate);
6195 if (PyErr_Occurred()) SWIG_fail;
6196 }
6197 Py_INCREF(Py_None); resultobj = Py_None;
6198 return resultobj;
6199 fail:
6200 return NULL;
6201 }
6202
6203
6204 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6205 PyObject *obj;
6206 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6207 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6208 Py_INCREF(obj);
6209 return Py_BuildValue((char *)"");
6210 }
6211 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6212 PyObject *resultobj;
6213 bool result;
6214 char *kwnames[] = {
6215 NULL
6216 };
6217
6218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6219 {
6220 PyThreadState* __tstate = wxPyBeginAllowThreads();
6221 result = (bool)wxThread_IsMain();
6222
6223 wxPyEndAllowThreads(__tstate);
6224 if (PyErr_Occurred()) SWIG_fail;
6225 }
6226 {
6227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6228 }
6229 return resultobj;
6230 fail:
6231 return NULL;
6232 }
6233
6234
6235 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6236 PyObject *resultobj;
6237 wxString *arg1 = 0 ;
6238 wxToolTip *result;
6239 bool temp1 = false ;
6240 PyObject * obj0 = 0 ;
6241 char *kwnames[] = {
6242 (char *) "tip", NULL
6243 };
6244
6245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6246 {
6247 arg1 = wxString_in_helper(obj0);
6248 if (arg1 == NULL) SWIG_fail;
6249 temp1 = true;
6250 }
6251 {
6252 if (!wxPyCheckForApp()) SWIG_fail;
6253 PyThreadState* __tstate = wxPyBeginAllowThreads();
6254 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6255
6256 wxPyEndAllowThreads(__tstate);
6257 if (PyErr_Occurred()) SWIG_fail;
6258 }
6259 {
6260 resultobj = wxPyMake_wxObject(result, 1);
6261 }
6262 {
6263 if (temp1)
6264 delete arg1;
6265 }
6266 return resultobj;
6267 fail:
6268 {
6269 if (temp1)
6270 delete arg1;
6271 }
6272 return NULL;
6273 }
6274
6275
6276 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6277 PyObject *resultobj;
6278 wxToolTip *arg1 = (wxToolTip *) 0 ;
6279 wxString *arg2 = 0 ;
6280 bool temp2 = false ;
6281 PyObject * obj0 = 0 ;
6282 PyObject * obj1 = 0 ;
6283 char *kwnames[] = {
6284 (char *) "self",(char *) "tip", NULL
6285 };
6286
6287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6289 if (SWIG_arg_fail(1)) SWIG_fail;
6290 {
6291 arg2 = wxString_in_helper(obj1);
6292 if (arg2 == NULL) SWIG_fail;
6293 temp2 = true;
6294 }
6295 {
6296 PyThreadState* __tstate = wxPyBeginAllowThreads();
6297 (arg1)->SetTip((wxString const &)*arg2);
6298
6299 wxPyEndAllowThreads(__tstate);
6300 if (PyErr_Occurred()) SWIG_fail;
6301 }
6302 Py_INCREF(Py_None); resultobj = Py_None;
6303 {
6304 if (temp2)
6305 delete arg2;
6306 }
6307 return resultobj;
6308 fail:
6309 {
6310 if (temp2)
6311 delete arg2;
6312 }
6313 return NULL;
6314 }
6315
6316
6317 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6318 PyObject *resultobj;
6319 wxToolTip *arg1 = (wxToolTip *) 0 ;
6320 wxString result;
6321 PyObject * obj0 = 0 ;
6322 char *kwnames[] = {
6323 (char *) "self", NULL
6324 };
6325
6326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6328 if (SWIG_arg_fail(1)) SWIG_fail;
6329 {
6330 PyThreadState* __tstate = wxPyBeginAllowThreads();
6331 result = (arg1)->GetTip();
6332
6333 wxPyEndAllowThreads(__tstate);
6334 if (PyErr_Occurred()) SWIG_fail;
6335 }
6336 {
6337 #if wxUSE_UNICODE
6338 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6339 #else
6340 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6341 #endif
6342 }
6343 return resultobj;
6344 fail:
6345 return NULL;
6346 }
6347
6348
6349 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6350 PyObject *resultobj;
6351 wxToolTip *arg1 = (wxToolTip *) 0 ;
6352 wxWindow *result;
6353 PyObject * obj0 = 0 ;
6354 char *kwnames[] = {
6355 (char *) "self", NULL
6356 };
6357
6358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6360 if (SWIG_arg_fail(1)) SWIG_fail;
6361 {
6362 PyThreadState* __tstate = wxPyBeginAllowThreads();
6363 result = (wxWindow *)(arg1)->GetWindow();
6364
6365 wxPyEndAllowThreads(__tstate);
6366 if (PyErr_Occurred()) SWIG_fail;
6367 }
6368 {
6369 resultobj = wxPyMake_wxObject(result, 0);
6370 }
6371 return resultobj;
6372 fail:
6373 return NULL;
6374 }
6375
6376
6377 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6378 PyObject *resultobj;
6379 bool arg1 ;
6380 PyObject * obj0 = 0 ;
6381 char *kwnames[] = {
6382 (char *) "flag", NULL
6383 };
6384
6385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6386 {
6387 arg1 = (bool)(SWIG_As_bool(obj0));
6388 if (SWIG_arg_fail(1)) SWIG_fail;
6389 }
6390 {
6391 PyThreadState* __tstate = wxPyBeginAllowThreads();
6392 wxToolTip::Enable(arg1);
6393
6394 wxPyEndAllowThreads(__tstate);
6395 if (PyErr_Occurred()) SWIG_fail;
6396 }
6397 Py_INCREF(Py_None); resultobj = Py_None;
6398 return resultobj;
6399 fail:
6400 return NULL;
6401 }
6402
6403
6404 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6405 PyObject *resultobj;
6406 long arg1 ;
6407 PyObject * obj0 = 0 ;
6408 char *kwnames[] = {
6409 (char *) "milliseconds", NULL
6410 };
6411
6412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6413 {
6414 arg1 = (long)(SWIG_As_long(obj0));
6415 if (SWIG_arg_fail(1)) SWIG_fail;
6416 }
6417 {
6418 PyThreadState* __tstate = wxPyBeginAllowThreads();
6419 wxToolTip::SetDelay(arg1);
6420
6421 wxPyEndAllowThreads(__tstate);
6422 if (PyErr_Occurred()) SWIG_fail;
6423 }
6424 Py_INCREF(Py_None); resultobj = Py_None;
6425 return resultobj;
6426 fail:
6427 return NULL;
6428 }
6429
6430
6431 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6432 PyObject *obj;
6433 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6434 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6435 Py_INCREF(obj);
6436 return Py_BuildValue((char *)"");
6437 }
6438 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6439 PyObject *resultobj;
6440 wxWindow *arg1 = (wxWindow *) 0 ;
6441 wxSize *arg2 = 0 ;
6442 wxCaret *result;
6443 wxSize temp2 ;
6444 PyObject * obj0 = 0 ;
6445 PyObject * obj1 = 0 ;
6446 char *kwnames[] = {
6447 (char *) "window",(char *) "size", NULL
6448 };
6449
6450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6452 if (SWIG_arg_fail(1)) SWIG_fail;
6453 {
6454 arg2 = &temp2;
6455 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6456 }
6457 {
6458 if (!wxPyCheckForApp()) SWIG_fail;
6459 PyThreadState* __tstate = wxPyBeginAllowThreads();
6460 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6461
6462 wxPyEndAllowThreads(__tstate);
6463 if (PyErr_Occurred()) SWIG_fail;
6464 }
6465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6466 return resultobj;
6467 fail:
6468 return NULL;
6469 }
6470
6471
6472 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6473 PyObject *resultobj;
6474 wxCaret *arg1 = (wxCaret *) 0 ;
6475 PyObject * obj0 = 0 ;
6476 char *kwnames[] = {
6477 (char *) "self", NULL
6478 };
6479
6480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6482 if (SWIG_arg_fail(1)) SWIG_fail;
6483 {
6484 PyThreadState* __tstate = wxPyBeginAllowThreads();
6485 wxCaret_Destroy(arg1);
6486
6487 wxPyEndAllowThreads(__tstate);
6488 if (PyErr_Occurred()) SWIG_fail;
6489 }
6490 Py_INCREF(Py_None); resultobj = Py_None;
6491 return resultobj;
6492 fail:
6493 return NULL;
6494 }
6495
6496
6497 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6498 PyObject *resultobj;
6499 wxCaret *arg1 = (wxCaret *) 0 ;
6500 bool result;
6501 PyObject * obj0 = 0 ;
6502 char *kwnames[] = {
6503 (char *) "self", NULL
6504 };
6505
6506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6508 if (SWIG_arg_fail(1)) SWIG_fail;
6509 {
6510 PyThreadState* __tstate = wxPyBeginAllowThreads();
6511 result = (bool)(arg1)->IsOk();
6512
6513 wxPyEndAllowThreads(__tstate);
6514 if (PyErr_Occurred()) SWIG_fail;
6515 }
6516 {
6517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6518 }
6519 return resultobj;
6520 fail:
6521 return NULL;
6522 }
6523
6524
6525 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6526 PyObject *resultobj;
6527 wxCaret *arg1 = (wxCaret *) 0 ;
6528 bool result;
6529 PyObject * obj0 = 0 ;
6530 char *kwnames[] = {
6531 (char *) "self", NULL
6532 };
6533
6534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6536 if (SWIG_arg_fail(1)) SWIG_fail;
6537 {
6538 PyThreadState* __tstate = wxPyBeginAllowThreads();
6539 result = (bool)(arg1)->IsVisible();
6540
6541 wxPyEndAllowThreads(__tstate);
6542 if (PyErr_Occurred()) SWIG_fail;
6543 }
6544 {
6545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6546 }
6547 return resultobj;
6548 fail:
6549 return NULL;
6550 }
6551
6552
6553 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6554 PyObject *resultobj;
6555 wxCaret *arg1 = (wxCaret *) 0 ;
6556 wxPoint result;
6557 PyObject * obj0 = 0 ;
6558 char *kwnames[] = {
6559 (char *) "self", NULL
6560 };
6561
6562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6564 if (SWIG_arg_fail(1)) SWIG_fail;
6565 {
6566 PyThreadState* __tstate = wxPyBeginAllowThreads();
6567 result = (arg1)->GetPosition();
6568
6569 wxPyEndAllowThreads(__tstate);
6570 if (PyErr_Occurred()) SWIG_fail;
6571 }
6572 {
6573 wxPoint * resultptr;
6574 resultptr = new wxPoint((wxPoint &)(result));
6575 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6576 }
6577 return resultobj;
6578 fail:
6579 return NULL;
6580 }
6581
6582
6583 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6584 PyObject *resultobj;
6585 wxCaret *arg1 = (wxCaret *) 0 ;
6586 int *arg2 = (int *) 0 ;
6587 int *arg3 = (int *) 0 ;
6588 int temp2 ;
6589 int res2 = 0 ;
6590 int temp3 ;
6591 int res3 = 0 ;
6592 PyObject * obj0 = 0 ;
6593 char *kwnames[] = {
6594 (char *) "self", NULL
6595 };
6596
6597 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6598 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6601 if (SWIG_arg_fail(1)) SWIG_fail;
6602 {
6603 PyThreadState* __tstate = wxPyBeginAllowThreads();
6604 (arg1)->GetPosition(arg2,arg3);
6605
6606 wxPyEndAllowThreads(__tstate);
6607 if (PyErr_Occurred()) SWIG_fail;
6608 }
6609 Py_INCREF(Py_None); resultobj = Py_None;
6610 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6611 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6612 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6613 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6614 return resultobj;
6615 fail:
6616 return NULL;
6617 }
6618
6619
6620 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6621 PyObject *resultobj;
6622 wxCaret *arg1 = (wxCaret *) 0 ;
6623 wxSize result;
6624 PyObject * obj0 = 0 ;
6625 char *kwnames[] = {
6626 (char *) "self", NULL
6627 };
6628
6629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6631 if (SWIG_arg_fail(1)) SWIG_fail;
6632 {
6633 PyThreadState* __tstate = wxPyBeginAllowThreads();
6634 result = (arg1)->GetSize();
6635
6636 wxPyEndAllowThreads(__tstate);
6637 if (PyErr_Occurred()) SWIG_fail;
6638 }
6639 {
6640 wxSize * resultptr;
6641 resultptr = new wxSize((wxSize &)(result));
6642 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6643 }
6644 return resultobj;
6645 fail:
6646 return NULL;
6647 }
6648
6649
6650 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6651 PyObject *resultobj;
6652 wxCaret *arg1 = (wxCaret *) 0 ;
6653 int *arg2 = (int *) 0 ;
6654 int *arg3 = (int *) 0 ;
6655 int temp2 ;
6656 int res2 = 0 ;
6657 int temp3 ;
6658 int res3 = 0 ;
6659 PyObject * obj0 = 0 ;
6660 char *kwnames[] = {
6661 (char *) "self", NULL
6662 };
6663
6664 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6665 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6668 if (SWIG_arg_fail(1)) SWIG_fail;
6669 {
6670 PyThreadState* __tstate = wxPyBeginAllowThreads();
6671 (arg1)->GetSize(arg2,arg3);
6672
6673 wxPyEndAllowThreads(__tstate);
6674 if (PyErr_Occurred()) SWIG_fail;
6675 }
6676 Py_INCREF(Py_None); resultobj = Py_None;
6677 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6678 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6679 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6680 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6681 return resultobj;
6682 fail:
6683 return NULL;
6684 }
6685
6686
6687 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6688 PyObject *resultobj;
6689 wxCaret *arg1 = (wxCaret *) 0 ;
6690 wxWindow *result;
6691 PyObject * obj0 = 0 ;
6692 char *kwnames[] = {
6693 (char *) "self", NULL
6694 };
6695
6696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6698 if (SWIG_arg_fail(1)) SWIG_fail;
6699 {
6700 PyThreadState* __tstate = wxPyBeginAllowThreads();
6701 result = (wxWindow *)(arg1)->GetWindow();
6702
6703 wxPyEndAllowThreads(__tstate);
6704 if (PyErr_Occurred()) SWIG_fail;
6705 }
6706 {
6707 resultobj = wxPyMake_wxObject(result, 0);
6708 }
6709 return resultobj;
6710 fail:
6711 return NULL;
6712 }
6713
6714
6715 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6716 PyObject *resultobj;
6717 wxCaret *arg1 = (wxCaret *) 0 ;
6718 int arg2 ;
6719 int arg3 ;
6720 PyObject * obj0 = 0 ;
6721 PyObject * obj1 = 0 ;
6722 PyObject * obj2 = 0 ;
6723 char *kwnames[] = {
6724 (char *) "self",(char *) "x",(char *) "y", NULL
6725 };
6726
6727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6729 if (SWIG_arg_fail(1)) SWIG_fail;
6730 {
6731 arg2 = (int)(SWIG_As_int(obj1));
6732 if (SWIG_arg_fail(2)) SWIG_fail;
6733 }
6734 {
6735 arg3 = (int)(SWIG_As_int(obj2));
6736 if (SWIG_arg_fail(3)) SWIG_fail;
6737 }
6738 {
6739 PyThreadState* __tstate = wxPyBeginAllowThreads();
6740 (arg1)->Move(arg2,arg3);
6741
6742 wxPyEndAllowThreads(__tstate);
6743 if (PyErr_Occurred()) SWIG_fail;
6744 }
6745 Py_INCREF(Py_None); resultobj = Py_None;
6746 return resultobj;
6747 fail:
6748 return NULL;
6749 }
6750
6751
6752 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6753 PyObject *resultobj;
6754 wxCaret *arg1 = (wxCaret *) 0 ;
6755 wxPoint *arg2 = 0 ;
6756 wxPoint temp2 ;
6757 PyObject * obj0 = 0 ;
6758 PyObject * obj1 = 0 ;
6759 char *kwnames[] = {
6760 (char *) "self",(char *) "pt", NULL
6761 };
6762
6763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) 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 = &temp2;
6768 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6769 }
6770 {
6771 PyThreadState* __tstate = wxPyBeginAllowThreads();
6772 (arg1)->Move((wxPoint const &)*arg2);
6773
6774 wxPyEndAllowThreads(__tstate);
6775 if (PyErr_Occurred()) SWIG_fail;
6776 }
6777 Py_INCREF(Py_None); resultobj = Py_None;
6778 return resultobj;
6779 fail:
6780 return NULL;
6781 }
6782
6783
6784 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6785 PyObject *resultobj;
6786 wxCaret *arg1 = (wxCaret *) 0 ;
6787 int arg2 ;
6788 int arg3 ;
6789 PyObject * obj0 = 0 ;
6790 PyObject * obj1 = 0 ;
6791 PyObject * obj2 = 0 ;
6792 char *kwnames[] = {
6793 (char *) "self",(char *) "width",(char *) "height", NULL
6794 };
6795
6796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6798 if (SWIG_arg_fail(1)) SWIG_fail;
6799 {
6800 arg2 = (int)(SWIG_As_int(obj1));
6801 if (SWIG_arg_fail(2)) SWIG_fail;
6802 }
6803 {
6804 arg3 = (int)(SWIG_As_int(obj2));
6805 if (SWIG_arg_fail(3)) SWIG_fail;
6806 }
6807 {
6808 PyThreadState* __tstate = wxPyBeginAllowThreads();
6809 (arg1)->SetSize(arg2,arg3);
6810
6811 wxPyEndAllowThreads(__tstate);
6812 if (PyErr_Occurred()) SWIG_fail;
6813 }
6814 Py_INCREF(Py_None); resultobj = Py_None;
6815 return resultobj;
6816 fail:
6817 return NULL;
6818 }
6819
6820
6821 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6822 PyObject *resultobj;
6823 wxCaret *arg1 = (wxCaret *) 0 ;
6824 wxSize *arg2 = 0 ;
6825 wxSize temp2 ;
6826 PyObject * obj0 = 0 ;
6827 PyObject * obj1 = 0 ;
6828 char *kwnames[] = {
6829 (char *) "self",(char *) "size", NULL
6830 };
6831
6832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) 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 = &temp2;
6837 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6838 }
6839 {
6840 PyThreadState* __tstate = wxPyBeginAllowThreads();
6841 (arg1)->SetSize((wxSize const &)*arg2);
6842
6843 wxPyEndAllowThreads(__tstate);
6844 if (PyErr_Occurred()) SWIG_fail;
6845 }
6846 Py_INCREF(Py_None); resultobj = Py_None;
6847 return resultobj;
6848 fail:
6849 return NULL;
6850 }
6851
6852
6853 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6854 PyObject *resultobj;
6855 wxCaret *arg1 = (wxCaret *) 0 ;
6856 int arg2 = (int) true ;
6857 PyObject * obj0 = 0 ;
6858 PyObject * obj1 = 0 ;
6859 char *kwnames[] = {
6860 (char *) "self",(char *) "show", NULL
6861 };
6862
6863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6865 if (SWIG_arg_fail(1)) SWIG_fail;
6866 if (obj1) {
6867 {
6868 arg2 = (int)(SWIG_As_int(obj1));
6869 if (SWIG_arg_fail(2)) SWIG_fail;
6870 }
6871 }
6872 {
6873 PyThreadState* __tstate = wxPyBeginAllowThreads();
6874 (arg1)->Show(arg2);
6875
6876 wxPyEndAllowThreads(__tstate);
6877 if (PyErr_Occurred()) SWIG_fail;
6878 }
6879 Py_INCREF(Py_None); resultobj = Py_None;
6880 return resultobj;
6881 fail:
6882 return NULL;
6883 }
6884
6885
6886 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6887 PyObject *resultobj;
6888 wxCaret *arg1 = (wxCaret *) 0 ;
6889 PyObject * obj0 = 0 ;
6890 char *kwnames[] = {
6891 (char *) "self", NULL
6892 };
6893
6894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6896 if (SWIG_arg_fail(1)) SWIG_fail;
6897 {
6898 PyThreadState* __tstate = wxPyBeginAllowThreads();
6899 (arg1)->Hide();
6900
6901 wxPyEndAllowThreads(__tstate);
6902 if (PyErr_Occurred()) SWIG_fail;
6903 }
6904 Py_INCREF(Py_None); resultobj = Py_None;
6905 return resultobj;
6906 fail:
6907 return NULL;
6908 }
6909
6910
6911 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6912 PyObject *resultobj;
6913 int result;
6914 char *kwnames[] = {
6915 NULL
6916 };
6917
6918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6919 {
6920 PyThreadState* __tstate = wxPyBeginAllowThreads();
6921 result = (int)wxCaret::GetBlinkTime();
6922
6923 wxPyEndAllowThreads(__tstate);
6924 if (PyErr_Occurred()) SWIG_fail;
6925 }
6926 {
6927 resultobj = SWIG_From_int((int)(result));
6928 }
6929 return resultobj;
6930 fail:
6931 return NULL;
6932 }
6933
6934
6935 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6936 PyObject *resultobj;
6937 int arg1 ;
6938 PyObject * obj0 = 0 ;
6939 char *kwnames[] = {
6940 (char *) "milliseconds", NULL
6941 };
6942
6943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6944 {
6945 arg1 = (int)(SWIG_As_int(obj0));
6946 if (SWIG_arg_fail(1)) SWIG_fail;
6947 }
6948 {
6949 PyThreadState* __tstate = wxPyBeginAllowThreads();
6950 wxCaret::SetBlinkTime(arg1);
6951
6952 wxPyEndAllowThreads(__tstate);
6953 if (PyErr_Occurred()) SWIG_fail;
6954 }
6955 Py_INCREF(Py_None); resultobj = Py_None;
6956 return resultobj;
6957 fail:
6958 return NULL;
6959 }
6960
6961
6962 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6963 PyObject *obj;
6964 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6965 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6966 Py_INCREF(obj);
6967 return Py_BuildValue((char *)"");
6968 }
6969 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6970 PyObject *resultobj;
6971 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6972 wxBusyCursor *result;
6973 PyObject * obj0 = 0 ;
6974 char *kwnames[] = {
6975 (char *) "cursor", NULL
6976 };
6977
6978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6979 if (obj0) {
6980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6981 if (SWIG_arg_fail(1)) SWIG_fail;
6982 }
6983 {
6984 if (!wxPyCheckForApp()) SWIG_fail;
6985 PyThreadState* __tstate = wxPyBeginAllowThreads();
6986 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6987
6988 wxPyEndAllowThreads(__tstate);
6989 if (PyErr_Occurred()) SWIG_fail;
6990 }
6991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6992 return resultobj;
6993 fail:
6994 return NULL;
6995 }
6996
6997
6998 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6999 PyObject *resultobj;
7000 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
7001 PyObject * obj0 = 0 ;
7002 char *kwnames[] = {
7003 (char *) "self", NULL
7004 };
7005
7006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
7007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
7008 if (SWIG_arg_fail(1)) SWIG_fail;
7009 {
7010 PyThreadState* __tstate = wxPyBeginAllowThreads();
7011 delete arg1;
7012
7013 wxPyEndAllowThreads(__tstate);
7014 if (PyErr_Occurred()) SWIG_fail;
7015 }
7016 Py_INCREF(Py_None); resultobj = Py_None;
7017 return resultobj;
7018 fail:
7019 return NULL;
7020 }
7021
7022
7023 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
7024 PyObject *obj;
7025 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7026 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
7027 Py_INCREF(obj);
7028 return Py_BuildValue((char *)"");
7029 }
7030 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7031 PyObject *resultobj;
7032 wxWindow *arg1 = (wxWindow *) NULL ;
7033 wxWindowDisabler *result;
7034 PyObject * obj0 = 0 ;
7035 char *kwnames[] = {
7036 (char *) "winToSkip", NULL
7037 };
7038
7039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7040 if (obj0) {
7041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7042 if (SWIG_arg_fail(1)) SWIG_fail;
7043 }
7044 {
7045 if (!wxPyCheckForApp()) SWIG_fail;
7046 PyThreadState* __tstate = wxPyBeginAllowThreads();
7047 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7048
7049 wxPyEndAllowThreads(__tstate);
7050 if (PyErr_Occurred()) SWIG_fail;
7051 }
7052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7053 return resultobj;
7054 fail:
7055 return NULL;
7056 }
7057
7058
7059 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7060 PyObject *resultobj;
7061 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7062 PyObject * obj0 = 0 ;
7063 char *kwnames[] = {
7064 (char *) "self", NULL
7065 };
7066
7067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7069 if (SWIG_arg_fail(1)) SWIG_fail;
7070 {
7071 PyThreadState* __tstate = wxPyBeginAllowThreads();
7072 delete arg1;
7073
7074 wxPyEndAllowThreads(__tstate);
7075 if (PyErr_Occurred()) SWIG_fail;
7076 }
7077 Py_INCREF(Py_None); resultobj = Py_None;
7078 return resultobj;
7079 fail:
7080 return NULL;
7081 }
7082
7083
7084 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7085 PyObject *obj;
7086 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7087 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7088 Py_INCREF(obj);
7089 return Py_BuildValue((char *)"");
7090 }
7091 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7092 PyObject *resultobj;
7093 wxString *arg1 = 0 ;
7094 wxBusyInfo *result;
7095 bool temp1 = false ;
7096 PyObject * obj0 = 0 ;
7097 char *kwnames[] = {
7098 (char *) "message", NULL
7099 };
7100
7101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7102 {
7103 arg1 = wxString_in_helper(obj0);
7104 if (arg1 == NULL) SWIG_fail;
7105 temp1 = true;
7106 }
7107 {
7108 if (!wxPyCheckForApp()) SWIG_fail;
7109 PyThreadState* __tstate = wxPyBeginAllowThreads();
7110 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7111
7112 wxPyEndAllowThreads(__tstate);
7113 if (PyErr_Occurred()) SWIG_fail;
7114 }
7115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7116 {
7117 if (temp1)
7118 delete arg1;
7119 }
7120 return resultobj;
7121 fail:
7122 {
7123 if (temp1)
7124 delete arg1;
7125 }
7126 return NULL;
7127 }
7128
7129
7130 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7131 PyObject *resultobj;
7132 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7133 PyObject * obj0 = 0 ;
7134 char *kwnames[] = {
7135 (char *) "self", NULL
7136 };
7137
7138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7140 if (SWIG_arg_fail(1)) SWIG_fail;
7141 {
7142 PyThreadState* __tstate = wxPyBeginAllowThreads();
7143 delete arg1;
7144
7145 wxPyEndAllowThreads(__tstate);
7146 if (PyErr_Occurred()) SWIG_fail;
7147 }
7148 Py_INCREF(Py_None); resultobj = Py_None;
7149 return resultobj;
7150 fail:
7151 return NULL;
7152 }
7153
7154
7155 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7156 PyObject *obj;
7157 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7158 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7159 Py_INCREF(obj);
7160 return Py_BuildValue((char *)"");
7161 }
7162 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7163 PyObject *resultobj;
7164 wxStopWatch *result;
7165 char *kwnames[] = {
7166 NULL
7167 };
7168
7169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7170 {
7171 PyThreadState* __tstate = wxPyBeginAllowThreads();
7172 result = (wxStopWatch *)new wxStopWatch();
7173
7174 wxPyEndAllowThreads(__tstate);
7175 if (PyErr_Occurred()) SWIG_fail;
7176 }
7177 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7178 return resultobj;
7179 fail:
7180 return NULL;
7181 }
7182
7183
7184 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7185 PyObject *resultobj;
7186 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7187 long arg2 = (long) 0 ;
7188 PyObject * obj0 = 0 ;
7189 PyObject * obj1 = 0 ;
7190 char *kwnames[] = {
7191 (char *) "self",(char *) "t0", NULL
7192 };
7193
7194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7196 if (SWIG_arg_fail(1)) SWIG_fail;
7197 if (obj1) {
7198 {
7199 arg2 = (long)(SWIG_As_long(obj1));
7200 if (SWIG_arg_fail(2)) SWIG_fail;
7201 }
7202 }
7203 {
7204 PyThreadState* __tstate = wxPyBeginAllowThreads();
7205 (arg1)->Start(arg2);
7206
7207 wxPyEndAllowThreads(__tstate);
7208 if (PyErr_Occurred()) SWIG_fail;
7209 }
7210 Py_INCREF(Py_None); resultobj = Py_None;
7211 return resultobj;
7212 fail:
7213 return NULL;
7214 }
7215
7216
7217 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7218 PyObject *resultobj;
7219 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7220 PyObject * obj0 = 0 ;
7221 char *kwnames[] = {
7222 (char *) "self", NULL
7223 };
7224
7225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7227 if (SWIG_arg_fail(1)) SWIG_fail;
7228 {
7229 PyThreadState* __tstate = wxPyBeginAllowThreads();
7230 (arg1)->Pause();
7231
7232 wxPyEndAllowThreads(__tstate);
7233 if (PyErr_Occurred()) SWIG_fail;
7234 }
7235 Py_INCREF(Py_None); resultobj = Py_None;
7236 return resultobj;
7237 fail:
7238 return NULL;
7239 }
7240
7241
7242 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7243 PyObject *resultobj;
7244 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7245 PyObject * obj0 = 0 ;
7246 char *kwnames[] = {
7247 (char *) "self", NULL
7248 };
7249
7250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7252 if (SWIG_arg_fail(1)) SWIG_fail;
7253 {
7254 PyThreadState* __tstate = wxPyBeginAllowThreads();
7255 (arg1)->Resume();
7256
7257 wxPyEndAllowThreads(__tstate);
7258 if (PyErr_Occurred()) SWIG_fail;
7259 }
7260 Py_INCREF(Py_None); resultobj = Py_None;
7261 return resultobj;
7262 fail:
7263 return NULL;
7264 }
7265
7266
7267 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7268 PyObject *resultobj;
7269 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7270 long result;
7271 PyObject * obj0 = 0 ;
7272 char *kwnames[] = {
7273 (char *) "self", NULL
7274 };
7275
7276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7278 if (SWIG_arg_fail(1)) SWIG_fail;
7279 {
7280 PyThreadState* __tstate = wxPyBeginAllowThreads();
7281 result = (long)((wxStopWatch const *)arg1)->Time();
7282
7283 wxPyEndAllowThreads(__tstate);
7284 if (PyErr_Occurred()) SWIG_fail;
7285 }
7286 {
7287 resultobj = SWIG_From_long((long)(result));
7288 }
7289 return resultobj;
7290 fail:
7291 return NULL;
7292 }
7293
7294
7295 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7296 PyObject *obj;
7297 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7298 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7299 Py_INCREF(obj);
7300 return Py_BuildValue((char *)"");
7301 }
7302 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7303 PyObject *resultobj;
7304 int arg1 = (int) 9 ;
7305 int arg2 = (int) wxID_FILE1 ;
7306 wxFileHistory *result;
7307 PyObject * obj0 = 0 ;
7308 PyObject * obj1 = 0 ;
7309 char *kwnames[] = {
7310 (char *) "maxFiles",(char *) "idBase", NULL
7311 };
7312
7313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7314 if (obj0) {
7315 {
7316 arg1 = (int)(SWIG_As_int(obj0));
7317 if (SWIG_arg_fail(1)) SWIG_fail;
7318 }
7319 }
7320 if (obj1) {
7321 {
7322 arg2 = (int)(SWIG_As_int(obj1));
7323 if (SWIG_arg_fail(2)) SWIG_fail;
7324 }
7325 }
7326 {
7327 PyThreadState* __tstate = wxPyBeginAllowThreads();
7328 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7329
7330 wxPyEndAllowThreads(__tstate);
7331 if (PyErr_Occurred()) SWIG_fail;
7332 }
7333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7334 return resultobj;
7335 fail:
7336 return NULL;
7337 }
7338
7339
7340 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7341 PyObject *resultobj;
7342 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7343 PyObject * obj0 = 0 ;
7344 char *kwnames[] = {
7345 (char *) "self", NULL
7346 };
7347
7348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7350 if (SWIG_arg_fail(1)) SWIG_fail;
7351 {
7352 PyThreadState* __tstate = wxPyBeginAllowThreads();
7353 delete arg1;
7354
7355 wxPyEndAllowThreads(__tstate);
7356 if (PyErr_Occurred()) SWIG_fail;
7357 }
7358 Py_INCREF(Py_None); resultobj = Py_None;
7359 return resultobj;
7360 fail:
7361 return NULL;
7362 }
7363
7364
7365 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7366 PyObject *resultobj;
7367 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7368 wxString *arg2 = 0 ;
7369 bool temp2 = false ;
7370 PyObject * obj0 = 0 ;
7371 PyObject * obj1 = 0 ;
7372 char *kwnames[] = {
7373 (char *) "self",(char *) "file", NULL
7374 };
7375
7376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7378 if (SWIG_arg_fail(1)) SWIG_fail;
7379 {
7380 arg2 = wxString_in_helper(obj1);
7381 if (arg2 == NULL) SWIG_fail;
7382 temp2 = true;
7383 }
7384 {
7385 PyThreadState* __tstate = wxPyBeginAllowThreads();
7386 (arg1)->AddFileToHistory((wxString const &)*arg2);
7387
7388 wxPyEndAllowThreads(__tstate);
7389 if (PyErr_Occurred()) SWIG_fail;
7390 }
7391 Py_INCREF(Py_None); resultobj = Py_None;
7392 {
7393 if (temp2)
7394 delete arg2;
7395 }
7396 return resultobj;
7397 fail:
7398 {
7399 if (temp2)
7400 delete arg2;
7401 }
7402 return NULL;
7403 }
7404
7405
7406 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7407 PyObject *resultobj;
7408 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7409 int arg2 ;
7410 PyObject * obj0 = 0 ;
7411 PyObject * obj1 = 0 ;
7412 char *kwnames[] = {
7413 (char *) "self",(char *) "i", NULL
7414 };
7415
7416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7418 if (SWIG_arg_fail(1)) SWIG_fail;
7419 {
7420 arg2 = (int)(SWIG_As_int(obj1));
7421 if (SWIG_arg_fail(2)) SWIG_fail;
7422 }
7423 {
7424 PyThreadState* __tstate = wxPyBeginAllowThreads();
7425 (arg1)->RemoveFileFromHistory(arg2);
7426
7427 wxPyEndAllowThreads(__tstate);
7428 if (PyErr_Occurred()) SWIG_fail;
7429 }
7430 Py_INCREF(Py_None); resultobj = Py_None;
7431 return resultobj;
7432 fail:
7433 return NULL;
7434 }
7435
7436
7437 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7438 PyObject *resultobj;
7439 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7440 int result;
7441 PyObject * obj0 = 0 ;
7442 char *kwnames[] = {
7443 (char *) "self", NULL
7444 };
7445
7446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7448 if (SWIG_arg_fail(1)) SWIG_fail;
7449 {
7450 PyThreadState* __tstate = wxPyBeginAllowThreads();
7451 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7452
7453 wxPyEndAllowThreads(__tstate);
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 {
7457 resultobj = SWIG_From_int((int)(result));
7458 }
7459 return resultobj;
7460 fail:
7461 return NULL;
7462 }
7463
7464
7465 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7466 PyObject *resultobj;
7467 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7468 wxMenu *arg2 = (wxMenu *) 0 ;
7469 PyObject * obj0 = 0 ;
7470 PyObject * obj1 = 0 ;
7471 char *kwnames[] = {
7472 (char *) "self",(char *) "menu", NULL
7473 };
7474
7475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7477 if (SWIG_arg_fail(1)) SWIG_fail;
7478 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7479 if (SWIG_arg_fail(2)) SWIG_fail;
7480 {
7481 PyThreadState* __tstate = wxPyBeginAllowThreads();
7482 (arg1)->UseMenu(arg2);
7483
7484 wxPyEndAllowThreads(__tstate);
7485 if (PyErr_Occurred()) SWIG_fail;
7486 }
7487 Py_INCREF(Py_None); resultobj = Py_None;
7488 return resultobj;
7489 fail:
7490 return NULL;
7491 }
7492
7493
7494 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7495 PyObject *resultobj;
7496 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7497 wxMenu *arg2 = (wxMenu *) 0 ;
7498 PyObject * obj0 = 0 ;
7499 PyObject * obj1 = 0 ;
7500 char *kwnames[] = {
7501 (char *) "self",(char *) "menu", NULL
7502 };
7503
7504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7506 if (SWIG_arg_fail(1)) SWIG_fail;
7507 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7508 if (SWIG_arg_fail(2)) SWIG_fail;
7509 {
7510 PyThreadState* __tstate = wxPyBeginAllowThreads();
7511 (arg1)->RemoveMenu(arg2);
7512
7513 wxPyEndAllowThreads(__tstate);
7514 if (PyErr_Occurred()) SWIG_fail;
7515 }
7516 Py_INCREF(Py_None); resultobj = Py_None;
7517 return resultobj;
7518 fail:
7519 return NULL;
7520 }
7521
7522
7523 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7524 PyObject *resultobj;
7525 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7526 wxConfigBase *arg2 = 0 ;
7527 PyObject * obj0 = 0 ;
7528 PyObject * obj1 = 0 ;
7529 char *kwnames[] = {
7530 (char *) "self",(char *) "config", NULL
7531 };
7532
7533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7535 if (SWIG_arg_fail(1)) SWIG_fail;
7536 {
7537 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7538 if (SWIG_arg_fail(2)) SWIG_fail;
7539 if (arg2 == NULL) {
7540 SWIG_null_ref("wxConfigBase");
7541 }
7542 if (SWIG_arg_fail(2)) SWIG_fail;
7543 }
7544 {
7545 PyThreadState* __tstate = wxPyBeginAllowThreads();
7546 (arg1)->Load(*arg2);
7547
7548 wxPyEndAllowThreads(__tstate);
7549 if (PyErr_Occurred()) SWIG_fail;
7550 }
7551 Py_INCREF(Py_None); resultobj = Py_None;
7552 return resultobj;
7553 fail:
7554 return NULL;
7555 }
7556
7557
7558 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7559 PyObject *resultobj;
7560 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7561 wxConfigBase *arg2 = 0 ;
7562 PyObject * obj0 = 0 ;
7563 PyObject * obj1 = 0 ;
7564 char *kwnames[] = {
7565 (char *) "self",(char *) "config", NULL
7566 };
7567
7568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7570 if (SWIG_arg_fail(1)) SWIG_fail;
7571 {
7572 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7573 if (SWIG_arg_fail(2)) SWIG_fail;
7574 if (arg2 == NULL) {
7575 SWIG_null_ref("wxConfigBase");
7576 }
7577 if (SWIG_arg_fail(2)) SWIG_fail;
7578 }
7579 {
7580 PyThreadState* __tstate = wxPyBeginAllowThreads();
7581 (arg1)->Save(*arg2);
7582
7583 wxPyEndAllowThreads(__tstate);
7584 if (PyErr_Occurred()) SWIG_fail;
7585 }
7586 Py_INCREF(Py_None); resultobj = Py_None;
7587 return resultobj;
7588 fail:
7589 return NULL;
7590 }
7591
7592
7593 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7594 PyObject *resultobj;
7595 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7596 PyObject * obj0 = 0 ;
7597 char *kwnames[] = {
7598 (char *) "self", NULL
7599 };
7600
7601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7603 if (SWIG_arg_fail(1)) SWIG_fail;
7604 {
7605 PyThreadState* __tstate = wxPyBeginAllowThreads();
7606 (arg1)->AddFilesToMenu();
7607
7608 wxPyEndAllowThreads(__tstate);
7609 if (PyErr_Occurred()) SWIG_fail;
7610 }
7611 Py_INCREF(Py_None); resultobj = Py_None;
7612 return resultobj;
7613 fail:
7614 return NULL;
7615 }
7616
7617
7618 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7619 PyObject *resultobj;
7620 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7621 wxMenu *arg2 = (wxMenu *) 0 ;
7622 PyObject * obj0 = 0 ;
7623 PyObject * obj1 = 0 ;
7624 char *kwnames[] = {
7625 (char *) "self",(char *) "menu", NULL
7626 };
7627
7628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7630 if (SWIG_arg_fail(1)) SWIG_fail;
7631 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7632 if (SWIG_arg_fail(2)) SWIG_fail;
7633 {
7634 PyThreadState* __tstate = wxPyBeginAllowThreads();
7635 (arg1)->AddFilesToMenu(arg2);
7636
7637 wxPyEndAllowThreads(__tstate);
7638 if (PyErr_Occurred()) SWIG_fail;
7639 }
7640 Py_INCREF(Py_None); resultobj = Py_None;
7641 return resultobj;
7642 fail:
7643 return NULL;
7644 }
7645
7646
7647 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7648 PyObject *resultobj;
7649 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7650 int arg2 ;
7651 wxString result;
7652 PyObject * obj0 = 0 ;
7653 PyObject * obj1 = 0 ;
7654 char *kwnames[] = {
7655 (char *) "self",(char *) "i", NULL
7656 };
7657
7658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7660 if (SWIG_arg_fail(1)) SWIG_fail;
7661 {
7662 arg2 = (int)(SWIG_As_int(obj1));
7663 if (SWIG_arg_fail(2)) SWIG_fail;
7664 }
7665 {
7666 PyThreadState* __tstate = wxPyBeginAllowThreads();
7667 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7668
7669 wxPyEndAllowThreads(__tstate);
7670 if (PyErr_Occurred()) SWIG_fail;
7671 }
7672 {
7673 #if wxUSE_UNICODE
7674 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7675 #else
7676 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7677 #endif
7678 }
7679 return resultobj;
7680 fail:
7681 return NULL;
7682 }
7683
7684
7685 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7686 PyObject *resultobj;
7687 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7688 int result;
7689 PyObject * obj0 = 0 ;
7690 char *kwnames[] = {
7691 (char *) "self", NULL
7692 };
7693
7694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
7699 result = (int)((wxFileHistory const *)arg1)->GetCount();
7700
7701 wxPyEndAllowThreads(__tstate);
7702 if (PyErr_Occurred()) SWIG_fail;
7703 }
7704 {
7705 resultobj = SWIG_From_int((int)(result));
7706 }
7707 return resultobj;
7708 fail:
7709 return NULL;
7710 }
7711
7712
7713 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7714 PyObject *obj;
7715 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7716 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7717 Py_INCREF(obj);
7718 return Py_BuildValue((char *)"");
7719 }
7720 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7721 PyObject *resultobj;
7722 wxString *arg1 = 0 ;
7723 wxString const &arg2_defvalue = wxPyEmptyString ;
7724 wxString *arg2 = (wxString *) &arg2_defvalue ;
7725 wxSingleInstanceChecker *result;
7726 bool temp1 = false ;
7727 bool temp2 = false ;
7728 PyObject * obj0 = 0 ;
7729 PyObject * obj1 = 0 ;
7730 char *kwnames[] = {
7731 (char *) "name",(char *) "path", NULL
7732 };
7733
7734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7735 {
7736 arg1 = wxString_in_helper(obj0);
7737 if (arg1 == NULL) SWIG_fail;
7738 temp1 = true;
7739 }
7740 if (obj1) {
7741 {
7742 arg2 = wxString_in_helper(obj1);
7743 if (arg2 == NULL) SWIG_fail;
7744 temp2 = true;
7745 }
7746 }
7747 {
7748 PyThreadState* __tstate = wxPyBeginAllowThreads();
7749 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7750
7751 wxPyEndAllowThreads(__tstate);
7752 if (PyErr_Occurred()) SWIG_fail;
7753 }
7754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7755 {
7756 if (temp1)
7757 delete arg1;
7758 }
7759 {
7760 if (temp2)
7761 delete arg2;
7762 }
7763 return resultobj;
7764 fail:
7765 {
7766 if (temp1)
7767 delete arg1;
7768 }
7769 {
7770 if (temp2)
7771 delete arg2;
7772 }
7773 return NULL;
7774 }
7775
7776
7777 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7778 PyObject *resultobj;
7779 wxSingleInstanceChecker *result;
7780 char *kwnames[] = {
7781 NULL
7782 };
7783
7784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7785 {
7786 PyThreadState* __tstate = wxPyBeginAllowThreads();
7787 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7788
7789 wxPyEndAllowThreads(__tstate);
7790 if (PyErr_Occurred()) SWIG_fail;
7791 }
7792 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7793 return resultobj;
7794 fail:
7795 return NULL;
7796 }
7797
7798
7799 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7800 PyObject *resultobj;
7801 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7802 PyObject * obj0 = 0 ;
7803 char *kwnames[] = {
7804 (char *) "self", NULL
7805 };
7806
7807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7809 if (SWIG_arg_fail(1)) SWIG_fail;
7810 {
7811 PyThreadState* __tstate = wxPyBeginAllowThreads();
7812 delete arg1;
7813
7814 wxPyEndAllowThreads(__tstate);
7815 if (PyErr_Occurred()) SWIG_fail;
7816 }
7817 Py_INCREF(Py_None); resultobj = Py_None;
7818 return resultobj;
7819 fail:
7820 return NULL;
7821 }
7822
7823
7824 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7825 PyObject *resultobj;
7826 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7827 wxString *arg2 = 0 ;
7828 wxString const &arg3_defvalue = wxPyEmptyString ;
7829 wxString *arg3 = (wxString *) &arg3_defvalue ;
7830 bool result;
7831 bool temp2 = false ;
7832 bool temp3 = false ;
7833 PyObject * obj0 = 0 ;
7834 PyObject * obj1 = 0 ;
7835 PyObject * obj2 = 0 ;
7836 char *kwnames[] = {
7837 (char *) "self",(char *) "name",(char *) "path", NULL
7838 };
7839
7840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7842 if (SWIG_arg_fail(1)) SWIG_fail;
7843 {
7844 arg2 = wxString_in_helper(obj1);
7845 if (arg2 == NULL) SWIG_fail;
7846 temp2 = true;
7847 }
7848 if (obj2) {
7849 {
7850 arg3 = wxString_in_helper(obj2);
7851 if (arg3 == NULL) SWIG_fail;
7852 temp3 = true;
7853 }
7854 }
7855 {
7856 PyThreadState* __tstate = wxPyBeginAllowThreads();
7857 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7858
7859 wxPyEndAllowThreads(__tstate);
7860 if (PyErr_Occurred()) SWIG_fail;
7861 }
7862 {
7863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7864 }
7865 {
7866 if (temp2)
7867 delete arg2;
7868 }
7869 {
7870 if (temp3)
7871 delete arg3;
7872 }
7873 return resultobj;
7874 fail:
7875 {
7876 if (temp2)
7877 delete arg2;
7878 }
7879 {
7880 if (temp3)
7881 delete arg3;
7882 }
7883 return NULL;
7884 }
7885
7886
7887 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7888 PyObject *resultobj;
7889 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7890 bool result;
7891 PyObject * obj0 = 0 ;
7892 char *kwnames[] = {
7893 (char *) "self", NULL
7894 };
7895
7896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7898 if (SWIG_arg_fail(1)) SWIG_fail;
7899 {
7900 PyThreadState* __tstate = wxPyBeginAllowThreads();
7901 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7902
7903 wxPyEndAllowThreads(__tstate);
7904 if (PyErr_Occurred()) SWIG_fail;
7905 }
7906 {
7907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7908 }
7909 return resultobj;
7910 fail:
7911 return NULL;
7912 }
7913
7914
7915 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7916 PyObject *obj;
7917 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7918 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7919 Py_INCREF(obj);
7920 return Py_BuildValue((char *)"");
7921 }
7922 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7923 PyObject *resultobj;
7924 wxWindow *arg1 = (wxWindow *) 0 ;
7925 wxDC *arg2 = 0 ;
7926 bool result;
7927 PyObject * obj0 = 0 ;
7928 PyObject * obj1 = 0 ;
7929 char *kwnames[] = {
7930 (char *) "window",(char *) "dc", NULL
7931 };
7932
7933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7935 if (SWIG_arg_fail(1)) SWIG_fail;
7936 {
7937 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7938 if (SWIG_arg_fail(2)) SWIG_fail;
7939 if (arg2 == NULL) {
7940 SWIG_null_ref("wxDC");
7941 }
7942 if (SWIG_arg_fail(2)) SWIG_fail;
7943 }
7944 {
7945 PyThreadState* __tstate = wxPyBeginAllowThreads();
7946 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7947
7948 wxPyEndAllowThreads(__tstate);
7949 if (PyErr_Occurred()) SWIG_fail;
7950 }
7951 {
7952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7953 }
7954 return resultobj;
7955 fail:
7956 return NULL;
7957 }
7958
7959
7960 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7961 PyObject *resultobj;
7962 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7963 PyObject * obj0 = 0 ;
7964 char *kwnames[] = {
7965 (char *) "self", NULL
7966 };
7967
7968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7970 if (SWIG_arg_fail(1)) SWIG_fail;
7971 {
7972 PyThreadState* __tstate = wxPyBeginAllowThreads();
7973 delete arg1;
7974
7975 wxPyEndAllowThreads(__tstate);
7976 if (PyErr_Occurred()) SWIG_fail;
7977 }
7978 Py_INCREF(Py_None); resultobj = Py_None;
7979 return resultobj;
7980 fail:
7981 return NULL;
7982 }
7983
7984
7985 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7986 PyObject *resultobj;
7987 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7988 wxString result;
7989 PyObject * obj0 = 0 ;
7990 char *kwnames[] = {
7991 (char *) "self", NULL
7992 };
7993
7994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7996 if (SWIG_arg_fail(1)) SWIG_fail;
7997 {
7998 PyThreadState* __tstate = wxPyBeginAllowThreads();
7999 result = (arg1)->GetTip();
8000
8001 wxPyEndAllowThreads(__tstate);
8002 if (PyErr_Occurred()) SWIG_fail;
8003 }
8004 {
8005 #if wxUSE_UNICODE
8006 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8007 #else
8008 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8009 #endif
8010 }
8011 return resultobj;
8012 fail:
8013 return NULL;
8014 }
8015
8016
8017 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
8018 PyObject *resultobj;
8019 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8020 size_t result;
8021 PyObject * obj0 = 0 ;
8022 char *kwnames[] = {
8023 (char *) "self", NULL
8024 };
8025
8026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
8027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8028 if (SWIG_arg_fail(1)) SWIG_fail;
8029 {
8030 PyThreadState* __tstate = wxPyBeginAllowThreads();
8031 result = (size_t)(arg1)->GetCurrentTip();
8032
8033 wxPyEndAllowThreads(__tstate);
8034 if (PyErr_Occurred()) SWIG_fail;
8035 }
8036 {
8037 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8038 }
8039 return resultobj;
8040 fail:
8041 return NULL;
8042 }
8043
8044
8045 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8046 PyObject *resultobj;
8047 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8048 wxString *arg2 = 0 ;
8049 wxString result;
8050 bool temp2 = false ;
8051 PyObject * obj0 = 0 ;
8052 PyObject * obj1 = 0 ;
8053 char *kwnames[] = {
8054 (char *) "self",(char *) "tip", NULL
8055 };
8056
8057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8059 if (SWIG_arg_fail(1)) SWIG_fail;
8060 {
8061 arg2 = wxString_in_helper(obj1);
8062 if (arg2 == NULL) SWIG_fail;
8063 temp2 = true;
8064 }
8065 {
8066 PyThreadState* __tstate = wxPyBeginAllowThreads();
8067 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8068
8069 wxPyEndAllowThreads(__tstate);
8070 if (PyErr_Occurred()) SWIG_fail;
8071 }
8072 {
8073 #if wxUSE_UNICODE
8074 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8075 #else
8076 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8077 #endif
8078 }
8079 {
8080 if (temp2)
8081 delete arg2;
8082 }
8083 return resultobj;
8084 fail:
8085 {
8086 if (temp2)
8087 delete arg2;
8088 }
8089 return NULL;
8090 }
8091
8092
8093 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8094 PyObject *obj;
8095 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8096 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8097 Py_INCREF(obj);
8098 return Py_BuildValue((char *)"");
8099 }
8100 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8101 PyObject *resultobj;
8102 size_t arg1 ;
8103 wxPyTipProvider *result;
8104 PyObject * obj0 = 0 ;
8105 char *kwnames[] = {
8106 (char *) "currentTip", NULL
8107 };
8108
8109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8110 {
8111 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8112 if (SWIG_arg_fail(1)) SWIG_fail;
8113 }
8114 {
8115 PyThreadState* __tstate = wxPyBeginAllowThreads();
8116 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8117
8118 wxPyEndAllowThreads(__tstate);
8119 if (PyErr_Occurred()) SWIG_fail;
8120 }
8121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8122 return resultobj;
8123 fail:
8124 return NULL;
8125 }
8126
8127
8128 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8129 PyObject *resultobj;
8130 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8131 PyObject *arg2 = (PyObject *) 0 ;
8132 PyObject *arg3 = (PyObject *) 0 ;
8133 PyObject * obj0 = 0 ;
8134 PyObject * obj1 = 0 ;
8135 PyObject * obj2 = 0 ;
8136 char *kwnames[] = {
8137 (char *) "self",(char *) "self",(char *) "_class", NULL
8138 };
8139
8140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8142 if (SWIG_arg_fail(1)) SWIG_fail;
8143 arg2 = obj1;
8144 arg3 = obj2;
8145 {
8146 PyThreadState* __tstate = wxPyBeginAllowThreads();
8147 (arg1)->_setCallbackInfo(arg2,arg3);
8148
8149 wxPyEndAllowThreads(__tstate);
8150 if (PyErr_Occurred()) SWIG_fail;
8151 }
8152 Py_INCREF(Py_None); resultobj = Py_None;
8153 return resultobj;
8154 fail:
8155 return NULL;
8156 }
8157
8158
8159 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8160 PyObject *obj;
8161 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8162 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8163 Py_INCREF(obj);
8164 return Py_BuildValue((char *)"");
8165 }
8166 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8167 PyObject *resultobj;
8168 wxWindow *arg1 = (wxWindow *) 0 ;
8169 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8170 bool arg3 = (bool) true ;
8171 bool result;
8172 PyObject * obj0 = 0 ;
8173 PyObject * obj1 = 0 ;
8174 PyObject * obj2 = 0 ;
8175 char *kwnames[] = {
8176 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8177 };
8178
8179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8181 if (SWIG_arg_fail(1)) SWIG_fail;
8182 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8183 if (SWIG_arg_fail(2)) SWIG_fail;
8184 if (obj2) {
8185 {
8186 arg3 = (bool)(SWIG_As_bool(obj2));
8187 if (SWIG_arg_fail(3)) SWIG_fail;
8188 }
8189 }
8190 {
8191 if (!wxPyCheckForApp()) SWIG_fail;
8192 PyThreadState* __tstate = wxPyBeginAllowThreads();
8193 result = (bool)wxShowTip(arg1,arg2,arg3);
8194
8195 wxPyEndAllowThreads(__tstate);
8196 if (PyErr_Occurred()) SWIG_fail;
8197 }
8198 {
8199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8200 }
8201 return resultobj;
8202 fail:
8203 return NULL;
8204 }
8205
8206
8207 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8208 PyObject *resultobj;
8209 wxString *arg1 = 0 ;
8210 size_t arg2 ;
8211 wxTipProvider *result;
8212 bool temp1 = false ;
8213 PyObject * obj0 = 0 ;
8214 PyObject * obj1 = 0 ;
8215 char *kwnames[] = {
8216 (char *) "filename",(char *) "currentTip", NULL
8217 };
8218
8219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8220 {
8221 arg1 = wxString_in_helper(obj0);
8222 if (arg1 == NULL) SWIG_fail;
8223 temp1 = true;
8224 }
8225 {
8226 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8227 if (SWIG_arg_fail(2)) SWIG_fail;
8228 }
8229 {
8230 if (!wxPyCheckForApp()) SWIG_fail;
8231 PyThreadState* __tstate = wxPyBeginAllowThreads();
8232 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8233
8234 wxPyEndAllowThreads(__tstate);
8235 if (PyErr_Occurred()) SWIG_fail;
8236 }
8237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8238 {
8239 if (temp1)
8240 delete arg1;
8241 }
8242 return resultobj;
8243 fail:
8244 {
8245 if (temp1)
8246 delete arg1;
8247 }
8248 return NULL;
8249 }
8250
8251
8252 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8253 PyObject *resultobj;
8254 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8255 int arg2 = (int) -1 ;
8256 wxPyTimer *result;
8257 PyObject * obj0 = 0 ;
8258 PyObject * obj1 = 0 ;
8259 char *kwnames[] = {
8260 (char *) "owner",(char *) "id", NULL
8261 };
8262
8263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8264 if (obj0) {
8265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8266 if (SWIG_arg_fail(1)) SWIG_fail;
8267 }
8268 if (obj1) {
8269 {
8270 arg2 = (int)(SWIG_As_int(obj1));
8271 if (SWIG_arg_fail(2)) SWIG_fail;
8272 }
8273 }
8274 {
8275 if (!wxPyCheckForApp()) SWIG_fail;
8276 PyThreadState* __tstate = wxPyBeginAllowThreads();
8277 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8278
8279 wxPyEndAllowThreads(__tstate);
8280 if (PyErr_Occurred()) SWIG_fail;
8281 }
8282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8283 return resultobj;
8284 fail:
8285 return NULL;
8286 }
8287
8288
8289 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8290 PyObject *resultobj;
8291 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8292 PyObject * obj0 = 0 ;
8293 char *kwnames[] = {
8294 (char *) "self", NULL
8295 };
8296
8297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8299 if (SWIG_arg_fail(1)) SWIG_fail;
8300 {
8301 PyThreadState* __tstate = wxPyBeginAllowThreads();
8302 delete arg1;
8303
8304 wxPyEndAllowThreads(__tstate);
8305 if (PyErr_Occurred()) SWIG_fail;
8306 }
8307 Py_INCREF(Py_None); resultobj = Py_None;
8308 return resultobj;
8309 fail:
8310 return NULL;
8311 }
8312
8313
8314 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8315 PyObject *resultobj;
8316 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8317 PyObject *arg2 = (PyObject *) 0 ;
8318 PyObject *arg3 = (PyObject *) 0 ;
8319 int arg4 = (int) 1 ;
8320 PyObject * obj0 = 0 ;
8321 PyObject * obj1 = 0 ;
8322 PyObject * obj2 = 0 ;
8323 PyObject * obj3 = 0 ;
8324 char *kwnames[] = {
8325 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8326 };
8327
8328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8330 if (SWIG_arg_fail(1)) SWIG_fail;
8331 arg2 = obj1;
8332 arg3 = obj2;
8333 if (obj3) {
8334 {
8335 arg4 = (int)(SWIG_As_int(obj3));
8336 if (SWIG_arg_fail(4)) SWIG_fail;
8337 }
8338 }
8339 {
8340 PyThreadState* __tstate = wxPyBeginAllowThreads();
8341 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8342
8343 wxPyEndAllowThreads(__tstate);
8344 if (PyErr_Occurred()) SWIG_fail;
8345 }
8346 Py_INCREF(Py_None); resultobj = Py_None;
8347 return resultobj;
8348 fail:
8349 return NULL;
8350 }
8351
8352
8353 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8354 PyObject *resultobj;
8355 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8356 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8357 int arg3 = (int) -1 ;
8358 PyObject * obj0 = 0 ;
8359 PyObject * obj1 = 0 ;
8360 PyObject * obj2 = 0 ;
8361 char *kwnames[] = {
8362 (char *) "self",(char *) "owner",(char *) "id", NULL
8363 };
8364
8365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8367 if (SWIG_arg_fail(1)) SWIG_fail;
8368 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8369 if (SWIG_arg_fail(2)) SWIG_fail;
8370 if (obj2) {
8371 {
8372 arg3 = (int)(SWIG_As_int(obj2));
8373 if (SWIG_arg_fail(3)) SWIG_fail;
8374 }
8375 }
8376 {
8377 PyThreadState* __tstate = wxPyBeginAllowThreads();
8378 (arg1)->SetOwner(arg2,arg3);
8379
8380 wxPyEndAllowThreads(__tstate);
8381 if (PyErr_Occurred()) SWIG_fail;
8382 }
8383 Py_INCREF(Py_None); resultobj = Py_None;
8384 return resultobj;
8385 fail:
8386 return NULL;
8387 }
8388
8389
8390 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8391 PyObject *resultobj;
8392 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8393 wxEvtHandler *result;
8394 PyObject * obj0 = 0 ;
8395 char *kwnames[] = {
8396 (char *) "self", NULL
8397 };
8398
8399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8401 if (SWIG_arg_fail(1)) SWIG_fail;
8402 {
8403 PyThreadState* __tstate = wxPyBeginAllowThreads();
8404 result = (wxEvtHandler *)(arg1)->GetOwner();
8405
8406 wxPyEndAllowThreads(__tstate);
8407 if (PyErr_Occurred()) SWIG_fail;
8408 }
8409 {
8410 resultobj = wxPyMake_wxObject(result, 0);
8411 }
8412 return resultobj;
8413 fail:
8414 return NULL;
8415 }
8416
8417
8418 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8419 PyObject *resultobj;
8420 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8421 int arg2 = (int) -1 ;
8422 bool arg3 = (bool) false ;
8423 bool result;
8424 PyObject * obj0 = 0 ;
8425 PyObject * obj1 = 0 ;
8426 PyObject * obj2 = 0 ;
8427 char *kwnames[] = {
8428 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8429 };
8430
8431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8433 if (SWIG_arg_fail(1)) SWIG_fail;
8434 if (obj1) {
8435 {
8436 arg2 = (int)(SWIG_As_int(obj1));
8437 if (SWIG_arg_fail(2)) SWIG_fail;
8438 }
8439 }
8440 if (obj2) {
8441 {
8442 arg3 = (bool)(SWIG_As_bool(obj2));
8443 if (SWIG_arg_fail(3)) SWIG_fail;
8444 }
8445 }
8446 {
8447 PyThreadState* __tstate = wxPyBeginAllowThreads();
8448 result = (bool)(arg1)->Start(arg2,arg3);
8449
8450 wxPyEndAllowThreads(__tstate);
8451 if (PyErr_Occurred()) SWIG_fail;
8452 }
8453 {
8454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8455 }
8456 return resultobj;
8457 fail:
8458 return NULL;
8459 }
8460
8461
8462 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8463 PyObject *resultobj;
8464 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8465 PyObject * obj0 = 0 ;
8466 char *kwnames[] = {
8467 (char *) "self", NULL
8468 };
8469
8470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8472 if (SWIG_arg_fail(1)) SWIG_fail;
8473 {
8474 PyThreadState* __tstate = wxPyBeginAllowThreads();
8475 (arg1)->Stop();
8476
8477 wxPyEndAllowThreads(__tstate);
8478 if (PyErr_Occurred()) SWIG_fail;
8479 }
8480 Py_INCREF(Py_None); resultobj = Py_None;
8481 return resultobj;
8482 fail:
8483 return NULL;
8484 }
8485
8486
8487 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8488 PyObject *resultobj;
8489 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8490 bool result;
8491 PyObject * obj0 = 0 ;
8492 char *kwnames[] = {
8493 (char *) "self", NULL
8494 };
8495
8496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8498 if (SWIG_arg_fail(1)) SWIG_fail;
8499 {
8500 PyThreadState* __tstate = wxPyBeginAllowThreads();
8501 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8502
8503 wxPyEndAllowThreads(__tstate);
8504 if (PyErr_Occurred()) SWIG_fail;
8505 }
8506 {
8507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8508 }
8509 return resultobj;
8510 fail:
8511 return NULL;
8512 }
8513
8514
8515 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8516 PyObject *resultobj;
8517 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8518 int result;
8519 PyObject * obj0 = 0 ;
8520 char *kwnames[] = {
8521 (char *) "self", NULL
8522 };
8523
8524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8526 if (SWIG_arg_fail(1)) SWIG_fail;
8527 {
8528 PyThreadState* __tstate = wxPyBeginAllowThreads();
8529 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8530
8531 wxPyEndAllowThreads(__tstate);
8532 if (PyErr_Occurred()) SWIG_fail;
8533 }
8534 {
8535 resultobj = SWIG_From_int((int)(result));
8536 }
8537 return resultobj;
8538 fail:
8539 return NULL;
8540 }
8541
8542
8543 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8544 PyObject *resultobj;
8545 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8546 bool result;
8547 PyObject * obj0 = 0 ;
8548 char *kwnames[] = {
8549 (char *) "self", NULL
8550 };
8551
8552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8554 if (SWIG_arg_fail(1)) SWIG_fail;
8555 {
8556 PyThreadState* __tstate = wxPyBeginAllowThreads();
8557 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8558
8559 wxPyEndAllowThreads(__tstate);
8560 if (PyErr_Occurred()) SWIG_fail;
8561 }
8562 {
8563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8564 }
8565 return resultobj;
8566 fail:
8567 return NULL;
8568 }
8569
8570
8571 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8572 PyObject *resultobj;
8573 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8574 int result;
8575 PyObject * obj0 = 0 ;
8576 char *kwnames[] = {
8577 (char *) "self", NULL
8578 };
8579
8580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8582 if (SWIG_arg_fail(1)) SWIG_fail;
8583 {
8584 PyThreadState* __tstate = wxPyBeginAllowThreads();
8585 result = (int)((wxPyTimer const *)arg1)->GetId();
8586
8587 wxPyEndAllowThreads(__tstate);
8588 if (PyErr_Occurred()) SWIG_fail;
8589 }
8590 {
8591 resultobj = SWIG_From_int((int)(result));
8592 }
8593 return resultobj;
8594 fail:
8595 return NULL;
8596 }
8597
8598
8599 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8600 PyObject *obj;
8601 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8602 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8603 Py_INCREF(obj);
8604 return Py_BuildValue((char *)"");
8605 }
8606 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8607 PyObject *resultobj;
8608 int arg1 = (int) 0 ;
8609 int arg2 = (int) 0 ;
8610 wxTimerEvent *result;
8611 PyObject * obj0 = 0 ;
8612 PyObject * obj1 = 0 ;
8613 char *kwnames[] = {
8614 (char *) "timerid",(char *) "interval", NULL
8615 };
8616
8617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8618 if (obj0) {
8619 {
8620 arg1 = (int)(SWIG_As_int(obj0));
8621 if (SWIG_arg_fail(1)) SWIG_fail;
8622 }
8623 }
8624 if (obj1) {
8625 {
8626 arg2 = (int)(SWIG_As_int(obj1));
8627 if (SWIG_arg_fail(2)) SWIG_fail;
8628 }
8629 }
8630 {
8631 PyThreadState* __tstate = wxPyBeginAllowThreads();
8632 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8633
8634 wxPyEndAllowThreads(__tstate);
8635 if (PyErr_Occurred()) SWIG_fail;
8636 }
8637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8638 return resultobj;
8639 fail:
8640 return NULL;
8641 }
8642
8643
8644 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8645 PyObject *resultobj;
8646 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8647 int result;
8648 PyObject * obj0 = 0 ;
8649 char *kwnames[] = {
8650 (char *) "self", NULL
8651 };
8652
8653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8655 if (SWIG_arg_fail(1)) SWIG_fail;
8656 {
8657 PyThreadState* __tstate = wxPyBeginAllowThreads();
8658 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8659
8660 wxPyEndAllowThreads(__tstate);
8661 if (PyErr_Occurred()) SWIG_fail;
8662 }
8663 {
8664 resultobj = SWIG_From_int((int)(result));
8665 }
8666 return resultobj;
8667 fail:
8668 return NULL;
8669 }
8670
8671
8672 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8673 PyObject *obj;
8674 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8675 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8676 Py_INCREF(obj);
8677 return Py_BuildValue((char *)"");
8678 }
8679 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8680 PyObject *resultobj;
8681 wxTimer *arg1 = 0 ;
8682 wxTimerRunner *result;
8683 PyObject * obj0 = 0 ;
8684
8685 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8686 {
8687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8688 if (SWIG_arg_fail(1)) SWIG_fail;
8689 if (arg1 == NULL) {
8690 SWIG_null_ref("wxTimer");
8691 }
8692 if (SWIG_arg_fail(1)) SWIG_fail;
8693 }
8694 {
8695 if (!wxPyCheckForApp()) SWIG_fail;
8696 PyThreadState* __tstate = wxPyBeginAllowThreads();
8697 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8698
8699 wxPyEndAllowThreads(__tstate);
8700 if (PyErr_Occurred()) SWIG_fail;
8701 }
8702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8703 return resultobj;
8704 fail:
8705 return NULL;
8706 }
8707
8708
8709 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8710 PyObject *resultobj;
8711 wxTimer *arg1 = 0 ;
8712 int arg2 ;
8713 bool arg3 = (bool) false ;
8714 wxTimerRunner *result;
8715 PyObject * obj0 = 0 ;
8716 PyObject * obj1 = 0 ;
8717 PyObject * obj2 = 0 ;
8718
8719 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8720 {
8721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8722 if (SWIG_arg_fail(1)) SWIG_fail;
8723 if (arg1 == NULL) {
8724 SWIG_null_ref("wxTimer");
8725 }
8726 if (SWIG_arg_fail(1)) SWIG_fail;
8727 }
8728 {
8729 arg2 = (int)(SWIG_As_int(obj1));
8730 if (SWIG_arg_fail(2)) SWIG_fail;
8731 }
8732 if (obj2) {
8733 {
8734 arg3 = (bool)(SWIG_As_bool(obj2));
8735 if (SWIG_arg_fail(3)) SWIG_fail;
8736 }
8737 }
8738 {
8739 if (!wxPyCheckForApp()) SWIG_fail;
8740 PyThreadState* __tstate = wxPyBeginAllowThreads();
8741 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8742
8743 wxPyEndAllowThreads(__tstate);
8744 if (PyErr_Occurred()) SWIG_fail;
8745 }
8746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8747 return resultobj;
8748 fail:
8749 return NULL;
8750 }
8751
8752
8753 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8754 int argc;
8755 PyObject *argv[4];
8756 int ii;
8757
8758 argc = PyObject_Length(args);
8759 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8760 argv[ii] = PyTuple_GetItem(args,ii);
8761 }
8762 if (argc == 1) {
8763 int _v;
8764 {
8765 void *ptr = 0;
8766 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8767 _v = 0;
8768 PyErr_Clear();
8769 } else {
8770 _v = (ptr != 0);
8771 }
8772 }
8773 if (_v) {
8774 return _wrap_new_TimerRunner__SWIG_0(self,args);
8775 }
8776 }
8777 if ((argc >= 2) && (argc <= 3)) {
8778 int _v;
8779 {
8780 void *ptr = 0;
8781 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8782 _v = 0;
8783 PyErr_Clear();
8784 } else {
8785 _v = (ptr != 0);
8786 }
8787 }
8788 if (_v) {
8789 _v = SWIG_Check_int(argv[1]);
8790 if (_v) {
8791 if (argc <= 2) {
8792 return _wrap_new_TimerRunner__SWIG_1(self,args);
8793 }
8794 _v = SWIG_Check_bool(argv[2]);
8795 if (_v) {
8796 return _wrap_new_TimerRunner__SWIG_1(self,args);
8797 }
8798 }
8799 }
8800 }
8801
8802 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8803 return NULL;
8804 }
8805
8806
8807 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8808 PyObject *resultobj;
8809 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8810 PyObject * obj0 = 0 ;
8811 char *kwnames[] = {
8812 (char *) "self", NULL
8813 };
8814
8815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8817 if (SWIG_arg_fail(1)) SWIG_fail;
8818 {
8819 PyThreadState* __tstate = wxPyBeginAllowThreads();
8820 delete arg1;
8821
8822 wxPyEndAllowThreads(__tstate);
8823 if (PyErr_Occurred()) SWIG_fail;
8824 }
8825 Py_INCREF(Py_None); resultobj = Py_None;
8826 return resultobj;
8827 fail:
8828 return NULL;
8829 }
8830
8831
8832 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8833 PyObject *resultobj;
8834 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8835 int arg2 ;
8836 bool arg3 = (bool) false ;
8837 PyObject * obj0 = 0 ;
8838 PyObject * obj1 = 0 ;
8839 PyObject * obj2 = 0 ;
8840 char *kwnames[] = {
8841 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8842 };
8843
8844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8846 if (SWIG_arg_fail(1)) SWIG_fail;
8847 {
8848 arg2 = (int)(SWIG_As_int(obj1));
8849 if (SWIG_arg_fail(2)) SWIG_fail;
8850 }
8851 if (obj2) {
8852 {
8853 arg3 = (bool)(SWIG_As_bool(obj2));
8854 if (SWIG_arg_fail(3)) SWIG_fail;
8855 }
8856 }
8857 {
8858 PyThreadState* __tstate = wxPyBeginAllowThreads();
8859 (arg1)->Start(arg2,arg3);
8860
8861 wxPyEndAllowThreads(__tstate);
8862 if (PyErr_Occurred()) SWIG_fail;
8863 }
8864 Py_INCREF(Py_None); resultobj = Py_None;
8865 return resultobj;
8866 fail:
8867 return NULL;
8868 }
8869
8870
8871 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8872 PyObject *obj;
8873 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8874 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8875 Py_INCREF(obj);
8876 return Py_BuildValue((char *)"");
8877 }
8878 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8879 PyObject *resultobj;
8880 wxLog *result;
8881 char *kwnames[] = {
8882 NULL
8883 };
8884
8885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8886 {
8887 PyThreadState* __tstate = wxPyBeginAllowThreads();
8888 result = (wxLog *)new wxLog();
8889
8890 wxPyEndAllowThreads(__tstate);
8891 if (PyErr_Occurred()) SWIG_fail;
8892 }
8893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8894 return resultobj;
8895 fail:
8896 return NULL;
8897 }
8898
8899
8900 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8901 PyObject *resultobj;
8902 bool result;
8903 char *kwnames[] = {
8904 NULL
8905 };
8906
8907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8908 {
8909 PyThreadState* __tstate = wxPyBeginAllowThreads();
8910 result = (bool)wxLog::IsEnabled();
8911
8912 wxPyEndAllowThreads(__tstate);
8913 if (PyErr_Occurred()) SWIG_fail;
8914 }
8915 {
8916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8917 }
8918 return resultobj;
8919 fail:
8920 return NULL;
8921 }
8922
8923
8924 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8925 PyObject *resultobj;
8926 bool arg1 = (bool) true ;
8927 bool result;
8928 PyObject * obj0 = 0 ;
8929 char *kwnames[] = {
8930 (char *) "doIt", NULL
8931 };
8932
8933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8934 if (obj0) {
8935 {
8936 arg1 = (bool)(SWIG_As_bool(obj0));
8937 if (SWIG_arg_fail(1)) SWIG_fail;
8938 }
8939 }
8940 {
8941 PyThreadState* __tstate = wxPyBeginAllowThreads();
8942 result = (bool)wxLog::EnableLogging(arg1);
8943
8944 wxPyEndAllowThreads(__tstate);
8945 if (PyErr_Occurred()) SWIG_fail;
8946 }
8947 {
8948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8949 }
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8957 PyObject *resultobj;
8958 wxLogLevel arg1 ;
8959 wxChar *arg2 = (wxChar *) 0 ;
8960 time_t arg3 ;
8961 PyObject * obj0 = 0 ;
8962 PyObject * obj1 = 0 ;
8963 PyObject * obj2 = 0 ;
8964 char *kwnames[] = {
8965 (char *) "level",(char *) "szString",(char *) "t", NULL
8966 };
8967
8968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8969 {
8970 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8971 if (SWIG_arg_fail(1)) SWIG_fail;
8972 }
8973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8974 if (SWIG_arg_fail(2)) SWIG_fail;
8975 {
8976 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8977 if (SWIG_arg_fail(3)) SWIG_fail;
8978 }
8979 {
8980 PyThreadState* __tstate = wxPyBeginAllowThreads();
8981 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8982
8983 wxPyEndAllowThreads(__tstate);
8984 if (PyErr_Occurred()) SWIG_fail;
8985 }
8986 Py_INCREF(Py_None); resultobj = Py_None;
8987 return resultobj;
8988 fail:
8989 return NULL;
8990 }
8991
8992
8993 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8994 PyObject *resultobj;
8995 wxLog *arg1 = (wxLog *) 0 ;
8996 PyObject * obj0 = 0 ;
8997 char *kwnames[] = {
8998 (char *) "self", NULL
8999 };
9000
9001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
9002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9003 if (SWIG_arg_fail(1)) SWIG_fail;
9004 {
9005 PyThreadState* __tstate = wxPyBeginAllowThreads();
9006 (arg1)->Flush();
9007
9008 wxPyEndAllowThreads(__tstate);
9009 if (PyErr_Occurred()) SWIG_fail;
9010 }
9011 Py_INCREF(Py_None); resultobj = Py_None;
9012 return resultobj;
9013 fail:
9014 return NULL;
9015 }
9016
9017
9018 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
9019 PyObject *resultobj;
9020 char *kwnames[] = {
9021 NULL
9022 };
9023
9024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
9025 {
9026 PyThreadState* __tstate = wxPyBeginAllowThreads();
9027 wxLog::FlushActive();
9028
9029 wxPyEndAllowThreads(__tstate);
9030 if (PyErr_Occurred()) SWIG_fail;
9031 }
9032 Py_INCREF(Py_None); resultobj = Py_None;
9033 return resultobj;
9034 fail:
9035 return NULL;
9036 }
9037
9038
9039 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9040 PyObject *resultobj;
9041 wxLog *result;
9042 char *kwnames[] = {
9043 NULL
9044 };
9045
9046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9047 {
9048 PyThreadState* __tstate = wxPyBeginAllowThreads();
9049 result = (wxLog *)wxLog::GetActiveTarget();
9050
9051 wxPyEndAllowThreads(__tstate);
9052 if (PyErr_Occurred()) SWIG_fail;
9053 }
9054 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9055 return resultobj;
9056 fail:
9057 return NULL;
9058 }
9059
9060
9061 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9062 PyObject *resultobj;
9063 wxLog *arg1 = (wxLog *) 0 ;
9064 wxLog *result;
9065 PyObject * obj0 = 0 ;
9066 char *kwnames[] = {
9067 (char *) "pLogger", NULL
9068 };
9069
9070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9072 if (SWIG_arg_fail(1)) SWIG_fail;
9073 {
9074 PyThreadState* __tstate = wxPyBeginAllowThreads();
9075 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9076
9077 wxPyEndAllowThreads(__tstate);
9078 if (PyErr_Occurred()) SWIG_fail;
9079 }
9080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9081 return resultobj;
9082 fail:
9083 return NULL;
9084 }
9085
9086
9087 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9088 PyObject *resultobj;
9089 char *kwnames[] = {
9090 NULL
9091 };
9092
9093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9094 {
9095 PyThreadState* __tstate = wxPyBeginAllowThreads();
9096 wxLog::Suspend();
9097
9098 wxPyEndAllowThreads(__tstate);
9099 if (PyErr_Occurred()) SWIG_fail;
9100 }
9101 Py_INCREF(Py_None); resultobj = Py_None;
9102 return resultobj;
9103 fail:
9104 return NULL;
9105 }
9106
9107
9108 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9109 PyObject *resultobj;
9110 char *kwnames[] = {
9111 NULL
9112 };
9113
9114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9115 {
9116 PyThreadState* __tstate = wxPyBeginAllowThreads();
9117 wxLog::Resume();
9118
9119 wxPyEndAllowThreads(__tstate);
9120 if (PyErr_Occurred()) SWIG_fail;
9121 }
9122 Py_INCREF(Py_None); resultobj = Py_None;
9123 return resultobj;
9124 fail:
9125 return NULL;
9126 }
9127
9128
9129 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9130 PyObject *resultobj;
9131 bool arg1 = (bool) true ;
9132 PyObject * obj0 = 0 ;
9133 char *kwnames[] = {
9134 (char *) "bVerbose", NULL
9135 };
9136
9137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9138 if (obj0) {
9139 {
9140 arg1 = (bool)(SWIG_As_bool(obj0));
9141 if (SWIG_arg_fail(1)) SWIG_fail;
9142 }
9143 }
9144 {
9145 PyThreadState* __tstate = wxPyBeginAllowThreads();
9146 wxLog::SetVerbose(arg1);
9147
9148 wxPyEndAllowThreads(__tstate);
9149 if (PyErr_Occurred()) SWIG_fail;
9150 }
9151 Py_INCREF(Py_None); resultobj = Py_None;
9152 return resultobj;
9153 fail:
9154 return NULL;
9155 }
9156
9157
9158 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9159 PyObject *resultobj;
9160 wxLogLevel arg1 ;
9161 PyObject * obj0 = 0 ;
9162 char *kwnames[] = {
9163 (char *) "logLevel", NULL
9164 };
9165
9166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9167 {
9168 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9169 if (SWIG_arg_fail(1)) SWIG_fail;
9170 }
9171 {
9172 PyThreadState* __tstate = wxPyBeginAllowThreads();
9173 wxLog::SetLogLevel(arg1);
9174
9175 wxPyEndAllowThreads(__tstate);
9176 if (PyErr_Occurred()) SWIG_fail;
9177 }
9178 Py_INCREF(Py_None); resultobj = Py_None;
9179 return resultobj;
9180 fail:
9181 return NULL;
9182 }
9183
9184
9185 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9186 PyObject *resultobj;
9187 char *kwnames[] = {
9188 NULL
9189 };
9190
9191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9192 {
9193 PyThreadState* __tstate = wxPyBeginAllowThreads();
9194 wxLog::DontCreateOnDemand();
9195
9196 wxPyEndAllowThreads(__tstate);
9197 if (PyErr_Occurred()) SWIG_fail;
9198 }
9199 Py_INCREF(Py_None); resultobj = Py_None;
9200 return resultobj;
9201 fail:
9202 return NULL;
9203 }
9204
9205
9206 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9207 PyObject *resultobj;
9208 wxTraceMask arg1 ;
9209 PyObject * obj0 = 0 ;
9210 char *kwnames[] = {
9211 (char *) "ulMask", NULL
9212 };
9213
9214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9215 {
9216 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9217 if (SWIG_arg_fail(1)) SWIG_fail;
9218 }
9219 {
9220 PyThreadState* __tstate = wxPyBeginAllowThreads();
9221 wxLog::SetTraceMask(arg1);
9222
9223 wxPyEndAllowThreads(__tstate);
9224 if (PyErr_Occurred()) SWIG_fail;
9225 }
9226 Py_INCREF(Py_None); resultobj = Py_None;
9227 return resultobj;
9228 fail:
9229 return NULL;
9230 }
9231
9232
9233 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9234 PyObject *resultobj;
9235 wxString *arg1 = 0 ;
9236 bool temp1 = false ;
9237 PyObject * obj0 = 0 ;
9238 char *kwnames[] = {
9239 (char *) "str", NULL
9240 };
9241
9242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9243 {
9244 arg1 = wxString_in_helper(obj0);
9245 if (arg1 == NULL) SWIG_fail;
9246 temp1 = true;
9247 }
9248 {
9249 PyThreadState* __tstate = wxPyBeginAllowThreads();
9250 wxLog::AddTraceMask((wxString const &)*arg1);
9251
9252 wxPyEndAllowThreads(__tstate);
9253 if (PyErr_Occurred()) SWIG_fail;
9254 }
9255 Py_INCREF(Py_None); resultobj = Py_None;
9256 {
9257 if (temp1)
9258 delete arg1;
9259 }
9260 return resultobj;
9261 fail:
9262 {
9263 if (temp1)
9264 delete arg1;
9265 }
9266 return NULL;
9267 }
9268
9269
9270 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9271 PyObject *resultobj;
9272 wxString *arg1 = 0 ;
9273 bool temp1 = false ;
9274 PyObject * obj0 = 0 ;
9275 char *kwnames[] = {
9276 (char *) "str", NULL
9277 };
9278
9279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9280 {
9281 arg1 = wxString_in_helper(obj0);
9282 if (arg1 == NULL) SWIG_fail;
9283 temp1 = true;
9284 }
9285 {
9286 PyThreadState* __tstate = wxPyBeginAllowThreads();
9287 wxLog::RemoveTraceMask((wxString const &)*arg1);
9288
9289 wxPyEndAllowThreads(__tstate);
9290 if (PyErr_Occurred()) SWIG_fail;
9291 }
9292 Py_INCREF(Py_None); resultobj = Py_None;
9293 {
9294 if (temp1)
9295 delete arg1;
9296 }
9297 return resultobj;
9298 fail:
9299 {
9300 if (temp1)
9301 delete arg1;
9302 }
9303 return NULL;
9304 }
9305
9306
9307 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9308 PyObject *resultobj;
9309 char *kwnames[] = {
9310 NULL
9311 };
9312
9313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9314 {
9315 PyThreadState* __tstate = wxPyBeginAllowThreads();
9316 wxLog::ClearTraceMasks();
9317
9318 wxPyEndAllowThreads(__tstate);
9319 if (PyErr_Occurred()) SWIG_fail;
9320 }
9321 Py_INCREF(Py_None); resultobj = Py_None;
9322 return resultobj;
9323 fail:
9324 return NULL;
9325 }
9326
9327
9328 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9329 PyObject *resultobj;
9330 wxArrayString *result;
9331 char *kwnames[] = {
9332 NULL
9333 };
9334
9335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9336 {
9337 PyThreadState* __tstate = wxPyBeginAllowThreads();
9338 {
9339 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9340 result = (wxArrayString *) &_result_ref;
9341 }
9342
9343 wxPyEndAllowThreads(__tstate);
9344 if (PyErr_Occurred()) SWIG_fail;
9345 }
9346 {
9347 resultobj = wxArrayString2PyList_helper(*result);
9348 }
9349 return resultobj;
9350 fail:
9351 return NULL;
9352 }
9353
9354
9355 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9356 PyObject *resultobj;
9357 wxChar *arg1 = (wxChar *) 0 ;
9358 PyObject * obj0 = 0 ;
9359 char *kwnames[] = {
9360 (char *) "ts", NULL
9361 };
9362
9363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9365 if (SWIG_arg_fail(1)) SWIG_fail;
9366 {
9367 PyThreadState* __tstate = wxPyBeginAllowThreads();
9368 wxLog::SetTimestamp((wxChar const *)arg1);
9369
9370 wxPyEndAllowThreads(__tstate);
9371 if (PyErr_Occurred()) SWIG_fail;
9372 }
9373 Py_INCREF(Py_None); resultobj = Py_None;
9374 return resultobj;
9375 fail:
9376 return NULL;
9377 }
9378
9379
9380 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9381 PyObject *resultobj;
9382 bool result;
9383 char *kwnames[] = {
9384 NULL
9385 };
9386
9387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9388 {
9389 PyThreadState* __tstate = wxPyBeginAllowThreads();
9390 result = (bool)wxLog::GetVerbose();
9391
9392 wxPyEndAllowThreads(__tstate);
9393 if (PyErr_Occurred()) SWIG_fail;
9394 }
9395 {
9396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9397 }
9398 return resultobj;
9399 fail:
9400 return NULL;
9401 }
9402
9403
9404 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9405 PyObject *resultobj;
9406 wxTraceMask result;
9407 char *kwnames[] = {
9408 NULL
9409 };
9410
9411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9412 {
9413 PyThreadState* __tstate = wxPyBeginAllowThreads();
9414 result = (wxTraceMask)wxLog::GetTraceMask();
9415
9416 wxPyEndAllowThreads(__tstate);
9417 if (PyErr_Occurred()) SWIG_fail;
9418 }
9419 {
9420 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9421 }
9422 return resultobj;
9423 fail:
9424 return NULL;
9425 }
9426
9427
9428 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9429 PyObject *resultobj;
9430 wxChar *arg1 = (wxChar *) 0 ;
9431 bool result;
9432 PyObject * obj0 = 0 ;
9433 char *kwnames[] = {
9434 (char *) "mask", NULL
9435 };
9436
9437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9439 if (SWIG_arg_fail(1)) SWIG_fail;
9440 {
9441 PyThreadState* __tstate = wxPyBeginAllowThreads();
9442 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9443
9444 wxPyEndAllowThreads(__tstate);
9445 if (PyErr_Occurred()) SWIG_fail;
9446 }
9447 {
9448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9449 }
9450 return resultobj;
9451 fail:
9452 return NULL;
9453 }
9454
9455
9456 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9457 PyObject *resultobj;
9458 wxLogLevel result;
9459 char *kwnames[] = {
9460 NULL
9461 };
9462
9463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9464 {
9465 PyThreadState* __tstate = wxPyBeginAllowThreads();
9466 result = (wxLogLevel)wxLog::GetLogLevel();
9467
9468 wxPyEndAllowThreads(__tstate);
9469 if (PyErr_Occurred()) SWIG_fail;
9470 }
9471 {
9472 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9473 }
9474 return resultobj;
9475 fail:
9476 return NULL;
9477 }
9478
9479
9480 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9481 PyObject *resultobj;
9482 wxChar *result;
9483 char *kwnames[] = {
9484 NULL
9485 };
9486
9487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9488 {
9489 PyThreadState* __tstate = wxPyBeginAllowThreads();
9490 result = (wxChar *)wxLog::GetTimestamp();
9491
9492 wxPyEndAllowThreads(__tstate);
9493 if (PyErr_Occurred()) SWIG_fail;
9494 }
9495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9496 return resultobj;
9497 fail:
9498 return NULL;
9499 }
9500
9501
9502 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9503 PyObject *resultobj;
9504 wxString result;
9505 char *kwnames[] = {
9506 NULL
9507 };
9508
9509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9510 {
9511 PyThreadState* __tstate = wxPyBeginAllowThreads();
9512 result = Log_TimeStamp();
9513
9514 wxPyEndAllowThreads(__tstate);
9515 if (PyErr_Occurred()) SWIG_fail;
9516 }
9517 {
9518 #if wxUSE_UNICODE
9519 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9520 #else
9521 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9522 #endif
9523 }
9524 return resultobj;
9525 fail:
9526 return NULL;
9527 }
9528
9529
9530 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9531 PyObject *resultobj;
9532 wxLog *arg1 = (wxLog *) 0 ;
9533 PyObject * obj0 = 0 ;
9534 char *kwnames[] = {
9535 (char *) "self", NULL
9536 };
9537
9538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9540 if (SWIG_arg_fail(1)) SWIG_fail;
9541 {
9542 PyThreadState* __tstate = wxPyBeginAllowThreads();
9543 wxLog_Destroy(arg1);
9544
9545 wxPyEndAllowThreads(__tstate);
9546 if (PyErr_Occurred()) SWIG_fail;
9547 }
9548 Py_INCREF(Py_None); resultobj = Py_None;
9549 return resultobj;
9550 fail:
9551 return NULL;
9552 }
9553
9554
9555 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9556 PyObject *obj;
9557 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9558 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9559 Py_INCREF(obj);
9560 return Py_BuildValue((char *)"");
9561 }
9562 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9563 PyObject *resultobj;
9564 wxLogStderr *result;
9565 char *kwnames[] = {
9566 NULL
9567 };
9568
9569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9570 {
9571 PyThreadState* __tstate = wxPyBeginAllowThreads();
9572 result = (wxLogStderr *)new wxLogStderr();
9573
9574 wxPyEndAllowThreads(__tstate);
9575 if (PyErr_Occurred()) SWIG_fail;
9576 }
9577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9578 return resultobj;
9579 fail:
9580 return NULL;
9581 }
9582
9583
9584 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9585 PyObject *obj;
9586 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9587 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9588 Py_INCREF(obj);
9589 return Py_BuildValue((char *)"");
9590 }
9591 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9592 PyObject *resultobj;
9593 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9594 wxLogTextCtrl *result;
9595 PyObject * obj0 = 0 ;
9596 char *kwnames[] = {
9597 (char *) "pTextCtrl", NULL
9598 };
9599
9600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9602 if (SWIG_arg_fail(1)) SWIG_fail;
9603 {
9604 PyThreadState* __tstate = wxPyBeginAllowThreads();
9605 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9606
9607 wxPyEndAllowThreads(__tstate);
9608 if (PyErr_Occurred()) SWIG_fail;
9609 }
9610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9611 return resultobj;
9612 fail:
9613 return NULL;
9614 }
9615
9616
9617 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9618 PyObject *obj;
9619 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9620 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9621 Py_INCREF(obj);
9622 return Py_BuildValue((char *)"");
9623 }
9624 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9625 PyObject *resultobj;
9626 wxLogGui *result;
9627 char *kwnames[] = {
9628 NULL
9629 };
9630
9631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9632 {
9633 PyThreadState* __tstate = wxPyBeginAllowThreads();
9634 result = (wxLogGui *)new wxLogGui();
9635
9636 wxPyEndAllowThreads(__tstate);
9637 if (PyErr_Occurred()) SWIG_fail;
9638 }
9639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9640 return resultobj;
9641 fail:
9642 return NULL;
9643 }
9644
9645
9646 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9647 PyObject *obj;
9648 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9649 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9650 Py_INCREF(obj);
9651 return Py_BuildValue((char *)"");
9652 }
9653 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9654 PyObject *resultobj;
9655 wxFrame *arg1 = (wxFrame *) 0 ;
9656 wxString *arg2 = 0 ;
9657 bool arg3 = (bool) true ;
9658 bool arg4 = (bool) true ;
9659 wxLogWindow *result;
9660 bool temp2 = false ;
9661 PyObject * obj0 = 0 ;
9662 PyObject * obj1 = 0 ;
9663 PyObject * obj2 = 0 ;
9664 PyObject * obj3 = 0 ;
9665 char *kwnames[] = {
9666 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9667 };
9668
9669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9671 if (SWIG_arg_fail(1)) SWIG_fail;
9672 {
9673 arg2 = wxString_in_helper(obj1);
9674 if (arg2 == NULL) SWIG_fail;
9675 temp2 = true;
9676 }
9677 if (obj2) {
9678 {
9679 arg3 = (bool)(SWIG_As_bool(obj2));
9680 if (SWIG_arg_fail(3)) SWIG_fail;
9681 }
9682 }
9683 if (obj3) {
9684 {
9685 arg4 = (bool)(SWIG_As_bool(obj3));
9686 if (SWIG_arg_fail(4)) SWIG_fail;
9687 }
9688 }
9689 {
9690 PyThreadState* __tstate = wxPyBeginAllowThreads();
9691 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9692
9693 wxPyEndAllowThreads(__tstate);
9694 if (PyErr_Occurred()) SWIG_fail;
9695 }
9696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9697 {
9698 if (temp2)
9699 delete arg2;
9700 }
9701 return resultobj;
9702 fail:
9703 {
9704 if (temp2)
9705 delete arg2;
9706 }
9707 return NULL;
9708 }
9709
9710
9711 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9712 PyObject *resultobj;
9713 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9714 bool arg2 = (bool) true ;
9715 PyObject * obj0 = 0 ;
9716 PyObject * obj1 = 0 ;
9717 char *kwnames[] = {
9718 (char *) "self",(char *) "bShow", NULL
9719 };
9720
9721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9723 if (SWIG_arg_fail(1)) SWIG_fail;
9724 if (obj1) {
9725 {
9726 arg2 = (bool)(SWIG_As_bool(obj1));
9727 if (SWIG_arg_fail(2)) SWIG_fail;
9728 }
9729 }
9730 {
9731 PyThreadState* __tstate = wxPyBeginAllowThreads();
9732 (arg1)->Show(arg2);
9733
9734 wxPyEndAllowThreads(__tstate);
9735 if (PyErr_Occurred()) SWIG_fail;
9736 }
9737 Py_INCREF(Py_None); resultobj = Py_None;
9738 return resultobj;
9739 fail:
9740 return NULL;
9741 }
9742
9743
9744 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9745 PyObject *resultobj;
9746 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9747 wxFrame *result;
9748 PyObject * obj0 = 0 ;
9749 char *kwnames[] = {
9750 (char *) "self", NULL
9751 };
9752
9753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9755 if (SWIG_arg_fail(1)) SWIG_fail;
9756 {
9757 PyThreadState* __tstate = wxPyBeginAllowThreads();
9758 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9759
9760 wxPyEndAllowThreads(__tstate);
9761 if (PyErr_Occurred()) SWIG_fail;
9762 }
9763 {
9764 resultobj = wxPyMake_wxObject(result, 0);
9765 }
9766 return resultobj;
9767 fail:
9768 return NULL;
9769 }
9770
9771
9772 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9773 PyObject *resultobj;
9774 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9775 wxLog *result;
9776 PyObject * obj0 = 0 ;
9777 char *kwnames[] = {
9778 (char *) "self", NULL
9779 };
9780
9781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9783 if (SWIG_arg_fail(1)) SWIG_fail;
9784 {
9785 PyThreadState* __tstate = wxPyBeginAllowThreads();
9786 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9787
9788 wxPyEndAllowThreads(__tstate);
9789 if (PyErr_Occurred()) SWIG_fail;
9790 }
9791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9792 return resultobj;
9793 fail:
9794 return NULL;
9795 }
9796
9797
9798 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9799 PyObject *resultobj;
9800 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9801 bool result;
9802 PyObject * obj0 = 0 ;
9803 char *kwnames[] = {
9804 (char *) "self", NULL
9805 };
9806
9807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9809 if (SWIG_arg_fail(1)) SWIG_fail;
9810 {
9811 PyThreadState* __tstate = wxPyBeginAllowThreads();
9812 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9813
9814 wxPyEndAllowThreads(__tstate);
9815 if (PyErr_Occurred()) SWIG_fail;
9816 }
9817 {
9818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9819 }
9820 return resultobj;
9821 fail:
9822 return NULL;
9823 }
9824
9825
9826 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9827 PyObject *resultobj;
9828 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9829 bool arg2 ;
9830 PyObject * obj0 = 0 ;
9831 PyObject * obj1 = 0 ;
9832 char *kwnames[] = {
9833 (char *) "self",(char *) "bDoPass", NULL
9834 };
9835
9836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9838 if (SWIG_arg_fail(1)) SWIG_fail;
9839 {
9840 arg2 = (bool)(SWIG_As_bool(obj1));
9841 if (SWIG_arg_fail(2)) SWIG_fail;
9842 }
9843 {
9844 PyThreadState* __tstate = wxPyBeginAllowThreads();
9845 (arg1)->PassMessages(arg2);
9846
9847 wxPyEndAllowThreads(__tstate);
9848 if (PyErr_Occurred()) SWIG_fail;
9849 }
9850 Py_INCREF(Py_None); resultobj = Py_None;
9851 return resultobj;
9852 fail:
9853 return NULL;
9854 }
9855
9856
9857 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9858 PyObject *obj;
9859 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9860 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9861 Py_INCREF(obj);
9862 return Py_BuildValue((char *)"");
9863 }
9864 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9865 PyObject *resultobj;
9866 wxLog *arg1 = (wxLog *) 0 ;
9867 wxLogChain *result;
9868 PyObject * obj0 = 0 ;
9869 char *kwnames[] = {
9870 (char *) "logger", NULL
9871 };
9872
9873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9875 if (SWIG_arg_fail(1)) SWIG_fail;
9876 {
9877 PyThreadState* __tstate = wxPyBeginAllowThreads();
9878 result = (wxLogChain *)new wxLogChain(arg1);
9879
9880 wxPyEndAllowThreads(__tstate);
9881 if (PyErr_Occurred()) SWIG_fail;
9882 }
9883 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9884 return resultobj;
9885 fail:
9886 return NULL;
9887 }
9888
9889
9890 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9891 PyObject *resultobj;
9892 wxLogChain *arg1 = (wxLogChain *) 0 ;
9893 wxLog *arg2 = (wxLog *) 0 ;
9894 PyObject * obj0 = 0 ;
9895 PyObject * obj1 = 0 ;
9896 char *kwnames[] = {
9897 (char *) "self",(char *) "logger", NULL
9898 };
9899
9900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9902 if (SWIG_arg_fail(1)) SWIG_fail;
9903 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9904 if (SWIG_arg_fail(2)) SWIG_fail;
9905 {
9906 PyThreadState* __tstate = wxPyBeginAllowThreads();
9907 (arg1)->SetLog(arg2);
9908
9909 wxPyEndAllowThreads(__tstate);
9910 if (PyErr_Occurred()) SWIG_fail;
9911 }
9912 Py_INCREF(Py_None); resultobj = Py_None;
9913 return resultobj;
9914 fail:
9915 return NULL;
9916 }
9917
9918
9919 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9920 PyObject *resultobj;
9921 wxLogChain *arg1 = (wxLogChain *) 0 ;
9922 bool arg2 ;
9923 PyObject * obj0 = 0 ;
9924 PyObject * obj1 = 0 ;
9925 char *kwnames[] = {
9926 (char *) "self",(char *) "bDoPass", NULL
9927 };
9928
9929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9931 if (SWIG_arg_fail(1)) SWIG_fail;
9932 {
9933 arg2 = (bool)(SWIG_As_bool(obj1));
9934 if (SWIG_arg_fail(2)) SWIG_fail;
9935 }
9936 {
9937 PyThreadState* __tstate = wxPyBeginAllowThreads();
9938 (arg1)->PassMessages(arg2);
9939
9940 wxPyEndAllowThreads(__tstate);
9941 if (PyErr_Occurred()) SWIG_fail;
9942 }
9943 Py_INCREF(Py_None); resultobj = Py_None;
9944 return resultobj;
9945 fail:
9946 return NULL;
9947 }
9948
9949
9950 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9951 PyObject *resultobj;
9952 wxLogChain *arg1 = (wxLogChain *) 0 ;
9953 bool result;
9954 PyObject * obj0 = 0 ;
9955 char *kwnames[] = {
9956 (char *) "self", NULL
9957 };
9958
9959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9961 if (SWIG_arg_fail(1)) SWIG_fail;
9962 {
9963 PyThreadState* __tstate = wxPyBeginAllowThreads();
9964 result = (bool)(arg1)->IsPassingMessages();
9965
9966 wxPyEndAllowThreads(__tstate);
9967 if (PyErr_Occurred()) SWIG_fail;
9968 }
9969 {
9970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9971 }
9972 return resultobj;
9973 fail:
9974 return NULL;
9975 }
9976
9977
9978 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9979 PyObject *resultobj;
9980 wxLogChain *arg1 = (wxLogChain *) 0 ;
9981 wxLog *result;
9982 PyObject * obj0 = 0 ;
9983 char *kwnames[] = {
9984 (char *) "self", NULL
9985 };
9986
9987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9989 if (SWIG_arg_fail(1)) SWIG_fail;
9990 {
9991 PyThreadState* __tstate = wxPyBeginAllowThreads();
9992 result = (wxLog *)(arg1)->GetOldLog();
9993
9994 wxPyEndAllowThreads(__tstate);
9995 if (PyErr_Occurred()) SWIG_fail;
9996 }
9997 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9998 return resultobj;
9999 fail:
10000 return NULL;
10001 }
10002
10003
10004 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
10005 PyObject *obj;
10006 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10007 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
10008 Py_INCREF(obj);
10009 return Py_BuildValue((char *)"");
10010 }
10011 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10012 PyObject *resultobj;
10013 unsigned long result;
10014 char *kwnames[] = {
10015 NULL
10016 };
10017
10018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10019 {
10020 PyThreadState* __tstate = wxPyBeginAllowThreads();
10021 result = (unsigned long)wxSysErrorCode();
10022
10023 wxPyEndAllowThreads(__tstate);
10024 if (PyErr_Occurred()) SWIG_fail;
10025 }
10026 {
10027 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10028 }
10029 return resultobj;
10030 fail:
10031 return NULL;
10032 }
10033
10034
10035 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10036 PyObject *resultobj;
10037 unsigned long arg1 = (unsigned long) 0 ;
10038 wxString result;
10039 PyObject * obj0 = 0 ;
10040 char *kwnames[] = {
10041 (char *) "nErrCode", NULL
10042 };
10043
10044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10045 if (obj0) {
10046 {
10047 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10048 if (SWIG_arg_fail(1)) SWIG_fail;
10049 }
10050 }
10051 {
10052 PyThreadState* __tstate = wxPyBeginAllowThreads();
10053 result = wxSysErrorMsg(arg1);
10054
10055 wxPyEndAllowThreads(__tstate);
10056 if (PyErr_Occurred()) SWIG_fail;
10057 }
10058 {
10059 #if wxUSE_UNICODE
10060 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10061 #else
10062 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10063 #endif
10064 }
10065 return resultobj;
10066 fail:
10067 return NULL;
10068 }
10069
10070
10071 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10072 PyObject *resultobj;
10073 wxString *arg1 = 0 ;
10074 bool temp1 = false ;
10075 PyObject * obj0 = 0 ;
10076 char *kwnames[] = {
10077 (char *) "msg", NULL
10078 };
10079
10080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10081 {
10082 arg1 = wxString_in_helper(obj0);
10083 if (arg1 == NULL) SWIG_fail;
10084 temp1 = true;
10085 }
10086 {
10087 PyThreadState* __tstate = wxPyBeginAllowThreads();
10088 wxPyLogFatalError((wxString const &)*arg1);
10089
10090 wxPyEndAllowThreads(__tstate);
10091 if (PyErr_Occurred()) SWIG_fail;
10092 }
10093 Py_INCREF(Py_None); resultobj = Py_None;
10094 {
10095 if (temp1)
10096 delete arg1;
10097 }
10098 return resultobj;
10099 fail:
10100 {
10101 if (temp1)
10102 delete arg1;
10103 }
10104 return NULL;
10105 }
10106
10107
10108 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10109 PyObject *resultobj;
10110 wxString *arg1 = 0 ;
10111 bool temp1 = false ;
10112 PyObject * obj0 = 0 ;
10113 char *kwnames[] = {
10114 (char *) "msg", NULL
10115 };
10116
10117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10118 {
10119 arg1 = wxString_in_helper(obj0);
10120 if (arg1 == NULL) SWIG_fail;
10121 temp1 = true;
10122 }
10123 {
10124 PyThreadState* __tstate = wxPyBeginAllowThreads();
10125 wxPyLogError((wxString const &)*arg1);
10126
10127 wxPyEndAllowThreads(__tstate);
10128 if (PyErr_Occurred()) SWIG_fail;
10129 }
10130 Py_INCREF(Py_None); resultobj = Py_None;
10131 {
10132 if (temp1)
10133 delete arg1;
10134 }
10135 return resultobj;
10136 fail:
10137 {
10138 if (temp1)
10139 delete arg1;
10140 }
10141 return NULL;
10142 }
10143
10144
10145 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10146 PyObject *resultobj;
10147 wxString *arg1 = 0 ;
10148 bool temp1 = false ;
10149 PyObject * obj0 = 0 ;
10150 char *kwnames[] = {
10151 (char *) "msg", NULL
10152 };
10153
10154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10155 {
10156 arg1 = wxString_in_helper(obj0);
10157 if (arg1 == NULL) SWIG_fail;
10158 temp1 = true;
10159 }
10160 {
10161 PyThreadState* __tstate = wxPyBeginAllowThreads();
10162 wxPyLogWarning((wxString const &)*arg1);
10163
10164 wxPyEndAllowThreads(__tstate);
10165 if (PyErr_Occurred()) SWIG_fail;
10166 }
10167 Py_INCREF(Py_None); resultobj = Py_None;
10168 {
10169 if (temp1)
10170 delete arg1;
10171 }
10172 return resultobj;
10173 fail:
10174 {
10175 if (temp1)
10176 delete arg1;
10177 }
10178 return NULL;
10179 }
10180
10181
10182 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10183 PyObject *resultobj;
10184 wxString *arg1 = 0 ;
10185 bool temp1 = false ;
10186 PyObject * obj0 = 0 ;
10187 char *kwnames[] = {
10188 (char *) "msg", NULL
10189 };
10190
10191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10192 {
10193 arg1 = wxString_in_helper(obj0);
10194 if (arg1 == NULL) SWIG_fail;
10195 temp1 = true;
10196 }
10197 {
10198 PyThreadState* __tstate = wxPyBeginAllowThreads();
10199 wxPyLogMessage((wxString const &)*arg1);
10200
10201 wxPyEndAllowThreads(__tstate);
10202 if (PyErr_Occurred()) SWIG_fail;
10203 }
10204 Py_INCREF(Py_None); resultobj = Py_None;
10205 {
10206 if (temp1)
10207 delete arg1;
10208 }
10209 return resultobj;
10210 fail:
10211 {
10212 if (temp1)
10213 delete arg1;
10214 }
10215 return NULL;
10216 }
10217
10218
10219 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10220 PyObject *resultobj;
10221 wxString *arg1 = 0 ;
10222 bool temp1 = false ;
10223 PyObject * obj0 = 0 ;
10224 char *kwnames[] = {
10225 (char *) "msg", NULL
10226 };
10227
10228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10229 {
10230 arg1 = wxString_in_helper(obj0);
10231 if (arg1 == NULL) SWIG_fail;
10232 temp1 = true;
10233 }
10234 {
10235 PyThreadState* __tstate = wxPyBeginAllowThreads();
10236 wxPyLogInfo((wxString const &)*arg1);
10237
10238 wxPyEndAllowThreads(__tstate);
10239 if (PyErr_Occurred()) SWIG_fail;
10240 }
10241 Py_INCREF(Py_None); resultobj = Py_None;
10242 {
10243 if (temp1)
10244 delete arg1;
10245 }
10246 return resultobj;
10247 fail:
10248 {
10249 if (temp1)
10250 delete arg1;
10251 }
10252 return NULL;
10253 }
10254
10255
10256 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10257 PyObject *resultobj;
10258 wxString *arg1 = 0 ;
10259 bool temp1 = false ;
10260 PyObject * obj0 = 0 ;
10261 char *kwnames[] = {
10262 (char *) "msg", NULL
10263 };
10264
10265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10266 {
10267 arg1 = wxString_in_helper(obj0);
10268 if (arg1 == NULL) SWIG_fail;
10269 temp1 = true;
10270 }
10271 {
10272 PyThreadState* __tstate = wxPyBeginAllowThreads();
10273 wxPyLogDebug((wxString const &)*arg1);
10274
10275 wxPyEndAllowThreads(__tstate);
10276 if (PyErr_Occurred()) SWIG_fail;
10277 }
10278 Py_INCREF(Py_None); resultobj = Py_None;
10279 {
10280 if (temp1)
10281 delete arg1;
10282 }
10283 return resultobj;
10284 fail:
10285 {
10286 if (temp1)
10287 delete arg1;
10288 }
10289 return NULL;
10290 }
10291
10292
10293 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10294 PyObject *resultobj;
10295 wxString *arg1 = 0 ;
10296 bool temp1 = false ;
10297 PyObject * obj0 = 0 ;
10298 char *kwnames[] = {
10299 (char *) "msg", NULL
10300 };
10301
10302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10303 {
10304 arg1 = wxString_in_helper(obj0);
10305 if (arg1 == NULL) SWIG_fail;
10306 temp1 = true;
10307 }
10308 {
10309 PyThreadState* __tstate = wxPyBeginAllowThreads();
10310 wxPyLogVerbose((wxString const &)*arg1);
10311
10312 wxPyEndAllowThreads(__tstate);
10313 if (PyErr_Occurred()) SWIG_fail;
10314 }
10315 Py_INCREF(Py_None); resultobj = Py_None;
10316 {
10317 if (temp1)
10318 delete arg1;
10319 }
10320 return resultobj;
10321 fail:
10322 {
10323 if (temp1)
10324 delete arg1;
10325 }
10326 return NULL;
10327 }
10328
10329
10330 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10331 PyObject *resultobj;
10332 wxString *arg1 = 0 ;
10333 bool temp1 = false ;
10334 PyObject * obj0 = 0 ;
10335 char *kwnames[] = {
10336 (char *) "msg", NULL
10337 };
10338
10339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10340 {
10341 arg1 = wxString_in_helper(obj0);
10342 if (arg1 == NULL) SWIG_fail;
10343 temp1 = true;
10344 }
10345 {
10346 PyThreadState* __tstate = wxPyBeginAllowThreads();
10347 wxPyLogStatus((wxString const &)*arg1);
10348
10349 wxPyEndAllowThreads(__tstate);
10350 if (PyErr_Occurred()) SWIG_fail;
10351 }
10352 Py_INCREF(Py_None); resultobj = Py_None;
10353 {
10354 if (temp1)
10355 delete arg1;
10356 }
10357 return resultobj;
10358 fail:
10359 {
10360 if (temp1)
10361 delete arg1;
10362 }
10363 return NULL;
10364 }
10365
10366
10367 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10368 PyObject *resultobj;
10369 wxFrame *arg1 = (wxFrame *) 0 ;
10370 wxString *arg2 = 0 ;
10371 bool temp2 = false ;
10372 PyObject * obj0 = 0 ;
10373 PyObject * obj1 = 0 ;
10374 char *kwnames[] = {
10375 (char *) "pFrame",(char *) "msg", NULL
10376 };
10377
10378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10380 if (SWIG_arg_fail(1)) SWIG_fail;
10381 {
10382 arg2 = wxString_in_helper(obj1);
10383 if (arg2 == NULL) SWIG_fail;
10384 temp2 = true;
10385 }
10386 {
10387 PyThreadState* __tstate = wxPyBeginAllowThreads();
10388 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10389
10390 wxPyEndAllowThreads(__tstate);
10391 if (PyErr_Occurred()) SWIG_fail;
10392 }
10393 Py_INCREF(Py_None); resultobj = Py_None;
10394 {
10395 if (temp2)
10396 delete arg2;
10397 }
10398 return resultobj;
10399 fail:
10400 {
10401 if (temp2)
10402 delete arg2;
10403 }
10404 return NULL;
10405 }
10406
10407
10408 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10409 PyObject *resultobj;
10410 wxString *arg1 = 0 ;
10411 bool temp1 = false ;
10412 PyObject * obj0 = 0 ;
10413 char *kwnames[] = {
10414 (char *) "msg", NULL
10415 };
10416
10417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10418 {
10419 arg1 = wxString_in_helper(obj0);
10420 if (arg1 == NULL) SWIG_fail;
10421 temp1 = true;
10422 }
10423 {
10424 PyThreadState* __tstate = wxPyBeginAllowThreads();
10425 wxPyLogSysError((wxString const &)*arg1);
10426
10427 wxPyEndAllowThreads(__tstate);
10428 if (PyErr_Occurred()) SWIG_fail;
10429 }
10430 Py_INCREF(Py_None); resultobj = Py_None;
10431 {
10432 if (temp1)
10433 delete arg1;
10434 }
10435 return resultobj;
10436 fail:
10437 {
10438 if (temp1)
10439 delete arg1;
10440 }
10441 return NULL;
10442 }
10443
10444
10445 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10446 PyObject *resultobj;
10447 unsigned long arg1 ;
10448 wxString *arg2 = 0 ;
10449 bool temp2 = false ;
10450 PyObject * obj0 = 0 ;
10451 PyObject * obj1 = 0 ;
10452 char *kwnames[] = {
10453 (char *) "level",(char *) "msg", NULL
10454 };
10455
10456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10457 {
10458 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10459 if (SWIG_arg_fail(1)) SWIG_fail;
10460 }
10461 {
10462 arg2 = wxString_in_helper(obj1);
10463 if (arg2 == NULL) SWIG_fail;
10464 temp2 = true;
10465 }
10466 {
10467 PyThreadState* __tstate = wxPyBeginAllowThreads();
10468 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10469
10470 wxPyEndAllowThreads(__tstate);
10471 if (PyErr_Occurred()) SWIG_fail;
10472 }
10473 Py_INCREF(Py_None); resultobj = Py_None;
10474 {
10475 if (temp2)
10476 delete arg2;
10477 }
10478 return resultobj;
10479 fail:
10480 {
10481 if (temp2)
10482 delete arg2;
10483 }
10484 return NULL;
10485 }
10486
10487
10488 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10489 PyObject *resultobj;
10490 unsigned long arg1 ;
10491 wxString *arg2 = 0 ;
10492 bool temp2 = false ;
10493 PyObject * obj0 = 0 ;
10494 PyObject * obj1 = 0 ;
10495
10496 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10497 {
10498 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10499 if (SWIG_arg_fail(1)) SWIG_fail;
10500 }
10501 {
10502 arg2 = wxString_in_helper(obj1);
10503 if (arg2 == NULL) SWIG_fail;
10504 temp2 = true;
10505 }
10506 {
10507 PyThreadState* __tstate = wxPyBeginAllowThreads();
10508 wxPyLogTrace(arg1,(wxString const &)*arg2);
10509
10510 wxPyEndAllowThreads(__tstate);
10511 if (PyErr_Occurred()) SWIG_fail;
10512 }
10513 Py_INCREF(Py_None); resultobj = Py_None;
10514 {
10515 if (temp2)
10516 delete arg2;
10517 }
10518 return resultobj;
10519 fail:
10520 {
10521 if (temp2)
10522 delete arg2;
10523 }
10524 return NULL;
10525 }
10526
10527
10528 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10529 PyObject *resultobj;
10530 wxString *arg1 = 0 ;
10531 wxString *arg2 = 0 ;
10532 bool temp1 = false ;
10533 bool temp2 = false ;
10534 PyObject * obj0 = 0 ;
10535 PyObject * obj1 = 0 ;
10536
10537 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10538 {
10539 arg1 = wxString_in_helper(obj0);
10540 if (arg1 == NULL) SWIG_fail;
10541 temp1 = true;
10542 }
10543 {
10544 arg2 = wxString_in_helper(obj1);
10545 if (arg2 == NULL) SWIG_fail;
10546 temp2 = true;
10547 }
10548 {
10549 PyThreadState* __tstate = wxPyBeginAllowThreads();
10550 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
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 {
10561 if (temp2)
10562 delete arg2;
10563 }
10564 return resultobj;
10565 fail:
10566 {
10567 if (temp1)
10568 delete arg1;
10569 }
10570 {
10571 if (temp2)
10572 delete arg2;
10573 }
10574 return NULL;
10575 }
10576
10577
10578 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10579 int argc;
10580 PyObject *argv[3];
10581 int ii;
10582
10583 argc = PyObject_Length(args);
10584 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10585 argv[ii] = PyTuple_GetItem(args,ii);
10586 }
10587 if (argc == 2) {
10588 int _v;
10589 {
10590 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10591 }
10592 if (_v) {
10593 {
10594 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10595 }
10596 if (_v) {
10597 return _wrap_LogTrace__SWIG_1(self,args);
10598 }
10599 }
10600 }
10601 if (argc == 2) {
10602 int _v;
10603 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10604 if (_v) {
10605 {
10606 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10607 }
10608 if (_v) {
10609 return _wrap_LogTrace__SWIG_0(self,args);
10610 }
10611 }
10612 }
10613
10614 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10615 return NULL;
10616 }
10617
10618
10619 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10620 PyObject *resultobj;
10621 wxString *arg1 = 0 ;
10622 wxString *arg2 = 0 ;
10623 bool temp1 = false ;
10624 bool temp2 = false ;
10625 PyObject * obj0 = 0 ;
10626 PyObject * obj1 = 0 ;
10627 char *kwnames[] = {
10628 (char *) "title",(char *) "text", NULL
10629 };
10630
10631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10632 {
10633 arg1 = wxString_in_helper(obj0);
10634 if (arg1 == NULL) SWIG_fail;
10635 temp1 = true;
10636 }
10637 {
10638 arg2 = wxString_in_helper(obj1);
10639 if (arg2 == NULL) SWIG_fail;
10640 temp2 = true;
10641 }
10642 {
10643 PyThreadState* __tstate = wxPyBeginAllowThreads();
10644 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10645
10646 wxPyEndAllowThreads(__tstate);
10647 if (PyErr_Occurred()) SWIG_fail;
10648 }
10649 Py_INCREF(Py_None); resultobj = Py_None;
10650 {
10651 if (temp1)
10652 delete arg1;
10653 }
10654 {
10655 if (temp2)
10656 delete arg2;
10657 }
10658 return resultobj;
10659 fail:
10660 {
10661 if (temp1)
10662 delete arg1;
10663 }
10664 {
10665 if (temp2)
10666 delete arg2;
10667 }
10668 return NULL;
10669 }
10670
10671
10672 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10673 PyObject *resultobj;
10674 wxLogNull *result;
10675 char *kwnames[] = {
10676 NULL
10677 };
10678
10679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10680 {
10681 PyThreadState* __tstate = wxPyBeginAllowThreads();
10682 result = (wxLogNull *)new wxLogNull();
10683
10684 wxPyEndAllowThreads(__tstate);
10685 if (PyErr_Occurred()) SWIG_fail;
10686 }
10687 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10688 return resultobj;
10689 fail:
10690 return NULL;
10691 }
10692
10693
10694 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10695 PyObject *resultobj;
10696 wxLogNull *arg1 = (wxLogNull *) 0 ;
10697 PyObject * obj0 = 0 ;
10698 char *kwnames[] = {
10699 (char *) "self", NULL
10700 };
10701
10702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10704 if (SWIG_arg_fail(1)) SWIG_fail;
10705 {
10706 PyThreadState* __tstate = wxPyBeginAllowThreads();
10707 delete arg1;
10708
10709 wxPyEndAllowThreads(__tstate);
10710 if (PyErr_Occurred()) SWIG_fail;
10711 }
10712 Py_INCREF(Py_None); resultobj = Py_None;
10713 return resultobj;
10714 fail:
10715 return NULL;
10716 }
10717
10718
10719 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10720 PyObject *obj;
10721 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10722 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10723 Py_INCREF(obj);
10724 return Py_BuildValue((char *)"");
10725 }
10726 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10727 PyObject *resultobj;
10728 wxPyLog *result;
10729 char *kwnames[] = {
10730 NULL
10731 };
10732
10733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10734 {
10735 PyThreadState* __tstate = wxPyBeginAllowThreads();
10736 result = (wxPyLog *)new wxPyLog();
10737
10738 wxPyEndAllowThreads(__tstate);
10739 if (PyErr_Occurred()) SWIG_fail;
10740 }
10741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10742 return resultobj;
10743 fail:
10744 return NULL;
10745 }
10746
10747
10748 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10749 PyObject *resultobj;
10750 wxPyLog *arg1 = (wxPyLog *) 0 ;
10751 PyObject *arg2 = (PyObject *) 0 ;
10752 PyObject *arg3 = (PyObject *) 0 ;
10753 PyObject * obj0 = 0 ;
10754 PyObject * obj1 = 0 ;
10755 PyObject * obj2 = 0 ;
10756 char *kwnames[] = {
10757 (char *) "self",(char *) "self",(char *) "_class", NULL
10758 };
10759
10760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10762 if (SWIG_arg_fail(1)) SWIG_fail;
10763 arg2 = obj1;
10764 arg3 = obj2;
10765 {
10766 PyThreadState* __tstate = wxPyBeginAllowThreads();
10767 (arg1)->_setCallbackInfo(arg2,arg3);
10768
10769 wxPyEndAllowThreads(__tstate);
10770 if (PyErr_Occurred()) SWIG_fail;
10771 }
10772 Py_INCREF(Py_None); resultobj = Py_None;
10773 return resultobj;
10774 fail:
10775 return NULL;
10776 }
10777
10778
10779 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10780 PyObject *obj;
10781 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10782 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10783 Py_INCREF(obj);
10784 return Py_BuildValue((char *)"");
10785 }
10786 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10787 PyObject *resultobj;
10788 int arg1 ;
10789 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10790 int arg3 = (int) wxKILL_NOCHILDREN ;
10791 wxKillError result;
10792 PyObject * obj0 = 0 ;
10793 PyObject * obj1 = 0 ;
10794 PyObject * obj2 = 0 ;
10795 char *kwnames[] = {
10796 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10797 };
10798
10799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10800 {
10801 arg1 = (int)(SWIG_As_int(obj0));
10802 if (SWIG_arg_fail(1)) SWIG_fail;
10803 }
10804 if (obj1) {
10805 {
10806 arg2 = (wxSignal)(SWIG_As_int(obj1));
10807 if (SWIG_arg_fail(2)) SWIG_fail;
10808 }
10809 }
10810 if (obj2) {
10811 {
10812 arg3 = (int)(SWIG_As_int(obj2));
10813 if (SWIG_arg_fail(3)) SWIG_fail;
10814 }
10815 }
10816 {
10817 PyThreadState* __tstate = wxPyBeginAllowThreads();
10818 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10819
10820 wxPyEndAllowThreads(__tstate);
10821 if (PyErr_Occurred()) SWIG_fail;
10822 }
10823 resultobj = SWIG_From_int((result));
10824 return resultobj;
10825 fail:
10826 return NULL;
10827 }
10828
10829
10830 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10831 PyObject *resultobj;
10832 int arg1 ;
10833 bool result;
10834 PyObject * obj0 = 0 ;
10835 char *kwnames[] = {
10836 (char *) "pid", NULL
10837 };
10838
10839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10840 {
10841 arg1 = (int)(SWIG_As_int(obj0));
10842 if (SWIG_arg_fail(1)) SWIG_fail;
10843 }
10844 {
10845 PyThreadState* __tstate = wxPyBeginAllowThreads();
10846 result = (bool)wxPyProcess::Exists(arg1);
10847
10848 wxPyEndAllowThreads(__tstate);
10849 if (PyErr_Occurred()) SWIG_fail;
10850 }
10851 {
10852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10853 }
10854 return resultobj;
10855 fail:
10856 return NULL;
10857 }
10858
10859
10860 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10861 PyObject *resultobj;
10862 wxString *arg1 = 0 ;
10863 int arg2 = (int) wxEXEC_ASYNC ;
10864 wxPyProcess *result;
10865 bool temp1 = false ;
10866 PyObject * obj0 = 0 ;
10867 PyObject * obj1 = 0 ;
10868 char *kwnames[] = {
10869 (char *) "cmd",(char *) "flags", NULL
10870 };
10871
10872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10873 {
10874 arg1 = wxString_in_helper(obj0);
10875 if (arg1 == NULL) SWIG_fail;
10876 temp1 = true;
10877 }
10878 if (obj1) {
10879 {
10880 arg2 = (int)(SWIG_As_int(obj1));
10881 if (SWIG_arg_fail(2)) SWIG_fail;
10882 }
10883 }
10884 {
10885 PyThreadState* __tstate = wxPyBeginAllowThreads();
10886 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10887
10888 wxPyEndAllowThreads(__tstate);
10889 if (PyErr_Occurred()) SWIG_fail;
10890 }
10891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10892 {
10893 if (temp1)
10894 delete arg1;
10895 }
10896 return resultobj;
10897 fail:
10898 {
10899 if (temp1)
10900 delete arg1;
10901 }
10902 return NULL;
10903 }
10904
10905
10906 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10907 PyObject *resultobj;
10908 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10909 int arg2 = (int) -1 ;
10910 wxPyProcess *result;
10911 PyObject * obj0 = 0 ;
10912 PyObject * obj1 = 0 ;
10913 char *kwnames[] = {
10914 (char *) "parent",(char *) "id", NULL
10915 };
10916
10917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10918 if (obj0) {
10919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10920 if (SWIG_arg_fail(1)) SWIG_fail;
10921 }
10922 if (obj1) {
10923 {
10924 arg2 = (int)(SWIG_As_int(obj1));
10925 if (SWIG_arg_fail(2)) SWIG_fail;
10926 }
10927 }
10928 {
10929 PyThreadState* __tstate = wxPyBeginAllowThreads();
10930 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10931
10932 wxPyEndAllowThreads(__tstate);
10933 if (PyErr_Occurred()) SWIG_fail;
10934 }
10935 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10936 return resultobj;
10937 fail:
10938 return NULL;
10939 }
10940
10941
10942 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10943 PyObject *resultobj;
10944 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10945 PyObject *arg2 = (PyObject *) 0 ;
10946 PyObject *arg3 = (PyObject *) 0 ;
10947 PyObject * obj0 = 0 ;
10948 PyObject * obj1 = 0 ;
10949 PyObject * obj2 = 0 ;
10950 char *kwnames[] = {
10951 (char *) "self",(char *) "self",(char *) "_class", NULL
10952 };
10953
10954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10956 if (SWIG_arg_fail(1)) SWIG_fail;
10957 arg2 = obj1;
10958 arg3 = obj2;
10959 {
10960 PyThreadState* __tstate = wxPyBeginAllowThreads();
10961 (arg1)->_setCallbackInfo(arg2,arg3);
10962
10963 wxPyEndAllowThreads(__tstate);
10964 if (PyErr_Occurred()) SWIG_fail;
10965 }
10966 Py_INCREF(Py_None); resultobj = Py_None;
10967 return resultobj;
10968 fail:
10969 return NULL;
10970 }
10971
10972
10973 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10974 PyObject *resultobj;
10975 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10976 int arg2 ;
10977 int arg3 ;
10978 PyObject * obj0 = 0 ;
10979 PyObject * obj1 = 0 ;
10980 PyObject * obj2 = 0 ;
10981 char *kwnames[] = {
10982 (char *) "self",(char *) "pid",(char *) "status", NULL
10983 };
10984
10985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10987 if (SWIG_arg_fail(1)) SWIG_fail;
10988 {
10989 arg2 = (int)(SWIG_As_int(obj1));
10990 if (SWIG_arg_fail(2)) SWIG_fail;
10991 }
10992 {
10993 arg3 = (int)(SWIG_As_int(obj2));
10994 if (SWIG_arg_fail(3)) SWIG_fail;
10995 }
10996 {
10997 PyThreadState* __tstate = wxPyBeginAllowThreads();
10998 (arg1)->base_OnTerminate(arg2,arg3);
10999
11000 wxPyEndAllowThreads(__tstate);
11001 if (PyErr_Occurred()) SWIG_fail;
11002 }
11003 Py_INCREF(Py_None); resultobj = Py_None;
11004 return resultobj;
11005 fail:
11006 return NULL;
11007 }
11008
11009
11010 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11011 PyObject *resultobj;
11012 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11013 PyObject * obj0 = 0 ;
11014 char *kwnames[] = {
11015 (char *) "self", NULL
11016 };
11017
11018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11020 if (SWIG_arg_fail(1)) SWIG_fail;
11021 {
11022 PyThreadState* __tstate = wxPyBeginAllowThreads();
11023 (arg1)->Redirect();
11024
11025 wxPyEndAllowThreads(__tstate);
11026 if (PyErr_Occurred()) SWIG_fail;
11027 }
11028 Py_INCREF(Py_None); resultobj = Py_None;
11029 return resultobj;
11030 fail:
11031 return NULL;
11032 }
11033
11034
11035 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11036 PyObject *resultobj;
11037 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11038 bool result;
11039 PyObject * obj0 = 0 ;
11040 char *kwnames[] = {
11041 (char *) "self", NULL
11042 };
11043
11044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11046 if (SWIG_arg_fail(1)) SWIG_fail;
11047 {
11048 PyThreadState* __tstate = wxPyBeginAllowThreads();
11049 result = (bool)(arg1)->IsRedirected();
11050
11051 wxPyEndAllowThreads(__tstate);
11052 if (PyErr_Occurred()) SWIG_fail;
11053 }
11054 {
11055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11056 }
11057 return resultobj;
11058 fail:
11059 return NULL;
11060 }
11061
11062
11063 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11064 PyObject *resultobj;
11065 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11066 PyObject * obj0 = 0 ;
11067 char *kwnames[] = {
11068 (char *) "self", NULL
11069 };
11070
11071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11073 if (SWIG_arg_fail(1)) SWIG_fail;
11074 {
11075 PyThreadState* __tstate = wxPyBeginAllowThreads();
11076 (arg1)->Detach();
11077
11078 wxPyEndAllowThreads(__tstate);
11079 if (PyErr_Occurred()) SWIG_fail;
11080 }
11081 Py_INCREF(Py_None); resultobj = Py_None;
11082 return resultobj;
11083 fail:
11084 return NULL;
11085 }
11086
11087
11088 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11089 PyObject *resultobj;
11090 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11091 wxInputStream *result;
11092 PyObject * obj0 = 0 ;
11093 char *kwnames[] = {
11094 (char *) "self", NULL
11095 };
11096
11097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11099 if (SWIG_arg_fail(1)) SWIG_fail;
11100 {
11101 PyThreadState* __tstate = wxPyBeginAllowThreads();
11102 result = (wxInputStream *)(arg1)->GetInputStream();
11103
11104 wxPyEndAllowThreads(__tstate);
11105 if (PyErr_Occurred()) SWIG_fail;
11106 }
11107 {
11108 wxPyInputStream * _ptr = NULL;
11109
11110 if (result) {
11111 _ptr = new wxPyInputStream(result);
11112 }
11113 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11114 }
11115 return resultobj;
11116 fail:
11117 return NULL;
11118 }
11119
11120
11121 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11122 PyObject *resultobj;
11123 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11124 wxInputStream *result;
11125 PyObject * obj0 = 0 ;
11126 char *kwnames[] = {
11127 (char *) "self", NULL
11128 };
11129
11130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11132 if (SWIG_arg_fail(1)) SWIG_fail;
11133 {
11134 PyThreadState* __tstate = wxPyBeginAllowThreads();
11135 result = (wxInputStream *)(arg1)->GetErrorStream();
11136
11137 wxPyEndAllowThreads(__tstate);
11138 if (PyErr_Occurred()) SWIG_fail;
11139 }
11140 {
11141 wxPyInputStream * _ptr = NULL;
11142
11143 if (result) {
11144 _ptr = new wxPyInputStream(result);
11145 }
11146 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11147 }
11148 return resultobj;
11149 fail:
11150 return NULL;
11151 }
11152
11153
11154 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11155 PyObject *resultobj;
11156 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11157 wxOutputStream *result;
11158 PyObject * obj0 = 0 ;
11159 char *kwnames[] = {
11160 (char *) "self", NULL
11161 };
11162
11163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11165 if (SWIG_arg_fail(1)) SWIG_fail;
11166 {
11167 PyThreadState* __tstate = wxPyBeginAllowThreads();
11168 result = (wxOutputStream *)(arg1)->GetOutputStream();
11169
11170 wxPyEndAllowThreads(__tstate);
11171 if (PyErr_Occurred()) SWIG_fail;
11172 }
11173 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11174 return resultobj;
11175 fail:
11176 return NULL;
11177 }
11178
11179
11180 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11181 PyObject *resultobj;
11182 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11183 PyObject * obj0 = 0 ;
11184 char *kwnames[] = {
11185 (char *) "self", NULL
11186 };
11187
11188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11190 if (SWIG_arg_fail(1)) SWIG_fail;
11191 {
11192 PyThreadState* __tstate = wxPyBeginAllowThreads();
11193 (arg1)->CloseOutput();
11194
11195 wxPyEndAllowThreads(__tstate);
11196 if (PyErr_Occurred()) SWIG_fail;
11197 }
11198 Py_INCREF(Py_None); resultobj = Py_None;
11199 return resultobj;
11200 fail:
11201 return NULL;
11202 }
11203
11204
11205 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11206 PyObject *resultobj;
11207 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11208 bool result;
11209 PyObject * obj0 = 0 ;
11210 char *kwnames[] = {
11211 (char *) "self", NULL
11212 };
11213
11214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11216 if (SWIG_arg_fail(1)) SWIG_fail;
11217 {
11218 PyThreadState* __tstate = wxPyBeginAllowThreads();
11219 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11220
11221 wxPyEndAllowThreads(__tstate);
11222 if (PyErr_Occurred()) SWIG_fail;
11223 }
11224 {
11225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11226 }
11227 return resultobj;
11228 fail:
11229 return NULL;
11230 }
11231
11232
11233 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11234 PyObject *resultobj;
11235 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11236 bool result;
11237 PyObject * obj0 = 0 ;
11238 char *kwnames[] = {
11239 (char *) "self", NULL
11240 };
11241
11242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11244 if (SWIG_arg_fail(1)) SWIG_fail;
11245 {
11246 PyThreadState* __tstate = wxPyBeginAllowThreads();
11247 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11248
11249 wxPyEndAllowThreads(__tstate);
11250 if (PyErr_Occurred()) SWIG_fail;
11251 }
11252 {
11253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11254 }
11255 return resultobj;
11256 fail:
11257 return NULL;
11258 }
11259
11260
11261 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11262 PyObject *resultobj;
11263 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11264 bool result;
11265 PyObject * obj0 = 0 ;
11266 char *kwnames[] = {
11267 (char *) "self", NULL
11268 };
11269
11270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11272 if (SWIG_arg_fail(1)) SWIG_fail;
11273 {
11274 PyThreadState* __tstate = wxPyBeginAllowThreads();
11275 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11276
11277 wxPyEndAllowThreads(__tstate);
11278 if (PyErr_Occurred()) SWIG_fail;
11279 }
11280 {
11281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11282 }
11283 return resultobj;
11284 fail:
11285 return NULL;
11286 }
11287
11288
11289 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11290 PyObject *obj;
11291 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11292 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11293 Py_INCREF(obj);
11294 return Py_BuildValue((char *)"");
11295 }
11296 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11297 PyObject *resultobj;
11298 int arg1 = (int) 0 ;
11299 int arg2 = (int) 0 ;
11300 int arg3 = (int) 0 ;
11301 wxProcessEvent *result;
11302 PyObject * obj0 = 0 ;
11303 PyObject * obj1 = 0 ;
11304 PyObject * obj2 = 0 ;
11305 char *kwnames[] = {
11306 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11307 };
11308
11309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11310 if (obj0) {
11311 {
11312 arg1 = (int)(SWIG_As_int(obj0));
11313 if (SWIG_arg_fail(1)) SWIG_fail;
11314 }
11315 }
11316 if (obj1) {
11317 {
11318 arg2 = (int)(SWIG_As_int(obj1));
11319 if (SWIG_arg_fail(2)) SWIG_fail;
11320 }
11321 }
11322 if (obj2) {
11323 {
11324 arg3 = (int)(SWIG_As_int(obj2));
11325 if (SWIG_arg_fail(3)) SWIG_fail;
11326 }
11327 }
11328 {
11329 PyThreadState* __tstate = wxPyBeginAllowThreads();
11330 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11331
11332 wxPyEndAllowThreads(__tstate);
11333 if (PyErr_Occurred()) SWIG_fail;
11334 }
11335 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11336 return resultobj;
11337 fail:
11338 return NULL;
11339 }
11340
11341
11342 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11343 PyObject *resultobj;
11344 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11345 int result;
11346 PyObject * obj0 = 0 ;
11347 char *kwnames[] = {
11348 (char *) "self", NULL
11349 };
11350
11351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11353 if (SWIG_arg_fail(1)) SWIG_fail;
11354 {
11355 PyThreadState* __tstate = wxPyBeginAllowThreads();
11356 result = (int)(arg1)->GetPid();
11357
11358 wxPyEndAllowThreads(__tstate);
11359 if (PyErr_Occurred()) SWIG_fail;
11360 }
11361 {
11362 resultobj = SWIG_From_int((int)(result));
11363 }
11364 return resultobj;
11365 fail:
11366 return NULL;
11367 }
11368
11369
11370 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11371 PyObject *resultobj;
11372 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11373 int result;
11374 PyObject * obj0 = 0 ;
11375 char *kwnames[] = {
11376 (char *) "self", NULL
11377 };
11378
11379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11381 if (SWIG_arg_fail(1)) SWIG_fail;
11382 {
11383 PyThreadState* __tstate = wxPyBeginAllowThreads();
11384 result = (int)(arg1)->GetExitCode();
11385
11386 wxPyEndAllowThreads(__tstate);
11387 if (PyErr_Occurred()) SWIG_fail;
11388 }
11389 {
11390 resultobj = SWIG_From_int((int)(result));
11391 }
11392 return resultobj;
11393 fail:
11394 return NULL;
11395 }
11396
11397
11398 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11399 PyObject *resultobj;
11400 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11401 int arg2 ;
11402 PyObject * obj0 = 0 ;
11403 PyObject * obj1 = 0 ;
11404 char *kwnames[] = {
11405 (char *) "self",(char *) "m_pid", NULL
11406 };
11407
11408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11410 if (SWIG_arg_fail(1)) SWIG_fail;
11411 {
11412 arg2 = (int)(SWIG_As_int(obj1));
11413 if (SWIG_arg_fail(2)) SWIG_fail;
11414 }
11415 if (arg1) (arg1)->m_pid = arg2;
11416
11417 Py_INCREF(Py_None); resultobj = Py_None;
11418 return resultobj;
11419 fail:
11420 return NULL;
11421 }
11422
11423
11424 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11425 PyObject *resultobj;
11426 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11427 int result;
11428 PyObject * obj0 = 0 ;
11429 char *kwnames[] = {
11430 (char *) "self", NULL
11431 };
11432
11433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11435 if (SWIG_arg_fail(1)) SWIG_fail;
11436 result = (int) ((arg1)->m_pid);
11437
11438 {
11439 resultobj = SWIG_From_int((int)(result));
11440 }
11441 return resultobj;
11442 fail:
11443 return NULL;
11444 }
11445
11446
11447 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11448 PyObject *resultobj;
11449 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11450 int arg2 ;
11451 PyObject * obj0 = 0 ;
11452 PyObject * obj1 = 0 ;
11453 char *kwnames[] = {
11454 (char *) "self",(char *) "m_exitcode", NULL
11455 };
11456
11457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11459 if (SWIG_arg_fail(1)) SWIG_fail;
11460 {
11461 arg2 = (int)(SWIG_As_int(obj1));
11462 if (SWIG_arg_fail(2)) SWIG_fail;
11463 }
11464 if (arg1) (arg1)->m_exitcode = arg2;
11465
11466 Py_INCREF(Py_None); resultobj = Py_None;
11467 return resultobj;
11468 fail:
11469 return NULL;
11470 }
11471
11472
11473 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11474 PyObject *resultobj;
11475 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11476 int result;
11477 PyObject * obj0 = 0 ;
11478 char *kwnames[] = {
11479 (char *) "self", NULL
11480 };
11481
11482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11484 if (SWIG_arg_fail(1)) SWIG_fail;
11485 result = (int) ((arg1)->m_exitcode);
11486
11487 {
11488 resultobj = SWIG_From_int((int)(result));
11489 }
11490 return resultobj;
11491 fail:
11492 return NULL;
11493 }
11494
11495
11496 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11497 PyObject *obj;
11498 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11499 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11500 Py_INCREF(obj);
11501 return Py_BuildValue((char *)"");
11502 }
11503 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11504 PyObject *resultobj;
11505 wxString *arg1 = 0 ;
11506 int arg2 = (int) wxEXEC_ASYNC ;
11507 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11508 long result;
11509 bool temp1 = false ;
11510 PyObject * obj0 = 0 ;
11511 PyObject * obj1 = 0 ;
11512 PyObject * obj2 = 0 ;
11513 char *kwnames[] = {
11514 (char *) "command",(char *) "flags",(char *) "process", NULL
11515 };
11516
11517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11518 {
11519 arg1 = wxString_in_helper(obj0);
11520 if (arg1 == NULL) SWIG_fail;
11521 temp1 = true;
11522 }
11523 if (obj1) {
11524 {
11525 arg2 = (int)(SWIG_As_int(obj1));
11526 if (SWIG_arg_fail(2)) SWIG_fail;
11527 }
11528 }
11529 if (obj2) {
11530 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11531 if (SWIG_arg_fail(3)) SWIG_fail;
11532 }
11533 {
11534 if (!wxPyCheckForApp()) SWIG_fail;
11535 PyThreadState* __tstate = wxPyBeginAllowThreads();
11536 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11537
11538 wxPyEndAllowThreads(__tstate);
11539 if (PyErr_Occurred()) SWIG_fail;
11540 }
11541 {
11542 resultobj = SWIG_From_long((long)(result));
11543 }
11544 {
11545 if (temp1)
11546 delete arg1;
11547 }
11548 return resultobj;
11549 fail:
11550 {
11551 if (temp1)
11552 delete arg1;
11553 }
11554 return NULL;
11555 }
11556
11557
11558 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11559 PyObject *resultobj;
11560 long arg1 ;
11561 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11562 wxKillError *arg3 = (wxKillError *) 0 ;
11563 int arg4 = (int) wxKILL_NOCHILDREN ;
11564 int result;
11565 wxKillError temp3 ;
11566 PyObject * obj0 = 0 ;
11567 PyObject * obj1 = 0 ;
11568 PyObject * obj2 = 0 ;
11569 char *kwnames[] = {
11570 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11571 };
11572
11573 {
11574 arg3 = &temp3;
11575 }
11576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11577 {
11578 arg1 = (long)(SWIG_As_long(obj0));
11579 if (SWIG_arg_fail(1)) SWIG_fail;
11580 }
11581 if (obj1) {
11582 {
11583 arg2 = (wxSignal)(SWIG_As_int(obj1));
11584 if (SWIG_arg_fail(2)) SWIG_fail;
11585 }
11586 }
11587 if (obj2) {
11588 {
11589 arg4 = (int)(SWIG_As_int(obj2));
11590 if (SWIG_arg_fail(4)) SWIG_fail;
11591 }
11592 }
11593 {
11594 PyThreadState* __tstate = wxPyBeginAllowThreads();
11595 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11596
11597 wxPyEndAllowThreads(__tstate);
11598 if (PyErr_Occurred()) SWIG_fail;
11599 }
11600 {
11601 resultobj = SWIG_From_int((int)(result));
11602 }
11603 {
11604 PyObject* o;
11605 o = PyInt_FromLong((long) (*arg3));
11606 resultobj = t_output_helper(resultobj, o);
11607 }
11608 return resultobj;
11609 fail:
11610 return NULL;
11611 }
11612
11613
11614 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11615 PyObject *resultobj;
11616 int arg1 = (int) wxJOYSTICK1 ;
11617 wxJoystick *result;
11618 PyObject * obj0 = 0 ;
11619 char *kwnames[] = {
11620 (char *) "joystick", NULL
11621 };
11622
11623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11624 if (obj0) {
11625 {
11626 arg1 = (int)(SWIG_As_int(obj0));
11627 if (SWIG_arg_fail(1)) SWIG_fail;
11628 }
11629 }
11630 {
11631 if (!wxPyCheckForApp()) SWIG_fail;
11632 PyThreadState* __tstate = wxPyBeginAllowThreads();
11633 result = (wxJoystick *)new wxJoystick(arg1);
11634
11635 wxPyEndAllowThreads(__tstate);
11636 if (PyErr_Occurred()) SWIG_fail;
11637 }
11638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11639 return resultobj;
11640 fail:
11641 return NULL;
11642 }
11643
11644
11645 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11646 PyObject *resultobj;
11647 wxJoystick *arg1 = (wxJoystick *) 0 ;
11648 PyObject * obj0 = 0 ;
11649 char *kwnames[] = {
11650 (char *) "self", NULL
11651 };
11652
11653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11655 if (SWIG_arg_fail(1)) SWIG_fail;
11656 {
11657 PyThreadState* __tstate = wxPyBeginAllowThreads();
11658 delete arg1;
11659
11660 wxPyEndAllowThreads(__tstate);
11661 if (PyErr_Occurred()) SWIG_fail;
11662 }
11663 Py_INCREF(Py_None); resultobj = Py_None;
11664 return resultobj;
11665 fail:
11666 return NULL;
11667 }
11668
11669
11670 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11671 PyObject *resultobj;
11672 wxJoystick *arg1 = (wxJoystick *) 0 ;
11673 wxPoint result;
11674 PyObject * obj0 = 0 ;
11675 char *kwnames[] = {
11676 (char *) "self", NULL
11677 };
11678
11679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11681 if (SWIG_arg_fail(1)) SWIG_fail;
11682 {
11683 PyThreadState* __tstate = wxPyBeginAllowThreads();
11684 result = (arg1)->GetPosition();
11685
11686 wxPyEndAllowThreads(__tstate);
11687 if (PyErr_Occurred()) SWIG_fail;
11688 }
11689 {
11690 wxPoint * resultptr;
11691 resultptr = new wxPoint((wxPoint &)(result));
11692 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11693 }
11694 return resultobj;
11695 fail:
11696 return NULL;
11697 }
11698
11699
11700 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11701 PyObject *resultobj;
11702 wxJoystick *arg1 = (wxJoystick *) 0 ;
11703 int result;
11704 PyObject * obj0 = 0 ;
11705 char *kwnames[] = {
11706 (char *) "self", NULL
11707 };
11708
11709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11711 if (SWIG_arg_fail(1)) SWIG_fail;
11712 {
11713 PyThreadState* __tstate = wxPyBeginAllowThreads();
11714 result = (int)(arg1)->GetZPosition();
11715
11716 wxPyEndAllowThreads(__tstate);
11717 if (PyErr_Occurred()) SWIG_fail;
11718 }
11719 {
11720 resultobj = SWIG_From_int((int)(result));
11721 }
11722 return resultobj;
11723 fail:
11724 return NULL;
11725 }
11726
11727
11728 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11729 PyObject *resultobj;
11730 wxJoystick *arg1 = (wxJoystick *) 0 ;
11731 int result;
11732 PyObject * obj0 = 0 ;
11733 char *kwnames[] = {
11734 (char *) "self", NULL
11735 };
11736
11737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11739 if (SWIG_arg_fail(1)) SWIG_fail;
11740 {
11741 PyThreadState* __tstate = wxPyBeginAllowThreads();
11742 result = (int)(arg1)->GetButtonState();
11743
11744 wxPyEndAllowThreads(__tstate);
11745 if (PyErr_Occurred()) SWIG_fail;
11746 }
11747 {
11748 resultobj = SWIG_From_int((int)(result));
11749 }
11750 return resultobj;
11751 fail:
11752 return NULL;
11753 }
11754
11755
11756 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11757 PyObject *resultobj;
11758 wxJoystick *arg1 = (wxJoystick *) 0 ;
11759 int result;
11760 PyObject * obj0 = 0 ;
11761 char *kwnames[] = {
11762 (char *) "self", NULL
11763 };
11764
11765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11767 if (SWIG_arg_fail(1)) SWIG_fail;
11768 {
11769 PyThreadState* __tstate = wxPyBeginAllowThreads();
11770 result = (int)(arg1)->GetPOVPosition();
11771
11772 wxPyEndAllowThreads(__tstate);
11773 if (PyErr_Occurred()) SWIG_fail;
11774 }
11775 {
11776 resultobj = SWIG_From_int((int)(result));
11777 }
11778 return resultobj;
11779 fail:
11780 return NULL;
11781 }
11782
11783
11784 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11785 PyObject *resultobj;
11786 wxJoystick *arg1 = (wxJoystick *) 0 ;
11787 int result;
11788 PyObject * obj0 = 0 ;
11789 char *kwnames[] = {
11790 (char *) "self", NULL
11791 };
11792
11793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11795 if (SWIG_arg_fail(1)) SWIG_fail;
11796 {
11797 PyThreadState* __tstate = wxPyBeginAllowThreads();
11798 result = (int)(arg1)->GetPOVCTSPosition();
11799
11800 wxPyEndAllowThreads(__tstate);
11801 if (PyErr_Occurred()) SWIG_fail;
11802 }
11803 {
11804 resultobj = SWIG_From_int((int)(result));
11805 }
11806 return resultobj;
11807 fail:
11808 return NULL;
11809 }
11810
11811
11812 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11813 PyObject *resultobj;
11814 wxJoystick *arg1 = (wxJoystick *) 0 ;
11815 int result;
11816 PyObject * obj0 = 0 ;
11817 char *kwnames[] = {
11818 (char *) "self", NULL
11819 };
11820
11821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11823 if (SWIG_arg_fail(1)) SWIG_fail;
11824 {
11825 PyThreadState* __tstate = wxPyBeginAllowThreads();
11826 result = (int)(arg1)->GetRudderPosition();
11827
11828 wxPyEndAllowThreads(__tstate);
11829 if (PyErr_Occurred()) SWIG_fail;
11830 }
11831 {
11832 resultobj = SWIG_From_int((int)(result));
11833 }
11834 return resultobj;
11835 fail:
11836 return NULL;
11837 }
11838
11839
11840 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11841 PyObject *resultobj;
11842 wxJoystick *arg1 = (wxJoystick *) 0 ;
11843 int result;
11844 PyObject * obj0 = 0 ;
11845 char *kwnames[] = {
11846 (char *) "self", NULL
11847 };
11848
11849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11851 if (SWIG_arg_fail(1)) SWIG_fail;
11852 {
11853 PyThreadState* __tstate = wxPyBeginAllowThreads();
11854 result = (int)(arg1)->GetUPosition();
11855
11856 wxPyEndAllowThreads(__tstate);
11857 if (PyErr_Occurred()) SWIG_fail;
11858 }
11859 {
11860 resultobj = SWIG_From_int((int)(result));
11861 }
11862 return resultobj;
11863 fail:
11864 return NULL;
11865 }
11866
11867
11868 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11869 PyObject *resultobj;
11870 wxJoystick *arg1 = (wxJoystick *) 0 ;
11871 int result;
11872 PyObject * obj0 = 0 ;
11873 char *kwnames[] = {
11874 (char *) "self", NULL
11875 };
11876
11877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11879 if (SWIG_arg_fail(1)) SWIG_fail;
11880 {
11881 PyThreadState* __tstate = wxPyBeginAllowThreads();
11882 result = (int)(arg1)->GetVPosition();
11883
11884 wxPyEndAllowThreads(__tstate);
11885 if (PyErr_Occurred()) SWIG_fail;
11886 }
11887 {
11888 resultobj = SWIG_From_int((int)(result));
11889 }
11890 return resultobj;
11891 fail:
11892 return NULL;
11893 }
11894
11895
11896 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11897 PyObject *resultobj;
11898 wxJoystick *arg1 = (wxJoystick *) 0 ;
11899 int result;
11900 PyObject * obj0 = 0 ;
11901 char *kwnames[] = {
11902 (char *) "self", NULL
11903 };
11904
11905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11907 if (SWIG_arg_fail(1)) SWIG_fail;
11908 {
11909 PyThreadState* __tstate = wxPyBeginAllowThreads();
11910 result = (int)(arg1)->GetMovementThreshold();
11911
11912 wxPyEndAllowThreads(__tstate);
11913 if (PyErr_Occurred()) SWIG_fail;
11914 }
11915 {
11916 resultobj = SWIG_From_int((int)(result));
11917 }
11918 return resultobj;
11919 fail:
11920 return NULL;
11921 }
11922
11923
11924 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11925 PyObject *resultobj;
11926 wxJoystick *arg1 = (wxJoystick *) 0 ;
11927 int arg2 ;
11928 PyObject * obj0 = 0 ;
11929 PyObject * obj1 = 0 ;
11930 char *kwnames[] = {
11931 (char *) "self",(char *) "threshold", NULL
11932 };
11933
11934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11936 if (SWIG_arg_fail(1)) SWIG_fail;
11937 {
11938 arg2 = (int)(SWIG_As_int(obj1));
11939 if (SWIG_arg_fail(2)) SWIG_fail;
11940 }
11941 {
11942 PyThreadState* __tstate = wxPyBeginAllowThreads();
11943 (arg1)->SetMovementThreshold(arg2);
11944
11945 wxPyEndAllowThreads(__tstate);
11946 if (PyErr_Occurred()) SWIG_fail;
11947 }
11948 Py_INCREF(Py_None); resultobj = Py_None;
11949 return resultobj;
11950 fail:
11951 return NULL;
11952 }
11953
11954
11955 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11956 PyObject *resultobj;
11957 wxJoystick *arg1 = (wxJoystick *) 0 ;
11958 bool result;
11959 PyObject * obj0 = 0 ;
11960 char *kwnames[] = {
11961 (char *) "self", NULL
11962 };
11963
11964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11966 if (SWIG_arg_fail(1)) SWIG_fail;
11967 {
11968 PyThreadState* __tstate = wxPyBeginAllowThreads();
11969 result = (bool)(arg1)->IsOk();
11970
11971 wxPyEndAllowThreads(__tstate);
11972 if (PyErr_Occurred()) SWIG_fail;
11973 }
11974 {
11975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11976 }
11977 return resultobj;
11978 fail:
11979 return NULL;
11980 }
11981
11982
11983 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11984 PyObject *resultobj;
11985 wxJoystick *arg1 = (wxJoystick *) 0 ;
11986 int result;
11987 PyObject * obj0 = 0 ;
11988 char *kwnames[] = {
11989 (char *) "self", NULL
11990 };
11991
11992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11994 if (SWIG_arg_fail(1)) SWIG_fail;
11995 {
11996 PyThreadState* __tstate = wxPyBeginAllowThreads();
11997 result = (int)(arg1)->GetNumberJoysticks();
11998
11999 wxPyEndAllowThreads(__tstate);
12000 if (PyErr_Occurred()) SWIG_fail;
12001 }
12002 {
12003 resultobj = SWIG_From_int((int)(result));
12004 }
12005 return resultobj;
12006 fail:
12007 return NULL;
12008 }
12009
12010
12011 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12012 PyObject *resultobj;
12013 wxJoystick *arg1 = (wxJoystick *) 0 ;
12014 int result;
12015 PyObject * obj0 = 0 ;
12016 char *kwnames[] = {
12017 (char *) "self", NULL
12018 };
12019
12020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12022 if (SWIG_arg_fail(1)) SWIG_fail;
12023 {
12024 PyThreadState* __tstate = wxPyBeginAllowThreads();
12025 result = (int)(arg1)->GetManufacturerId();
12026
12027 wxPyEndAllowThreads(__tstate);
12028 if (PyErr_Occurred()) SWIG_fail;
12029 }
12030 {
12031 resultobj = SWIG_From_int((int)(result));
12032 }
12033 return resultobj;
12034 fail:
12035 return NULL;
12036 }
12037
12038
12039 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12040 PyObject *resultobj;
12041 wxJoystick *arg1 = (wxJoystick *) 0 ;
12042 int result;
12043 PyObject * obj0 = 0 ;
12044 char *kwnames[] = {
12045 (char *) "self", NULL
12046 };
12047
12048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12050 if (SWIG_arg_fail(1)) SWIG_fail;
12051 {
12052 PyThreadState* __tstate = wxPyBeginAllowThreads();
12053 result = (int)(arg1)->GetProductId();
12054
12055 wxPyEndAllowThreads(__tstate);
12056 if (PyErr_Occurred()) SWIG_fail;
12057 }
12058 {
12059 resultobj = SWIG_From_int((int)(result));
12060 }
12061 return resultobj;
12062 fail:
12063 return NULL;
12064 }
12065
12066
12067 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12068 PyObject *resultobj;
12069 wxJoystick *arg1 = (wxJoystick *) 0 ;
12070 wxString result;
12071 PyObject * obj0 = 0 ;
12072 char *kwnames[] = {
12073 (char *) "self", NULL
12074 };
12075
12076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12078 if (SWIG_arg_fail(1)) SWIG_fail;
12079 {
12080 PyThreadState* __tstate = wxPyBeginAllowThreads();
12081 result = (arg1)->GetProductName();
12082
12083 wxPyEndAllowThreads(__tstate);
12084 if (PyErr_Occurred()) SWIG_fail;
12085 }
12086 {
12087 #if wxUSE_UNICODE
12088 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12089 #else
12090 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12091 #endif
12092 }
12093 return resultobj;
12094 fail:
12095 return NULL;
12096 }
12097
12098
12099 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12100 PyObject *resultobj;
12101 wxJoystick *arg1 = (wxJoystick *) 0 ;
12102 int result;
12103 PyObject * obj0 = 0 ;
12104 char *kwnames[] = {
12105 (char *) "self", NULL
12106 };
12107
12108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12110 if (SWIG_arg_fail(1)) SWIG_fail;
12111 {
12112 PyThreadState* __tstate = wxPyBeginAllowThreads();
12113 result = (int)(arg1)->GetXMin();
12114
12115 wxPyEndAllowThreads(__tstate);
12116 if (PyErr_Occurred()) SWIG_fail;
12117 }
12118 {
12119 resultobj = SWIG_From_int((int)(result));
12120 }
12121 return resultobj;
12122 fail:
12123 return NULL;
12124 }
12125
12126
12127 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12128 PyObject *resultobj;
12129 wxJoystick *arg1 = (wxJoystick *) 0 ;
12130 int result;
12131 PyObject * obj0 = 0 ;
12132 char *kwnames[] = {
12133 (char *) "self", NULL
12134 };
12135
12136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12138 if (SWIG_arg_fail(1)) SWIG_fail;
12139 {
12140 PyThreadState* __tstate = wxPyBeginAllowThreads();
12141 result = (int)(arg1)->GetYMin();
12142
12143 wxPyEndAllowThreads(__tstate);
12144 if (PyErr_Occurred()) SWIG_fail;
12145 }
12146 {
12147 resultobj = SWIG_From_int((int)(result));
12148 }
12149 return resultobj;
12150 fail:
12151 return NULL;
12152 }
12153
12154
12155 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12156 PyObject *resultobj;
12157 wxJoystick *arg1 = (wxJoystick *) 0 ;
12158 int result;
12159 PyObject * obj0 = 0 ;
12160 char *kwnames[] = {
12161 (char *) "self", NULL
12162 };
12163
12164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12166 if (SWIG_arg_fail(1)) SWIG_fail;
12167 {
12168 PyThreadState* __tstate = wxPyBeginAllowThreads();
12169 result = (int)(arg1)->GetZMin();
12170
12171 wxPyEndAllowThreads(__tstate);
12172 if (PyErr_Occurred()) SWIG_fail;
12173 }
12174 {
12175 resultobj = SWIG_From_int((int)(result));
12176 }
12177 return resultobj;
12178 fail:
12179 return NULL;
12180 }
12181
12182
12183 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12184 PyObject *resultobj;
12185 wxJoystick *arg1 = (wxJoystick *) 0 ;
12186 int result;
12187 PyObject * obj0 = 0 ;
12188 char *kwnames[] = {
12189 (char *) "self", NULL
12190 };
12191
12192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12194 if (SWIG_arg_fail(1)) SWIG_fail;
12195 {
12196 PyThreadState* __tstate = wxPyBeginAllowThreads();
12197 result = (int)(arg1)->GetXMax();
12198
12199 wxPyEndAllowThreads(__tstate);
12200 if (PyErr_Occurred()) SWIG_fail;
12201 }
12202 {
12203 resultobj = SWIG_From_int((int)(result));
12204 }
12205 return resultobj;
12206 fail:
12207 return NULL;
12208 }
12209
12210
12211 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12212 PyObject *resultobj;
12213 wxJoystick *arg1 = (wxJoystick *) 0 ;
12214 int result;
12215 PyObject * obj0 = 0 ;
12216 char *kwnames[] = {
12217 (char *) "self", NULL
12218 };
12219
12220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12222 if (SWIG_arg_fail(1)) SWIG_fail;
12223 {
12224 PyThreadState* __tstate = wxPyBeginAllowThreads();
12225 result = (int)(arg1)->GetYMax();
12226
12227 wxPyEndAllowThreads(__tstate);
12228 if (PyErr_Occurred()) SWIG_fail;
12229 }
12230 {
12231 resultobj = SWIG_From_int((int)(result));
12232 }
12233 return resultobj;
12234 fail:
12235 return NULL;
12236 }
12237
12238
12239 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12240 PyObject *resultobj;
12241 wxJoystick *arg1 = (wxJoystick *) 0 ;
12242 int result;
12243 PyObject * obj0 = 0 ;
12244 char *kwnames[] = {
12245 (char *) "self", NULL
12246 };
12247
12248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12250 if (SWIG_arg_fail(1)) SWIG_fail;
12251 {
12252 PyThreadState* __tstate = wxPyBeginAllowThreads();
12253 result = (int)(arg1)->GetZMax();
12254
12255 wxPyEndAllowThreads(__tstate);
12256 if (PyErr_Occurred()) SWIG_fail;
12257 }
12258 {
12259 resultobj = SWIG_From_int((int)(result));
12260 }
12261 return resultobj;
12262 fail:
12263 return NULL;
12264 }
12265
12266
12267 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12268 PyObject *resultobj;
12269 wxJoystick *arg1 = (wxJoystick *) 0 ;
12270 int result;
12271 PyObject * obj0 = 0 ;
12272 char *kwnames[] = {
12273 (char *) "self", NULL
12274 };
12275
12276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12278 if (SWIG_arg_fail(1)) SWIG_fail;
12279 {
12280 PyThreadState* __tstate = wxPyBeginAllowThreads();
12281 result = (int)(arg1)->GetNumberButtons();
12282
12283 wxPyEndAllowThreads(__tstate);
12284 if (PyErr_Occurred()) SWIG_fail;
12285 }
12286 {
12287 resultobj = SWIG_From_int((int)(result));
12288 }
12289 return resultobj;
12290 fail:
12291 return NULL;
12292 }
12293
12294
12295 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12296 PyObject *resultobj;
12297 wxJoystick *arg1 = (wxJoystick *) 0 ;
12298 int result;
12299 PyObject * obj0 = 0 ;
12300 char *kwnames[] = {
12301 (char *) "self", NULL
12302 };
12303
12304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12306 if (SWIG_arg_fail(1)) SWIG_fail;
12307 {
12308 PyThreadState* __tstate = wxPyBeginAllowThreads();
12309 result = (int)(arg1)->GetNumberAxes();
12310
12311 wxPyEndAllowThreads(__tstate);
12312 if (PyErr_Occurred()) SWIG_fail;
12313 }
12314 {
12315 resultobj = SWIG_From_int((int)(result));
12316 }
12317 return resultobj;
12318 fail:
12319 return NULL;
12320 }
12321
12322
12323 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12324 PyObject *resultobj;
12325 wxJoystick *arg1 = (wxJoystick *) 0 ;
12326 int result;
12327 PyObject * obj0 = 0 ;
12328 char *kwnames[] = {
12329 (char *) "self", NULL
12330 };
12331
12332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12334 if (SWIG_arg_fail(1)) SWIG_fail;
12335 {
12336 PyThreadState* __tstate = wxPyBeginAllowThreads();
12337 result = (int)(arg1)->GetMaxButtons();
12338
12339 wxPyEndAllowThreads(__tstate);
12340 if (PyErr_Occurred()) SWIG_fail;
12341 }
12342 {
12343 resultobj = SWIG_From_int((int)(result));
12344 }
12345 return resultobj;
12346 fail:
12347 return NULL;
12348 }
12349
12350
12351 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12352 PyObject *resultobj;
12353 wxJoystick *arg1 = (wxJoystick *) 0 ;
12354 int result;
12355 PyObject * obj0 = 0 ;
12356 char *kwnames[] = {
12357 (char *) "self", NULL
12358 };
12359
12360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12362 if (SWIG_arg_fail(1)) SWIG_fail;
12363 {
12364 PyThreadState* __tstate = wxPyBeginAllowThreads();
12365 result = (int)(arg1)->GetMaxAxes();
12366
12367 wxPyEndAllowThreads(__tstate);
12368 if (PyErr_Occurred()) SWIG_fail;
12369 }
12370 {
12371 resultobj = SWIG_From_int((int)(result));
12372 }
12373 return resultobj;
12374 fail:
12375 return NULL;
12376 }
12377
12378
12379 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12380 PyObject *resultobj;
12381 wxJoystick *arg1 = (wxJoystick *) 0 ;
12382 int result;
12383 PyObject * obj0 = 0 ;
12384 char *kwnames[] = {
12385 (char *) "self", NULL
12386 };
12387
12388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12390 if (SWIG_arg_fail(1)) SWIG_fail;
12391 {
12392 PyThreadState* __tstate = wxPyBeginAllowThreads();
12393 result = (int)(arg1)->GetPollingMin();
12394
12395 wxPyEndAllowThreads(__tstate);
12396 if (PyErr_Occurred()) SWIG_fail;
12397 }
12398 {
12399 resultobj = SWIG_From_int((int)(result));
12400 }
12401 return resultobj;
12402 fail:
12403 return NULL;
12404 }
12405
12406
12407 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12408 PyObject *resultobj;
12409 wxJoystick *arg1 = (wxJoystick *) 0 ;
12410 int result;
12411 PyObject * obj0 = 0 ;
12412 char *kwnames[] = {
12413 (char *) "self", NULL
12414 };
12415
12416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12418 if (SWIG_arg_fail(1)) SWIG_fail;
12419 {
12420 PyThreadState* __tstate = wxPyBeginAllowThreads();
12421 result = (int)(arg1)->GetPollingMax();
12422
12423 wxPyEndAllowThreads(__tstate);
12424 if (PyErr_Occurred()) SWIG_fail;
12425 }
12426 {
12427 resultobj = SWIG_From_int((int)(result));
12428 }
12429 return resultobj;
12430 fail:
12431 return NULL;
12432 }
12433
12434
12435 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12436 PyObject *resultobj;
12437 wxJoystick *arg1 = (wxJoystick *) 0 ;
12438 int result;
12439 PyObject * obj0 = 0 ;
12440 char *kwnames[] = {
12441 (char *) "self", NULL
12442 };
12443
12444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12446 if (SWIG_arg_fail(1)) SWIG_fail;
12447 {
12448 PyThreadState* __tstate = wxPyBeginAllowThreads();
12449 result = (int)(arg1)->GetRudderMin();
12450
12451 wxPyEndAllowThreads(__tstate);
12452 if (PyErr_Occurred()) SWIG_fail;
12453 }
12454 {
12455 resultobj = SWIG_From_int((int)(result));
12456 }
12457 return resultobj;
12458 fail:
12459 return NULL;
12460 }
12461
12462
12463 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12464 PyObject *resultobj;
12465 wxJoystick *arg1 = (wxJoystick *) 0 ;
12466 int result;
12467 PyObject * obj0 = 0 ;
12468 char *kwnames[] = {
12469 (char *) "self", NULL
12470 };
12471
12472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12474 if (SWIG_arg_fail(1)) SWIG_fail;
12475 {
12476 PyThreadState* __tstate = wxPyBeginAllowThreads();
12477 result = (int)(arg1)->GetRudderMax();
12478
12479 wxPyEndAllowThreads(__tstate);
12480 if (PyErr_Occurred()) SWIG_fail;
12481 }
12482 {
12483 resultobj = SWIG_From_int((int)(result));
12484 }
12485 return resultobj;
12486 fail:
12487 return NULL;
12488 }
12489
12490
12491 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12492 PyObject *resultobj;
12493 wxJoystick *arg1 = (wxJoystick *) 0 ;
12494 int result;
12495 PyObject * obj0 = 0 ;
12496 char *kwnames[] = {
12497 (char *) "self", NULL
12498 };
12499
12500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12502 if (SWIG_arg_fail(1)) SWIG_fail;
12503 {
12504 PyThreadState* __tstate = wxPyBeginAllowThreads();
12505 result = (int)(arg1)->GetUMin();
12506
12507 wxPyEndAllowThreads(__tstate);
12508 if (PyErr_Occurred()) SWIG_fail;
12509 }
12510 {
12511 resultobj = SWIG_From_int((int)(result));
12512 }
12513 return resultobj;
12514 fail:
12515 return NULL;
12516 }
12517
12518
12519 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12520 PyObject *resultobj;
12521 wxJoystick *arg1 = (wxJoystick *) 0 ;
12522 int result;
12523 PyObject * obj0 = 0 ;
12524 char *kwnames[] = {
12525 (char *) "self", NULL
12526 };
12527
12528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12530 if (SWIG_arg_fail(1)) SWIG_fail;
12531 {
12532 PyThreadState* __tstate = wxPyBeginAllowThreads();
12533 result = (int)(arg1)->GetUMax();
12534
12535 wxPyEndAllowThreads(__tstate);
12536 if (PyErr_Occurred()) SWIG_fail;
12537 }
12538 {
12539 resultobj = SWIG_From_int((int)(result));
12540 }
12541 return resultobj;
12542 fail:
12543 return NULL;
12544 }
12545
12546
12547 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12548 PyObject *resultobj;
12549 wxJoystick *arg1 = (wxJoystick *) 0 ;
12550 int result;
12551 PyObject * obj0 = 0 ;
12552 char *kwnames[] = {
12553 (char *) "self", NULL
12554 };
12555
12556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12558 if (SWIG_arg_fail(1)) SWIG_fail;
12559 {
12560 PyThreadState* __tstate = wxPyBeginAllowThreads();
12561 result = (int)(arg1)->GetVMin();
12562
12563 wxPyEndAllowThreads(__tstate);
12564 if (PyErr_Occurred()) SWIG_fail;
12565 }
12566 {
12567 resultobj = SWIG_From_int((int)(result));
12568 }
12569 return resultobj;
12570 fail:
12571 return NULL;
12572 }
12573
12574
12575 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12576 PyObject *resultobj;
12577 wxJoystick *arg1 = (wxJoystick *) 0 ;
12578 int result;
12579 PyObject * obj0 = 0 ;
12580 char *kwnames[] = {
12581 (char *) "self", NULL
12582 };
12583
12584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12586 if (SWIG_arg_fail(1)) SWIG_fail;
12587 {
12588 PyThreadState* __tstate = wxPyBeginAllowThreads();
12589 result = (int)(arg1)->GetVMax();
12590
12591 wxPyEndAllowThreads(__tstate);
12592 if (PyErr_Occurred()) SWIG_fail;
12593 }
12594 {
12595 resultobj = SWIG_From_int((int)(result));
12596 }
12597 return resultobj;
12598 fail:
12599 return NULL;
12600 }
12601
12602
12603 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12604 PyObject *resultobj;
12605 wxJoystick *arg1 = (wxJoystick *) 0 ;
12606 bool result;
12607 PyObject * obj0 = 0 ;
12608 char *kwnames[] = {
12609 (char *) "self", NULL
12610 };
12611
12612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12614 if (SWIG_arg_fail(1)) SWIG_fail;
12615 {
12616 PyThreadState* __tstate = wxPyBeginAllowThreads();
12617 result = (bool)(arg1)->HasRudder();
12618
12619 wxPyEndAllowThreads(__tstate);
12620 if (PyErr_Occurred()) SWIG_fail;
12621 }
12622 {
12623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12624 }
12625 return resultobj;
12626 fail:
12627 return NULL;
12628 }
12629
12630
12631 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12632 PyObject *resultobj;
12633 wxJoystick *arg1 = (wxJoystick *) 0 ;
12634 bool result;
12635 PyObject * obj0 = 0 ;
12636 char *kwnames[] = {
12637 (char *) "self", NULL
12638 };
12639
12640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12642 if (SWIG_arg_fail(1)) SWIG_fail;
12643 {
12644 PyThreadState* __tstate = wxPyBeginAllowThreads();
12645 result = (bool)(arg1)->HasZ();
12646
12647 wxPyEndAllowThreads(__tstate);
12648 if (PyErr_Occurred()) SWIG_fail;
12649 }
12650 {
12651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12652 }
12653 return resultobj;
12654 fail:
12655 return NULL;
12656 }
12657
12658
12659 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12660 PyObject *resultobj;
12661 wxJoystick *arg1 = (wxJoystick *) 0 ;
12662 bool result;
12663 PyObject * obj0 = 0 ;
12664 char *kwnames[] = {
12665 (char *) "self", NULL
12666 };
12667
12668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12670 if (SWIG_arg_fail(1)) SWIG_fail;
12671 {
12672 PyThreadState* __tstate = wxPyBeginAllowThreads();
12673 result = (bool)(arg1)->HasU();
12674
12675 wxPyEndAllowThreads(__tstate);
12676 if (PyErr_Occurred()) SWIG_fail;
12677 }
12678 {
12679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12680 }
12681 return resultobj;
12682 fail:
12683 return NULL;
12684 }
12685
12686
12687 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12688 PyObject *resultobj;
12689 wxJoystick *arg1 = (wxJoystick *) 0 ;
12690 bool result;
12691 PyObject * obj0 = 0 ;
12692 char *kwnames[] = {
12693 (char *) "self", NULL
12694 };
12695
12696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12698 if (SWIG_arg_fail(1)) SWIG_fail;
12699 {
12700 PyThreadState* __tstate = wxPyBeginAllowThreads();
12701 result = (bool)(arg1)->HasV();
12702
12703 wxPyEndAllowThreads(__tstate);
12704 if (PyErr_Occurred()) SWIG_fail;
12705 }
12706 {
12707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12708 }
12709 return resultobj;
12710 fail:
12711 return NULL;
12712 }
12713
12714
12715 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12716 PyObject *resultobj;
12717 wxJoystick *arg1 = (wxJoystick *) 0 ;
12718 bool result;
12719 PyObject * obj0 = 0 ;
12720 char *kwnames[] = {
12721 (char *) "self", NULL
12722 };
12723
12724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12726 if (SWIG_arg_fail(1)) SWIG_fail;
12727 {
12728 PyThreadState* __tstate = wxPyBeginAllowThreads();
12729 result = (bool)(arg1)->HasPOV();
12730
12731 wxPyEndAllowThreads(__tstate);
12732 if (PyErr_Occurred()) SWIG_fail;
12733 }
12734 {
12735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12736 }
12737 return resultobj;
12738 fail:
12739 return NULL;
12740 }
12741
12742
12743 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12744 PyObject *resultobj;
12745 wxJoystick *arg1 = (wxJoystick *) 0 ;
12746 bool result;
12747 PyObject * obj0 = 0 ;
12748 char *kwnames[] = {
12749 (char *) "self", NULL
12750 };
12751
12752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12754 if (SWIG_arg_fail(1)) SWIG_fail;
12755 {
12756 PyThreadState* __tstate = wxPyBeginAllowThreads();
12757 result = (bool)(arg1)->HasPOV4Dir();
12758
12759 wxPyEndAllowThreads(__tstate);
12760 if (PyErr_Occurred()) SWIG_fail;
12761 }
12762 {
12763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12764 }
12765 return resultobj;
12766 fail:
12767 return NULL;
12768 }
12769
12770
12771 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12772 PyObject *resultobj;
12773 wxJoystick *arg1 = (wxJoystick *) 0 ;
12774 bool result;
12775 PyObject * obj0 = 0 ;
12776 char *kwnames[] = {
12777 (char *) "self", NULL
12778 };
12779
12780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12782 if (SWIG_arg_fail(1)) SWIG_fail;
12783 {
12784 PyThreadState* __tstate = wxPyBeginAllowThreads();
12785 result = (bool)(arg1)->HasPOVCTS();
12786
12787 wxPyEndAllowThreads(__tstate);
12788 if (PyErr_Occurred()) SWIG_fail;
12789 }
12790 {
12791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12792 }
12793 return resultobj;
12794 fail:
12795 return NULL;
12796 }
12797
12798
12799 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12800 PyObject *resultobj;
12801 wxJoystick *arg1 = (wxJoystick *) 0 ;
12802 wxWindow *arg2 = (wxWindow *) 0 ;
12803 int arg3 = (int) 0 ;
12804 bool result;
12805 PyObject * obj0 = 0 ;
12806 PyObject * obj1 = 0 ;
12807 PyObject * obj2 = 0 ;
12808 char *kwnames[] = {
12809 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12810 };
12811
12812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12814 if (SWIG_arg_fail(1)) SWIG_fail;
12815 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12816 if (SWIG_arg_fail(2)) SWIG_fail;
12817 if (obj2) {
12818 {
12819 arg3 = (int)(SWIG_As_int(obj2));
12820 if (SWIG_arg_fail(3)) SWIG_fail;
12821 }
12822 }
12823 {
12824 PyThreadState* __tstate = wxPyBeginAllowThreads();
12825 result = (bool)(arg1)->SetCapture(arg2,arg3);
12826
12827 wxPyEndAllowThreads(__tstate);
12828 if (PyErr_Occurred()) SWIG_fail;
12829 }
12830 {
12831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12832 }
12833 return resultobj;
12834 fail:
12835 return NULL;
12836 }
12837
12838
12839 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12840 PyObject *resultobj;
12841 wxJoystick *arg1 = (wxJoystick *) 0 ;
12842 bool result;
12843 PyObject * obj0 = 0 ;
12844 char *kwnames[] = {
12845 (char *) "self", NULL
12846 };
12847
12848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12850 if (SWIG_arg_fail(1)) SWIG_fail;
12851 {
12852 PyThreadState* __tstate = wxPyBeginAllowThreads();
12853 result = (bool)(arg1)->ReleaseCapture();
12854
12855 wxPyEndAllowThreads(__tstate);
12856 if (PyErr_Occurred()) SWIG_fail;
12857 }
12858 {
12859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12860 }
12861 return resultobj;
12862 fail:
12863 return NULL;
12864 }
12865
12866
12867 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12868 PyObject *obj;
12869 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12870 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12871 Py_INCREF(obj);
12872 return Py_BuildValue((char *)"");
12873 }
12874 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12875 PyObject *resultobj;
12876 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12877 int arg2 = (int) 0 ;
12878 int arg3 = (int) wxJOYSTICK1 ;
12879 int arg4 = (int) 0 ;
12880 wxJoystickEvent *result;
12881 PyObject * obj0 = 0 ;
12882 PyObject * obj1 = 0 ;
12883 PyObject * obj2 = 0 ;
12884 PyObject * obj3 = 0 ;
12885 char *kwnames[] = {
12886 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12887 };
12888
12889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12890 if (obj0) {
12891 {
12892 arg1 = (wxEventType)(SWIG_As_int(obj0));
12893 if (SWIG_arg_fail(1)) SWIG_fail;
12894 }
12895 }
12896 if (obj1) {
12897 {
12898 arg2 = (int)(SWIG_As_int(obj1));
12899 if (SWIG_arg_fail(2)) SWIG_fail;
12900 }
12901 }
12902 if (obj2) {
12903 {
12904 arg3 = (int)(SWIG_As_int(obj2));
12905 if (SWIG_arg_fail(3)) SWIG_fail;
12906 }
12907 }
12908 if (obj3) {
12909 {
12910 arg4 = (int)(SWIG_As_int(obj3));
12911 if (SWIG_arg_fail(4)) SWIG_fail;
12912 }
12913 }
12914 {
12915 PyThreadState* __tstate = wxPyBeginAllowThreads();
12916 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12917
12918 wxPyEndAllowThreads(__tstate);
12919 if (PyErr_Occurred()) SWIG_fail;
12920 }
12921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12922 return resultobj;
12923 fail:
12924 return NULL;
12925 }
12926
12927
12928 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12929 PyObject *resultobj;
12930 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12931 wxPoint result;
12932 PyObject * obj0 = 0 ;
12933 char *kwnames[] = {
12934 (char *) "self", NULL
12935 };
12936
12937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12939 if (SWIG_arg_fail(1)) SWIG_fail;
12940 {
12941 PyThreadState* __tstate = wxPyBeginAllowThreads();
12942 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12943
12944 wxPyEndAllowThreads(__tstate);
12945 if (PyErr_Occurred()) SWIG_fail;
12946 }
12947 {
12948 wxPoint * resultptr;
12949 resultptr = new wxPoint((wxPoint &)(result));
12950 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12951 }
12952 return resultobj;
12953 fail:
12954 return NULL;
12955 }
12956
12957
12958 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12959 PyObject *resultobj;
12960 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12961 int result;
12962 PyObject * obj0 = 0 ;
12963 char *kwnames[] = {
12964 (char *) "self", NULL
12965 };
12966
12967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12969 if (SWIG_arg_fail(1)) SWIG_fail;
12970 {
12971 PyThreadState* __tstate = wxPyBeginAllowThreads();
12972 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12973
12974 wxPyEndAllowThreads(__tstate);
12975 if (PyErr_Occurred()) SWIG_fail;
12976 }
12977 {
12978 resultobj = SWIG_From_int((int)(result));
12979 }
12980 return resultobj;
12981 fail:
12982 return NULL;
12983 }
12984
12985
12986 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12987 PyObject *resultobj;
12988 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12989 int result;
12990 PyObject * obj0 = 0 ;
12991 char *kwnames[] = {
12992 (char *) "self", NULL
12993 };
12994
12995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12997 if (SWIG_arg_fail(1)) SWIG_fail;
12998 {
12999 PyThreadState* __tstate = wxPyBeginAllowThreads();
13000 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13001
13002 wxPyEndAllowThreads(__tstate);
13003 if (PyErr_Occurred()) SWIG_fail;
13004 }
13005 {
13006 resultobj = SWIG_From_int((int)(result));
13007 }
13008 return resultobj;
13009 fail:
13010 return NULL;
13011 }
13012
13013
13014 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13015 PyObject *resultobj;
13016 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13017 int result;
13018 PyObject * obj0 = 0 ;
13019 char *kwnames[] = {
13020 (char *) "self", NULL
13021 };
13022
13023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13025 if (SWIG_arg_fail(1)) SWIG_fail;
13026 {
13027 PyThreadState* __tstate = wxPyBeginAllowThreads();
13028 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13029
13030 wxPyEndAllowThreads(__tstate);
13031 if (PyErr_Occurred()) SWIG_fail;
13032 }
13033 {
13034 resultobj = SWIG_From_int((int)(result));
13035 }
13036 return resultobj;
13037 fail:
13038 return NULL;
13039 }
13040
13041
13042 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13043 PyObject *resultobj;
13044 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13045 int result;
13046 PyObject * obj0 = 0 ;
13047 char *kwnames[] = {
13048 (char *) "self", NULL
13049 };
13050
13051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13053 if (SWIG_arg_fail(1)) SWIG_fail;
13054 {
13055 PyThreadState* __tstate = wxPyBeginAllowThreads();
13056 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13057
13058 wxPyEndAllowThreads(__tstate);
13059 if (PyErr_Occurred()) SWIG_fail;
13060 }
13061 {
13062 resultobj = SWIG_From_int((int)(result));
13063 }
13064 return resultobj;
13065 fail:
13066 return NULL;
13067 }
13068
13069
13070 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13071 PyObject *resultobj;
13072 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13073 int arg2 ;
13074 PyObject * obj0 = 0 ;
13075 PyObject * obj1 = 0 ;
13076 char *kwnames[] = {
13077 (char *) "self",(char *) "stick", NULL
13078 };
13079
13080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13082 if (SWIG_arg_fail(1)) SWIG_fail;
13083 {
13084 arg2 = (int)(SWIG_As_int(obj1));
13085 if (SWIG_arg_fail(2)) SWIG_fail;
13086 }
13087 {
13088 PyThreadState* __tstate = wxPyBeginAllowThreads();
13089 (arg1)->SetJoystick(arg2);
13090
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 Py_INCREF(Py_None); resultobj = Py_None;
13095 return resultobj;
13096 fail:
13097 return NULL;
13098 }
13099
13100
13101 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13102 PyObject *resultobj;
13103 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13104 int arg2 ;
13105 PyObject * obj0 = 0 ;
13106 PyObject * obj1 = 0 ;
13107 char *kwnames[] = {
13108 (char *) "self",(char *) "state", NULL
13109 };
13110
13111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13113 if (SWIG_arg_fail(1)) SWIG_fail;
13114 {
13115 arg2 = (int)(SWIG_As_int(obj1));
13116 if (SWIG_arg_fail(2)) SWIG_fail;
13117 }
13118 {
13119 PyThreadState* __tstate = wxPyBeginAllowThreads();
13120 (arg1)->SetButtonState(arg2);
13121
13122 wxPyEndAllowThreads(__tstate);
13123 if (PyErr_Occurred()) SWIG_fail;
13124 }
13125 Py_INCREF(Py_None); resultobj = Py_None;
13126 return resultobj;
13127 fail:
13128 return NULL;
13129 }
13130
13131
13132 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13133 PyObject *resultobj;
13134 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13135 int arg2 ;
13136 PyObject * obj0 = 0 ;
13137 PyObject * obj1 = 0 ;
13138 char *kwnames[] = {
13139 (char *) "self",(char *) "change", NULL
13140 };
13141
13142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13144 if (SWIG_arg_fail(1)) SWIG_fail;
13145 {
13146 arg2 = (int)(SWIG_As_int(obj1));
13147 if (SWIG_arg_fail(2)) SWIG_fail;
13148 }
13149 {
13150 PyThreadState* __tstate = wxPyBeginAllowThreads();
13151 (arg1)->SetButtonChange(arg2);
13152
13153 wxPyEndAllowThreads(__tstate);
13154 if (PyErr_Occurred()) SWIG_fail;
13155 }
13156 Py_INCREF(Py_None); resultobj = Py_None;
13157 return resultobj;
13158 fail:
13159 return NULL;
13160 }
13161
13162
13163 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13164 PyObject *resultobj;
13165 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13166 wxPoint *arg2 = 0 ;
13167 wxPoint temp2 ;
13168 PyObject * obj0 = 0 ;
13169 PyObject * obj1 = 0 ;
13170 char *kwnames[] = {
13171 (char *) "self",(char *) "pos", NULL
13172 };
13173
13174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13176 if (SWIG_arg_fail(1)) SWIG_fail;
13177 {
13178 arg2 = &temp2;
13179 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13180 }
13181 {
13182 PyThreadState* __tstate = wxPyBeginAllowThreads();
13183 (arg1)->SetPosition((wxPoint const &)*arg2);
13184
13185 wxPyEndAllowThreads(__tstate);
13186 if (PyErr_Occurred()) SWIG_fail;
13187 }
13188 Py_INCREF(Py_None); resultobj = Py_None;
13189 return resultobj;
13190 fail:
13191 return NULL;
13192 }
13193
13194
13195 static PyObject *_wrap_JoystickEvent_SetZPosition(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 *) "zPos", NULL
13203 };
13204
13205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",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)->SetZPosition(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_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13227 PyObject *resultobj;
13228 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13229 bool result;
13230 PyObject * obj0 = 0 ;
13231 char *kwnames[] = {
13232 (char *) "self", NULL
13233 };
13234
13235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13237 if (SWIG_arg_fail(1)) SWIG_fail;
13238 {
13239 PyThreadState* __tstate = wxPyBeginAllowThreads();
13240 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13241
13242 wxPyEndAllowThreads(__tstate);
13243 if (PyErr_Occurred()) SWIG_fail;
13244 }
13245 {
13246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13247 }
13248 return resultobj;
13249 fail:
13250 return NULL;
13251 }
13252
13253
13254 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13255 PyObject *resultobj;
13256 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13257 bool result;
13258 PyObject * obj0 = 0 ;
13259 char *kwnames[] = {
13260 (char *) "self", NULL
13261 };
13262
13263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13265 if (SWIG_arg_fail(1)) SWIG_fail;
13266 {
13267 PyThreadState* __tstate = wxPyBeginAllowThreads();
13268 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13269
13270 wxPyEndAllowThreads(__tstate);
13271 if (PyErr_Occurred()) SWIG_fail;
13272 }
13273 {
13274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13275 }
13276 return resultobj;
13277 fail:
13278 return NULL;
13279 }
13280
13281
13282 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13283 PyObject *resultobj;
13284 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13285 bool result;
13286 PyObject * obj0 = 0 ;
13287 char *kwnames[] = {
13288 (char *) "self", NULL
13289 };
13290
13291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13293 if (SWIG_arg_fail(1)) SWIG_fail;
13294 {
13295 PyThreadState* __tstate = wxPyBeginAllowThreads();
13296 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13297
13298 wxPyEndAllowThreads(__tstate);
13299 if (PyErr_Occurred()) SWIG_fail;
13300 }
13301 {
13302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13303 }
13304 return resultobj;
13305 fail:
13306 return NULL;
13307 }
13308
13309
13310 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13311 PyObject *resultobj;
13312 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13313 int arg2 = (int) wxJOY_BUTTON_ANY ;
13314 bool result;
13315 PyObject * obj0 = 0 ;
13316 PyObject * obj1 = 0 ;
13317 char *kwnames[] = {
13318 (char *) "self",(char *) "but", NULL
13319 };
13320
13321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13323 if (SWIG_arg_fail(1)) SWIG_fail;
13324 if (obj1) {
13325 {
13326 arg2 = (int)(SWIG_As_int(obj1));
13327 if (SWIG_arg_fail(2)) SWIG_fail;
13328 }
13329 }
13330 {
13331 PyThreadState* __tstate = wxPyBeginAllowThreads();
13332 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13333
13334 wxPyEndAllowThreads(__tstate);
13335 if (PyErr_Occurred()) SWIG_fail;
13336 }
13337 {
13338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13339 }
13340 return resultobj;
13341 fail:
13342 return NULL;
13343 }
13344
13345
13346 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13347 PyObject *resultobj;
13348 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13349 int arg2 = (int) wxJOY_BUTTON_ANY ;
13350 bool result;
13351 PyObject * obj0 = 0 ;
13352 PyObject * obj1 = 0 ;
13353 char *kwnames[] = {
13354 (char *) "self",(char *) "but", NULL
13355 };
13356
13357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13359 if (SWIG_arg_fail(1)) SWIG_fail;
13360 if (obj1) {
13361 {
13362 arg2 = (int)(SWIG_As_int(obj1));
13363 if (SWIG_arg_fail(2)) SWIG_fail;
13364 }
13365 }
13366 {
13367 PyThreadState* __tstate = wxPyBeginAllowThreads();
13368 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13369
13370 wxPyEndAllowThreads(__tstate);
13371 if (PyErr_Occurred()) SWIG_fail;
13372 }
13373 {
13374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13375 }
13376 return resultobj;
13377 fail:
13378 return NULL;
13379 }
13380
13381
13382 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13383 PyObject *resultobj;
13384 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13385 int arg2 = (int) wxJOY_BUTTON_ANY ;
13386 bool result;
13387 PyObject * obj0 = 0 ;
13388 PyObject * obj1 = 0 ;
13389 char *kwnames[] = {
13390 (char *) "self",(char *) "but", NULL
13391 };
13392
13393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13395 if (SWIG_arg_fail(1)) SWIG_fail;
13396 if (obj1) {
13397 {
13398 arg2 = (int)(SWIG_As_int(obj1));
13399 if (SWIG_arg_fail(2)) SWIG_fail;
13400 }
13401 }
13402 {
13403 PyThreadState* __tstate = wxPyBeginAllowThreads();
13404 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13405
13406 wxPyEndAllowThreads(__tstate);
13407 if (PyErr_Occurred()) SWIG_fail;
13408 }
13409 {
13410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13411 }
13412 return resultobj;
13413 fail:
13414 return NULL;
13415 }
13416
13417
13418 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13419 PyObject *obj;
13420 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13421 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13422 Py_INCREF(obj);
13423 return Py_BuildValue((char *)"");
13424 }
13425 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13426 PyObject *resultobj;
13427 wxString const &arg1_defvalue = wxPyEmptyString ;
13428 wxString *arg1 = (wxString *) &arg1_defvalue ;
13429 wxSound *result;
13430 bool temp1 = false ;
13431 PyObject * obj0 = 0 ;
13432 char *kwnames[] = {
13433 (char *) "fileName", NULL
13434 };
13435
13436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13437 if (obj0) {
13438 {
13439 arg1 = wxString_in_helper(obj0);
13440 if (arg1 == NULL) SWIG_fail;
13441 temp1 = true;
13442 }
13443 }
13444 {
13445 if (!wxPyCheckForApp()) SWIG_fail;
13446 PyThreadState* __tstate = wxPyBeginAllowThreads();
13447 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13448
13449 wxPyEndAllowThreads(__tstate);
13450 if (PyErr_Occurred()) SWIG_fail;
13451 }
13452 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13453 {
13454 if (temp1)
13455 delete arg1;
13456 }
13457 return resultobj;
13458 fail:
13459 {
13460 if (temp1)
13461 delete arg1;
13462 }
13463 return NULL;
13464 }
13465
13466
13467 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13468 PyObject *resultobj;
13469 PyObject *arg1 = (PyObject *) 0 ;
13470 wxSound *result;
13471 PyObject * obj0 = 0 ;
13472 char *kwnames[] = {
13473 (char *) "data", NULL
13474 };
13475
13476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13477 arg1 = obj0;
13478 {
13479 if (!wxPyCheckForApp()) SWIG_fail;
13480 PyThreadState* __tstate = wxPyBeginAllowThreads();
13481 result = (wxSound *)new_wxSound(arg1);
13482
13483 wxPyEndAllowThreads(__tstate);
13484 if (PyErr_Occurred()) SWIG_fail;
13485 }
13486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13487 return resultobj;
13488 fail:
13489 return NULL;
13490 }
13491
13492
13493 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13494 PyObject *resultobj;
13495 wxSound *arg1 = (wxSound *) 0 ;
13496 PyObject * obj0 = 0 ;
13497 char *kwnames[] = {
13498 (char *) "self", NULL
13499 };
13500
13501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13503 if (SWIG_arg_fail(1)) SWIG_fail;
13504 {
13505 PyThreadState* __tstate = wxPyBeginAllowThreads();
13506 delete arg1;
13507
13508 wxPyEndAllowThreads(__tstate);
13509 if (PyErr_Occurred()) SWIG_fail;
13510 }
13511 Py_INCREF(Py_None); resultobj = Py_None;
13512 return resultobj;
13513 fail:
13514 return NULL;
13515 }
13516
13517
13518 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13519 PyObject *resultobj;
13520 wxSound *arg1 = (wxSound *) 0 ;
13521 wxString *arg2 = 0 ;
13522 bool result;
13523 bool temp2 = false ;
13524 PyObject * obj0 = 0 ;
13525 PyObject * obj1 = 0 ;
13526 char *kwnames[] = {
13527 (char *) "self",(char *) "fileName", NULL
13528 };
13529
13530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13532 if (SWIG_arg_fail(1)) SWIG_fail;
13533 {
13534 arg2 = wxString_in_helper(obj1);
13535 if (arg2 == NULL) SWIG_fail;
13536 temp2 = true;
13537 }
13538 {
13539 PyThreadState* __tstate = wxPyBeginAllowThreads();
13540 result = (bool)(arg1)->Create((wxString const &)*arg2);
13541
13542 wxPyEndAllowThreads(__tstate);
13543 if (PyErr_Occurred()) SWIG_fail;
13544 }
13545 {
13546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13547 }
13548 {
13549 if (temp2)
13550 delete arg2;
13551 }
13552 return resultobj;
13553 fail:
13554 {
13555 if (temp2)
13556 delete arg2;
13557 }
13558 return NULL;
13559 }
13560
13561
13562 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13563 PyObject *resultobj;
13564 wxSound *arg1 = (wxSound *) 0 ;
13565 PyObject *arg2 = (PyObject *) 0 ;
13566 bool result;
13567 PyObject * obj0 = 0 ;
13568 PyObject * obj1 = 0 ;
13569 char *kwnames[] = {
13570 (char *) "self",(char *) "data", NULL
13571 };
13572
13573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13575 if (SWIG_arg_fail(1)) SWIG_fail;
13576 arg2 = obj1;
13577 {
13578 PyThreadState* __tstate = wxPyBeginAllowThreads();
13579 result = (bool)wxSound_CreateFromData(arg1,arg2);
13580
13581 wxPyEndAllowThreads(__tstate);
13582 if (PyErr_Occurred()) SWIG_fail;
13583 }
13584 {
13585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13586 }
13587 return resultobj;
13588 fail:
13589 return NULL;
13590 }
13591
13592
13593 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13594 PyObject *resultobj;
13595 wxSound *arg1 = (wxSound *) 0 ;
13596 bool result;
13597 PyObject * obj0 = 0 ;
13598 char *kwnames[] = {
13599 (char *) "self", NULL
13600 };
13601
13602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13604 if (SWIG_arg_fail(1)) SWIG_fail;
13605 {
13606 PyThreadState* __tstate = wxPyBeginAllowThreads();
13607 result = (bool)(arg1)->IsOk();
13608
13609 wxPyEndAllowThreads(__tstate);
13610 if (PyErr_Occurred()) SWIG_fail;
13611 }
13612 {
13613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13614 }
13615 return resultobj;
13616 fail:
13617 return NULL;
13618 }
13619
13620
13621 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13622 PyObject *resultobj;
13623 wxSound *arg1 = (wxSound *) 0 ;
13624 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13625 bool result;
13626 PyObject * obj0 = 0 ;
13627 PyObject * obj1 = 0 ;
13628 char *kwnames[] = {
13629 (char *) "self",(char *) "flags", NULL
13630 };
13631
13632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13634 if (SWIG_arg_fail(1)) SWIG_fail;
13635 if (obj1) {
13636 {
13637 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13638 if (SWIG_arg_fail(2)) SWIG_fail;
13639 }
13640 }
13641 {
13642 if (!wxPyCheckForApp()) SWIG_fail;
13643 PyThreadState* __tstate = wxPyBeginAllowThreads();
13644 result = (bool)((wxSound const *)arg1)->Play(arg2);
13645
13646 wxPyEndAllowThreads(__tstate);
13647 if (PyErr_Occurred()) SWIG_fail;
13648 }
13649 {
13650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13651 }
13652 return resultobj;
13653 fail:
13654 return NULL;
13655 }
13656
13657
13658 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13659 PyObject *resultobj;
13660 wxString *arg1 = 0 ;
13661 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13662 bool result;
13663 bool temp1 = false ;
13664 PyObject * obj0 = 0 ;
13665 PyObject * obj1 = 0 ;
13666 char *kwnames[] = {
13667 (char *) "filename",(char *) "flags", NULL
13668 };
13669
13670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13671 {
13672 arg1 = wxString_in_helper(obj0);
13673 if (arg1 == NULL) SWIG_fail;
13674 temp1 = true;
13675 }
13676 if (obj1) {
13677 {
13678 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13679 if (SWIG_arg_fail(2)) SWIG_fail;
13680 }
13681 }
13682 {
13683 if (!wxPyCheckForApp()) SWIG_fail;
13684 PyThreadState* __tstate = wxPyBeginAllowThreads();
13685 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13686
13687 wxPyEndAllowThreads(__tstate);
13688 if (PyErr_Occurred()) SWIG_fail;
13689 }
13690 {
13691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13692 }
13693 {
13694 if (temp1)
13695 delete arg1;
13696 }
13697 return resultobj;
13698 fail:
13699 {
13700 if (temp1)
13701 delete arg1;
13702 }
13703 return NULL;
13704 }
13705
13706
13707 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13708 PyObject *resultobj;
13709 char *kwnames[] = {
13710 NULL
13711 };
13712
13713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13714 {
13715 if (!wxPyCheckForApp()) SWIG_fail;
13716 PyThreadState* __tstate = wxPyBeginAllowThreads();
13717 wxSound::Stop();
13718
13719 wxPyEndAllowThreads(__tstate);
13720 if (PyErr_Occurred()) SWIG_fail;
13721 }
13722 Py_INCREF(Py_None); resultobj = Py_None;
13723 return resultobj;
13724 fail:
13725 return NULL;
13726 }
13727
13728
13729 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13730 PyObject *obj;
13731 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13732 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13733 Py_INCREF(obj);
13734 return Py_BuildValue((char *)"");
13735 }
13736 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13737 PyObject *resultobj;
13738 wxString *arg1 = 0 ;
13739 wxString *arg2 = 0 ;
13740 wxString *arg3 = 0 ;
13741 wxString *arg4 = 0 ;
13742 wxFileTypeInfo *result;
13743 bool temp1 = false ;
13744 bool temp2 = false ;
13745 bool temp3 = false ;
13746 bool temp4 = false ;
13747 PyObject * obj0 = 0 ;
13748 PyObject * obj1 = 0 ;
13749 PyObject * obj2 = 0 ;
13750 PyObject * obj3 = 0 ;
13751 char *kwnames[] = {
13752 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13753 };
13754
13755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13756 {
13757 arg1 = wxString_in_helper(obj0);
13758 if (arg1 == NULL) SWIG_fail;
13759 temp1 = true;
13760 }
13761 {
13762 arg2 = wxString_in_helper(obj1);
13763 if (arg2 == NULL) SWIG_fail;
13764 temp2 = true;
13765 }
13766 {
13767 arg3 = wxString_in_helper(obj2);
13768 if (arg3 == NULL) SWIG_fail;
13769 temp3 = true;
13770 }
13771 {
13772 arg4 = wxString_in_helper(obj3);
13773 if (arg4 == NULL) SWIG_fail;
13774 temp4 = true;
13775 }
13776 {
13777 PyThreadState* __tstate = wxPyBeginAllowThreads();
13778 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13779
13780 wxPyEndAllowThreads(__tstate);
13781 if (PyErr_Occurred()) SWIG_fail;
13782 }
13783 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13784 {
13785 if (temp1)
13786 delete arg1;
13787 }
13788 {
13789 if (temp2)
13790 delete arg2;
13791 }
13792 {
13793 if (temp3)
13794 delete arg3;
13795 }
13796 {
13797 if (temp4)
13798 delete arg4;
13799 }
13800 return resultobj;
13801 fail:
13802 {
13803 if (temp1)
13804 delete arg1;
13805 }
13806 {
13807 if (temp2)
13808 delete arg2;
13809 }
13810 {
13811 if (temp3)
13812 delete arg3;
13813 }
13814 {
13815 if (temp4)
13816 delete arg4;
13817 }
13818 return NULL;
13819 }
13820
13821
13822 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13823 PyObject *resultobj;
13824 wxArrayString *arg1 = 0 ;
13825 wxFileTypeInfo *result;
13826 bool temp1 = false ;
13827 PyObject * obj0 = 0 ;
13828 char *kwnames[] = {
13829 (char *) "sArray", NULL
13830 };
13831
13832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13833 {
13834 if (! PySequence_Check(obj0)) {
13835 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13836 SWIG_fail;
13837 }
13838 arg1 = new wxArrayString;
13839 temp1 = true;
13840 int i, len=PySequence_Length(obj0);
13841 for (i=0; i<len; i++) {
13842 PyObject* item = PySequence_GetItem(obj0, i);
13843 #if wxUSE_UNICODE
13844 PyObject* str = PyObject_Unicode(item);
13845 #else
13846 PyObject* str = PyObject_Str(item);
13847 #endif
13848 if (PyErr_Occurred()) SWIG_fail;
13849 arg1->Add(Py2wxString(str));
13850 Py_DECREF(item);
13851 Py_DECREF(str);
13852 }
13853 }
13854 {
13855 PyThreadState* __tstate = wxPyBeginAllowThreads();
13856 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13857
13858 wxPyEndAllowThreads(__tstate);
13859 if (PyErr_Occurred()) SWIG_fail;
13860 }
13861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13862 {
13863 if (temp1) delete arg1;
13864 }
13865 return resultobj;
13866 fail:
13867 {
13868 if (temp1) delete arg1;
13869 }
13870 return NULL;
13871 }
13872
13873
13874 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13875 PyObject *resultobj;
13876 wxFileTypeInfo *result;
13877 char *kwnames[] = {
13878 NULL
13879 };
13880
13881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13882 {
13883 PyThreadState* __tstate = wxPyBeginAllowThreads();
13884 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13885
13886 wxPyEndAllowThreads(__tstate);
13887 if (PyErr_Occurred()) SWIG_fail;
13888 }
13889 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13890 return resultobj;
13891 fail:
13892 return NULL;
13893 }
13894
13895
13896 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13897 PyObject *resultobj;
13898 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13899 bool result;
13900 PyObject * obj0 = 0 ;
13901 char *kwnames[] = {
13902 (char *) "self", NULL
13903 };
13904
13905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13907 if (SWIG_arg_fail(1)) SWIG_fail;
13908 {
13909 PyThreadState* __tstate = wxPyBeginAllowThreads();
13910 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13911
13912 wxPyEndAllowThreads(__tstate);
13913 if (PyErr_Occurred()) SWIG_fail;
13914 }
13915 {
13916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13917 }
13918 return resultobj;
13919 fail:
13920 return NULL;
13921 }
13922
13923
13924 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13925 PyObject *resultobj;
13926 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13927 wxString *arg2 = 0 ;
13928 int arg3 = (int) 0 ;
13929 bool temp2 = false ;
13930 PyObject * obj0 = 0 ;
13931 PyObject * obj1 = 0 ;
13932 PyObject * obj2 = 0 ;
13933 char *kwnames[] = {
13934 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13935 };
13936
13937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13939 if (SWIG_arg_fail(1)) SWIG_fail;
13940 {
13941 arg2 = wxString_in_helper(obj1);
13942 if (arg2 == NULL) SWIG_fail;
13943 temp2 = true;
13944 }
13945 if (obj2) {
13946 {
13947 arg3 = (int)(SWIG_As_int(obj2));
13948 if (SWIG_arg_fail(3)) SWIG_fail;
13949 }
13950 }
13951 {
13952 PyThreadState* __tstate = wxPyBeginAllowThreads();
13953 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13954
13955 wxPyEndAllowThreads(__tstate);
13956 if (PyErr_Occurred()) SWIG_fail;
13957 }
13958 Py_INCREF(Py_None); resultobj = Py_None;
13959 {
13960 if (temp2)
13961 delete arg2;
13962 }
13963 return resultobj;
13964 fail:
13965 {
13966 if (temp2)
13967 delete arg2;
13968 }
13969 return NULL;
13970 }
13971
13972
13973 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13974 PyObject *resultobj;
13975 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13976 wxString *arg2 = 0 ;
13977 bool temp2 = false ;
13978 PyObject * obj0 = 0 ;
13979 PyObject * obj1 = 0 ;
13980 char *kwnames[] = {
13981 (char *) "self",(char *) "shortDesc", NULL
13982 };
13983
13984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13986 if (SWIG_arg_fail(1)) SWIG_fail;
13987 {
13988 arg2 = wxString_in_helper(obj1);
13989 if (arg2 == NULL) SWIG_fail;
13990 temp2 = true;
13991 }
13992 {
13993 PyThreadState* __tstate = wxPyBeginAllowThreads();
13994 (arg1)->SetShortDesc((wxString const &)*arg2);
13995
13996 wxPyEndAllowThreads(__tstate);
13997 if (PyErr_Occurred()) SWIG_fail;
13998 }
13999 Py_INCREF(Py_None); resultobj = Py_None;
14000 {
14001 if (temp2)
14002 delete arg2;
14003 }
14004 return resultobj;
14005 fail:
14006 {
14007 if (temp2)
14008 delete arg2;
14009 }
14010 return NULL;
14011 }
14012
14013
14014 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14015 PyObject *resultobj;
14016 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14017 wxString *result;
14018 PyObject * obj0 = 0 ;
14019 char *kwnames[] = {
14020 (char *) "self", NULL
14021 };
14022
14023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14025 if (SWIG_arg_fail(1)) SWIG_fail;
14026 {
14027 PyThreadState* __tstate = wxPyBeginAllowThreads();
14028 {
14029 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14030 result = (wxString *) &_result_ref;
14031 }
14032
14033 wxPyEndAllowThreads(__tstate);
14034 if (PyErr_Occurred()) SWIG_fail;
14035 }
14036 {
14037 #if wxUSE_UNICODE
14038 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14039 #else
14040 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14041 #endif
14042 }
14043 return resultobj;
14044 fail:
14045 return NULL;
14046 }
14047
14048
14049 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14050 PyObject *resultobj;
14051 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14052 wxString *result;
14053 PyObject * obj0 = 0 ;
14054 char *kwnames[] = {
14055 (char *) "self", NULL
14056 };
14057
14058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
14063 {
14064 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14065 result = (wxString *) &_result_ref;
14066 }
14067
14068 wxPyEndAllowThreads(__tstate);
14069 if (PyErr_Occurred()) SWIG_fail;
14070 }
14071 {
14072 #if wxUSE_UNICODE
14073 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14074 #else
14075 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14076 #endif
14077 }
14078 return resultobj;
14079 fail:
14080 return NULL;
14081 }
14082
14083
14084 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14085 PyObject *resultobj;
14086 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14087 wxString *result;
14088 PyObject * obj0 = 0 ;
14089 char *kwnames[] = {
14090 (char *) "self", NULL
14091 };
14092
14093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14095 if (SWIG_arg_fail(1)) SWIG_fail;
14096 {
14097 PyThreadState* __tstate = wxPyBeginAllowThreads();
14098 {
14099 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14100 result = (wxString *) &_result_ref;
14101 }
14102
14103 wxPyEndAllowThreads(__tstate);
14104 if (PyErr_Occurred()) SWIG_fail;
14105 }
14106 {
14107 #if wxUSE_UNICODE
14108 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14109 #else
14110 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14111 #endif
14112 }
14113 return resultobj;
14114 fail:
14115 return NULL;
14116 }
14117
14118
14119 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14120 PyObject *resultobj;
14121 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14122 wxString *result;
14123 PyObject * obj0 = 0 ;
14124 char *kwnames[] = {
14125 (char *) "self", NULL
14126 };
14127
14128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14130 if (SWIG_arg_fail(1)) SWIG_fail;
14131 {
14132 PyThreadState* __tstate = wxPyBeginAllowThreads();
14133 {
14134 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14135 result = (wxString *) &_result_ref;
14136 }
14137
14138 wxPyEndAllowThreads(__tstate);
14139 if (PyErr_Occurred()) SWIG_fail;
14140 }
14141 {
14142 #if wxUSE_UNICODE
14143 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14144 #else
14145 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14146 #endif
14147 }
14148 return resultobj;
14149 fail:
14150 return NULL;
14151 }
14152
14153
14154 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14155 PyObject *resultobj;
14156 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14157 wxString *result;
14158 PyObject * obj0 = 0 ;
14159 char *kwnames[] = {
14160 (char *) "self", NULL
14161 };
14162
14163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14165 if (SWIG_arg_fail(1)) SWIG_fail;
14166 {
14167 PyThreadState* __tstate = wxPyBeginAllowThreads();
14168 {
14169 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14170 result = (wxString *) &_result_ref;
14171 }
14172
14173 wxPyEndAllowThreads(__tstate);
14174 if (PyErr_Occurred()) SWIG_fail;
14175 }
14176 {
14177 #if wxUSE_UNICODE
14178 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14179 #else
14180 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14181 #endif
14182 }
14183 return resultobj;
14184 fail:
14185 return NULL;
14186 }
14187
14188
14189 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14190 PyObject *resultobj;
14191 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14192 wxArrayString *result;
14193 PyObject * obj0 = 0 ;
14194 char *kwnames[] = {
14195 (char *) "self", NULL
14196 };
14197
14198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14200 if (SWIG_arg_fail(1)) SWIG_fail;
14201 {
14202 PyThreadState* __tstate = wxPyBeginAllowThreads();
14203 {
14204 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14205 result = (wxArrayString *) &_result_ref;
14206 }
14207
14208 wxPyEndAllowThreads(__tstate);
14209 if (PyErr_Occurred()) SWIG_fail;
14210 }
14211 {
14212 resultobj = wxArrayString2PyList_helper(*result);
14213 }
14214 return resultobj;
14215 fail:
14216 return NULL;
14217 }
14218
14219
14220 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14221 PyObject *resultobj;
14222 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14223 int result;
14224 PyObject * obj0 = 0 ;
14225 char *kwnames[] = {
14226 (char *) "self", NULL
14227 };
14228
14229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14231 if (SWIG_arg_fail(1)) SWIG_fail;
14232 {
14233 PyThreadState* __tstate = wxPyBeginAllowThreads();
14234 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14235
14236 wxPyEndAllowThreads(__tstate);
14237 if (PyErr_Occurred()) SWIG_fail;
14238 }
14239 {
14240 resultobj = SWIG_From_int((int)(result));
14241 }
14242 return resultobj;
14243 fail:
14244 return NULL;
14245 }
14246
14247
14248 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14249 PyObject *resultobj;
14250 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14251 wxString *result;
14252 PyObject * obj0 = 0 ;
14253 char *kwnames[] = {
14254 (char *) "self", NULL
14255 };
14256
14257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14259 if (SWIG_arg_fail(1)) SWIG_fail;
14260 {
14261 PyThreadState* __tstate = wxPyBeginAllowThreads();
14262 {
14263 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14264 result = (wxString *) &_result_ref;
14265 }
14266
14267 wxPyEndAllowThreads(__tstate);
14268 if (PyErr_Occurred()) SWIG_fail;
14269 }
14270 {
14271 #if wxUSE_UNICODE
14272 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14273 #else
14274 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14275 #endif
14276 }
14277 return resultobj;
14278 fail:
14279 return NULL;
14280 }
14281
14282
14283 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14284 PyObject *resultobj;
14285 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14286 int result;
14287 PyObject * obj0 = 0 ;
14288 char *kwnames[] = {
14289 (char *) "self", NULL
14290 };
14291
14292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14294 if (SWIG_arg_fail(1)) SWIG_fail;
14295 {
14296 PyThreadState* __tstate = wxPyBeginAllowThreads();
14297 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14298
14299 wxPyEndAllowThreads(__tstate);
14300 if (PyErr_Occurred()) SWIG_fail;
14301 }
14302 {
14303 resultobj = SWIG_From_int((int)(result));
14304 }
14305 return resultobj;
14306 fail:
14307 return NULL;
14308 }
14309
14310
14311 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14312 PyObject *obj;
14313 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14314 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14315 Py_INCREF(obj);
14316 return Py_BuildValue((char *)"");
14317 }
14318 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14319 PyObject *resultobj;
14320 wxFileTypeInfo *arg1 = 0 ;
14321 wxFileType *result;
14322 PyObject * obj0 = 0 ;
14323 char *kwnames[] = {
14324 (char *) "ftInfo", NULL
14325 };
14326
14327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14328 {
14329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14330 if (SWIG_arg_fail(1)) SWIG_fail;
14331 if (arg1 == NULL) {
14332 SWIG_null_ref("wxFileTypeInfo");
14333 }
14334 if (SWIG_arg_fail(1)) SWIG_fail;
14335 }
14336 {
14337 PyThreadState* __tstate = wxPyBeginAllowThreads();
14338 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14339
14340 wxPyEndAllowThreads(__tstate);
14341 if (PyErr_Occurred()) SWIG_fail;
14342 }
14343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14344 return resultobj;
14345 fail:
14346 return NULL;
14347 }
14348
14349
14350 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14351 PyObject *resultobj;
14352 wxFileType *arg1 = (wxFileType *) 0 ;
14353 PyObject * obj0 = 0 ;
14354 char *kwnames[] = {
14355 (char *) "self", NULL
14356 };
14357
14358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14360 if (SWIG_arg_fail(1)) SWIG_fail;
14361 {
14362 PyThreadState* __tstate = wxPyBeginAllowThreads();
14363 delete arg1;
14364
14365 wxPyEndAllowThreads(__tstate);
14366 if (PyErr_Occurred()) SWIG_fail;
14367 }
14368 Py_INCREF(Py_None); resultobj = Py_None;
14369 return resultobj;
14370 fail:
14371 return NULL;
14372 }
14373
14374
14375 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14376 PyObject *resultobj;
14377 wxFileType *arg1 = (wxFileType *) 0 ;
14378 PyObject *result;
14379 PyObject * obj0 = 0 ;
14380 char *kwnames[] = {
14381 (char *) "self", NULL
14382 };
14383
14384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14386 if (SWIG_arg_fail(1)) SWIG_fail;
14387 {
14388 PyThreadState* __tstate = wxPyBeginAllowThreads();
14389 result = (PyObject *)wxFileType_GetMimeType(arg1);
14390
14391 wxPyEndAllowThreads(__tstate);
14392 if (PyErr_Occurred()) SWIG_fail;
14393 }
14394 resultobj = result;
14395 return resultobj;
14396 fail:
14397 return NULL;
14398 }
14399
14400
14401 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14402 PyObject *resultobj;
14403 wxFileType *arg1 = (wxFileType *) 0 ;
14404 PyObject *result;
14405 PyObject * obj0 = 0 ;
14406 char *kwnames[] = {
14407 (char *) "self", NULL
14408 };
14409
14410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14412 if (SWIG_arg_fail(1)) SWIG_fail;
14413 {
14414 PyThreadState* __tstate = wxPyBeginAllowThreads();
14415 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14416
14417 wxPyEndAllowThreads(__tstate);
14418 if (PyErr_Occurred()) SWIG_fail;
14419 }
14420 resultobj = result;
14421 return resultobj;
14422 fail:
14423 return NULL;
14424 }
14425
14426
14427 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14428 PyObject *resultobj;
14429 wxFileType *arg1 = (wxFileType *) 0 ;
14430 PyObject *result;
14431 PyObject * obj0 = 0 ;
14432 char *kwnames[] = {
14433 (char *) "self", NULL
14434 };
14435
14436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14438 if (SWIG_arg_fail(1)) SWIG_fail;
14439 {
14440 PyThreadState* __tstate = wxPyBeginAllowThreads();
14441 result = (PyObject *)wxFileType_GetExtensions(arg1);
14442
14443 wxPyEndAllowThreads(__tstate);
14444 if (PyErr_Occurred()) SWIG_fail;
14445 }
14446 resultobj = result;
14447 return resultobj;
14448 fail:
14449 return NULL;
14450 }
14451
14452
14453 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14454 PyObject *resultobj;
14455 wxFileType *arg1 = (wxFileType *) 0 ;
14456 wxIcon *result;
14457 PyObject * obj0 = 0 ;
14458 char *kwnames[] = {
14459 (char *) "self", NULL
14460 };
14461
14462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14464 if (SWIG_arg_fail(1)) SWIG_fail;
14465 {
14466 PyThreadState* __tstate = wxPyBeginAllowThreads();
14467 result = (wxIcon *)wxFileType_GetIcon(arg1);
14468
14469 wxPyEndAllowThreads(__tstate);
14470 if (PyErr_Occurred()) SWIG_fail;
14471 }
14472 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14473 return resultobj;
14474 fail:
14475 return NULL;
14476 }
14477
14478
14479 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14480 PyObject *resultobj;
14481 wxFileType *arg1 = (wxFileType *) 0 ;
14482 PyObject *result;
14483 PyObject * obj0 = 0 ;
14484 char *kwnames[] = {
14485 (char *) "self", NULL
14486 };
14487
14488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14490 if (SWIG_arg_fail(1)) SWIG_fail;
14491 {
14492 PyThreadState* __tstate = wxPyBeginAllowThreads();
14493 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14494
14495 wxPyEndAllowThreads(__tstate);
14496 if (PyErr_Occurred()) SWIG_fail;
14497 }
14498 resultobj = result;
14499 return resultobj;
14500 fail:
14501 return NULL;
14502 }
14503
14504
14505 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14506 PyObject *resultobj;
14507 wxFileType *arg1 = (wxFileType *) 0 ;
14508 PyObject *result;
14509 PyObject * obj0 = 0 ;
14510 char *kwnames[] = {
14511 (char *) "self", NULL
14512 };
14513
14514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14516 if (SWIG_arg_fail(1)) SWIG_fail;
14517 {
14518 PyThreadState* __tstate = wxPyBeginAllowThreads();
14519 result = (PyObject *)wxFileType_GetDescription(arg1);
14520
14521 wxPyEndAllowThreads(__tstate);
14522 if (PyErr_Occurred()) SWIG_fail;
14523 }
14524 resultobj = result;
14525 return resultobj;
14526 fail:
14527 return NULL;
14528 }
14529
14530
14531 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14532 PyObject *resultobj;
14533 wxFileType *arg1 = (wxFileType *) 0 ;
14534 wxString *arg2 = 0 ;
14535 wxString const &arg3_defvalue = wxPyEmptyString ;
14536 wxString *arg3 = (wxString *) &arg3_defvalue ;
14537 PyObject *result;
14538 bool temp2 = false ;
14539 bool temp3 = false ;
14540 PyObject * obj0 = 0 ;
14541 PyObject * obj1 = 0 ;
14542 PyObject * obj2 = 0 ;
14543 char *kwnames[] = {
14544 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14545 };
14546
14547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14549 if (SWIG_arg_fail(1)) SWIG_fail;
14550 {
14551 arg2 = wxString_in_helper(obj1);
14552 if (arg2 == NULL) SWIG_fail;
14553 temp2 = true;
14554 }
14555 if (obj2) {
14556 {
14557 arg3 = wxString_in_helper(obj2);
14558 if (arg3 == NULL) SWIG_fail;
14559 temp3 = true;
14560 }
14561 }
14562 {
14563 PyThreadState* __tstate = wxPyBeginAllowThreads();
14564 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14565
14566 wxPyEndAllowThreads(__tstate);
14567 if (PyErr_Occurred()) SWIG_fail;
14568 }
14569 resultobj = result;
14570 {
14571 if (temp2)
14572 delete arg2;
14573 }
14574 {
14575 if (temp3)
14576 delete arg3;
14577 }
14578 return resultobj;
14579 fail:
14580 {
14581 if (temp2)
14582 delete arg2;
14583 }
14584 {
14585 if (temp3)
14586 delete arg3;
14587 }
14588 return NULL;
14589 }
14590
14591
14592 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14593 PyObject *resultobj;
14594 wxFileType *arg1 = (wxFileType *) 0 ;
14595 wxString *arg2 = 0 ;
14596 wxString const &arg3_defvalue = wxPyEmptyString ;
14597 wxString *arg3 = (wxString *) &arg3_defvalue ;
14598 PyObject *result;
14599 bool temp2 = false ;
14600 bool temp3 = false ;
14601 PyObject * obj0 = 0 ;
14602 PyObject * obj1 = 0 ;
14603 PyObject * obj2 = 0 ;
14604 char *kwnames[] = {
14605 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14606 };
14607
14608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14610 if (SWIG_arg_fail(1)) SWIG_fail;
14611 {
14612 arg2 = wxString_in_helper(obj1);
14613 if (arg2 == NULL) SWIG_fail;
14614 temp2 = true;
14615 }
14616 if (obj2) {
14617 {
14618 arg3 = wxString_in_helper(obj2);
14619 if (arg3 == NULL) SWIG_fail;
14620 temp3 = true;
14621 }
14622 }
14623 {
14624 PyThreadState* __tstate = wxPyBeginAllowThreads();
14625 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14626
14627 wxPyEndAllowThreads(__tstate);
14628 if (PyErr_Occurred()) SWIG_fail;
14629 }
14630 resultobj = result;
14631 {
14632 if (temp2)
14633 delete arg2;
14634 }
14635 {
14636 if (temp3)
14637 delete arg3;
14638 }
14639 return resultobj;
14640 fail:
14641 {
14642 if (temp2)
14643 delete arg2;
14644 }
14645 {
14646 if (temp3)
14647 delete arg3;
14648 }
14649 return NULL;
14650 }
14651
14652
14653 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14654 PyObject *resultobj;
14655 wxFileType *arg1 = (wxFileType *) 0 ;
14656 wxString *arg2 = 0 ;
14657 wxString const &arg3_defvalue = wxPyEmptyString ;
14658 wxString *arg3 = (wxString *) &arg3_defvalue ;
14659 PyObject *result;
14660 bool temp2 = false ;
14661 bool temp3 = false ;
14662 PyObject * obj0 = 0 ;
14663 PyObject * obj1 = 0 ;
14664 PyObject * obj2 = 0 ;
14665 char *kwnames[] = {
14666 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14667 };
14668
14669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14671 if (SWIG_arg_fail(1)) SWIG_fail;
14672 {
14673 arg2 = wxString_in_helper(obj1);
14674 if (arg2 == NULL) SWIG_fail;
14675 temp2 = true;
14676 }
14677 if (obj2) {
14678 {
14679 arg3 = wxString_in_helper(obj2);
14680 if (arg3 == NULL) SWIG_fail;
14681 temp3 = true;
14682 }
14683 }
14684 {
14685 PyThreadState* __tstate = wxPyBeginAllowThreads();
14686 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14687
14688 wxPyEndAllowThreads(__tstate);
14689 if (PyErr_Occurred()) SWIG_fail;
14690 }
14691 resultobj = result;
14692 {
14693 if (temp2)
14694 delete arg2;
14695 }
14696 {
14697 if (temp3)
14698 delete arg3;
14699 }
14700 return resultobj;
14701 fail:
14702 {
14703 if (temp2)
14704 delete arg2;
14705 }
14706 {
14707 if (temp3)
14708 delete arg3;
14709 }
14710 return NULL;
14711 }
14712
14713
14714 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14715 PyObject *resultobj;
14716 wxFileType *arg1 = (wxFileType *) 0 ;
14717 wxString *arg2 = 0 ;
14718 wxString *arg3 = 0 ;
14719 bool arg4 = (bool) true ;
14720 bool result;
14721 bool temp2 = false ;
14722 bool temp3 = false ;
14723 PyObject * obj0 = 0 ;
14724 PyObject * obj1 = 0 ;
14725 PyObject * obj2 = 0 ;
14726 PyObject * obj3 = 0 ;
14727 char *kwnames[] = {
14728 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14729 };
14730
14731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14733 if (SWIG_arg_fail(1)) SWIG_fail;
14734 {
14735 arg2 = wxString_in_helper(obj1);
14736 if (arg2 == NULL) SWIG_fail;
14737 temp2 = true;
14738 }
14739 {
14740 arg3 = wxString_in_helper(obj2);
14741 if (arg3 == NULL) SWIG_fail;
14742 temp3 = true;
14743 }
14744 if (obj3) {
14745 {
14746 arg4 = (bool)(SWIG_As_bool(obj3));
14747 if (SWIG_arg_fail(4)) SWIG_fail;
14748 }
14749 }
14750 {
14751 PyThreadState* __tstate = wxPyBeginAllowThreads();
14752 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14753
14754 wxPyEndAllowThreads(__tstate);
14755 if (PyErr_Occurred()) SWIG_fail;
14756 }
14757 {
14758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14759 }
14760 {
14761 if (temp2)
14762 delete arg2;
14763 }
14764 {
14765 if (temp3)
14766 delete arg3;
14767 }
14768 return resultobj;
14769 fail:
14770 {
14771 if (temp2)
14772 delete arg2;
14773 }
14774 {
14775 if (temp3)
14776 delete arg3;
14777 }
14778 return NULL;
14779 }
14780
14781
14782 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14783 PyObject *resultobj;
14784 wxFileType *arg1 = (wxFileType *) 0 ;
14785 wxString const &arg2_defvalue = wxPyEmptyString ;
14786 wxString *arg2 = (wxString *) &arg2_defvalue ;
14787 int arg3 = (int) 0 ;
14788 bool result;
14789 bool temp2 = false ;
14790 PyObject * obj0 = 0 ;
14791 PyObject * obj1 = 0 ;
14792 PyObject * obj2 = 0 ;
14793 char *kwnames[] = {
14794 (char *) "self",(char *) "cmd",(char *) "index", NULL
14795 };
14796
14797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14799 if (SWIG_arg_fail(1)) SWIG_fail;
14800 if (obj1) {
14801 {
14802 arg2 = wxString_in_helper(obj1);
14803 if (arg2 == NULL) SWIG_fail;
14804 temp2 = true;
14805 }
14806 }
14807 if (obj2) {
14808 {
14809 arg3 = (int)(SWIG_As_int(obj2));
14810 if (SWIG_arg_fail(3)) SWIG_fail;
14811 }
14812 }
14813 {
14814 PyThreadState* __tstate = wxPyBeginAllowThreads();
14815 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14816
14817 wxPyEndAllowThreads(__tstate);
14818 if (PyErr_Occurred()) SWIG_fail;
14819 }
14820 {
14821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14822 }
14823 {
14824 if (temp2)
14825 delete arg2;
14826 }
14827 return resultobj;
14828 fail:
14829 {
14830 if (temp2)
14831 delete arg2;
14832 }
14833 return NULL;
14834 }
14835
14836
14837 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14838 PyObject *resultobj;
14839 wxFileType *arg1 = (wxFileType *) 0 ;
14840 bool result;
14841 PyObject * obj0 = 0 ;
14842 char *kwnames[] = {
14843 (char *) "self", NULL
14844 };
14845
14846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14848 if (SWIG_arg_fail(1)) SWIG_fail;
14849 {
14850 PyThreadState* __tstate = wxPyBeginAllowThreads();
14851 result = (bool)(arg1)->Unassociate();
14852
14853 wxPyEndAllowThreads(__tstate);
14854 if (PyErr_Occurred()) SWIG_fail;
14855 }
14856 {
14857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14858 }
14859 return resultobj;
14860 fail:
14861 return NULL;
14862 }
14863
14864
14865 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14866 PyObject *resultobj;
14867 wxString *arg1 = 0 ;
14868 wxString *arg2 = 0 ;
14869 wxString const &arg3_defvalue = wxPyEmptyString ;
14870 wxString *arg3 = (wxString *) &arg3_defvalue ;
14871 wxString result;
14872 bool temp1 = false ;
14873 bool temp2 = false ;
14874 bool temp3 = false ;
14875 PyObject * obj0 = 0 ;
14876 PyObject * obj1 = 0 ;
14877 PyObject * obj2 = 0 ;
14878 char *kwnames[] = {
14879 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14880 };
14881
14882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14883 {
14884 arg1 = wxString_in_helper(obj0);
14885 if (arg1 == NULL) SWIG_fail;
14886 temp1 = true;
14887 }
14888 {
14889 arg2 = wxString_in_helper(obj1);
14890 if (arg2 == NULL) SWIG_fail;
14891 temp2 = true;
14892 }
14893 if (obj2) {
14894 {
14895 arg3 = wxString_in_helper(obj2);
14896 if (arg3 == NULL) SWIG_fail;
14897 temp3 = true;
14898 }
14899 }
14900 {
14901 PyThreadState* __tstate = wxPyBeginAllowThreads();
14902 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14903
14904 wxPyEndAllowThreads(__tstate);
14905 if (PyErr_Occurred()) SWIG_fail;
14906 }
14907 {
14908 #if wxUSE_UNICODE
14909 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14910 #else
14911 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14912 #endif
14913 }
14914 {
14915 if (temp1)
14916 delete arg1;
14917 }
14918 {
14919 if (temp2)
14920 delete arg2;
14921 }
14922 {
14923 if (temp3)
14924 delete arg3;
14925 }
14926 return resultobj;
14927 fail:
14928 {
14929 if (temp1)
14930 delete arg1;
14931 }
14932 {
14933 if (temp2)
14934 delete arg2;
14935 }
14936 {
14937 if (temp3)
14938 delete arg3;
14939 }
14940 return NULL;
14941 }
14942
14943
14944 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14945 PyObject *obj;
14946 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14947 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14948 Py_INCREF(obj);
14949 return Py_BuildValue((char *)"");
14950 }
14951 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14952 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14953 return 1;
14954 }
14955
14956
14957 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14958 PyObject *pyobj;
14959
14960 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14961 return pyobj;
14962 }
14963
14964
14965 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14966 PyObject *resultobj;
14967 wxString *arg1 = 0 ;
14968 wxString *arg2 = 0 ;
14969 bool result;
14970 bool temp1 = false ;
14971 bool temp2 = false ;
14972 PyObject * obj0 = 0 ;
14973 PyObject * obj1 = 0 ;
14974 char *kwnames[] = {
14975 (char *) "mimeType",(char *) "wildcard", NULL
14976 };
14977
14978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14979 {
14980 arg1 = wxString_in_helper(obj0);
14981 if (arg1 == NULL) SWIG_fail;
14982 temp1 = true;
14983 }
14984 {
14985 arg2 = wxString_in_helper(obj1);
14986 if (arg2 == NULL) SWIG_fail;
14987 temp2 = true;
14988 }
14989 {
14990 PyThreadState* __tstate = wxPyBeginAllowThreads();
14991 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14992
14993 wxPyEndAllowThreads(__tstate);
14994 if (PyErr_Occurred()) SWIG_fail;
14995 }
14996 {
14997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14998 }
14999 {
15000 if (temp1)
15001 delete arg1;
15002 }
15003 {
15004 if (temp2)
15005 delete arg2;
15006 }
15007 return resultobj;
15008 fail:
15009 {
15010 if (temp1)
15011 delete arg1;
15012 }
15013 {
15014 if (temp2)
15015 delete arg2;
15016 }
15017 return NULL;
15018 }
15019
15020
15021 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15022 PyObject *resultobj;
15023 wxMimeTypesManager *result;
15024 char *kwnames[] = {
15025 NULL
15026 };
15027
15028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15029 {
15030 PyThreadState* __tstate = wxPyBeginAllowThreads();
15031 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15032
15033 wxPyEndAllowThreads(__tstate);
15034 if (PyErr_Occurred()) SWIG_fail;
15035 }
15036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15037 return resultobj;
15038 fail:
15039 return NULL;
15040 }
15041
15042
15043 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15044 PyObject *resultobj;
15045 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15046 int arg2 = (int) wxMAILCAP_ALL ;
15047 wxString const &arg3_defvalue = wxPyEmptyString ;
15048 wxString *arg3 = (wxString *) &arg3_defvalue ;
15049 bool temp3 = false ;
15050 PyObject * obj0 = 0 ;
15051 PyObject * obj1 = 0 ;
15052 PyObject * obj2 = 0 ;
15053 char *kwnames[] = {
15054 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15055 };
15056
15057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15059 if (SWIG_arg_fail(1)) SWIG_fail;
15060 if (obj1) {
15061 {
15062 arg2 = (int)(SWIG_As_int(obj1));
15063 if (SWIG_arg_fail(2)) SWIG_fail;
15064 }
15065 }
15066 if (obj2) {
15067 {
15068 arg3 = wxString_in_helper(obj2);
15069 if (arg3 == NULL) SWIG_fail;
15070 temp3 = true;
15071 }
15072 }
15073 {
15074 PyThreadState* __tstate = wxPyBeginAllowThreads();
15075 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15076
15077 wxPyEndAllowThreads(__tstate);
15078 if (PyErr_Occurred()) SWIG_fail;
15079 }
15080 Py_INCREF(Py_None); resultobj = Py_None;
15081 {
15082 if (temp3)
15083 delete arg3;
15084 }
15085 return resultobj;
15086 fail:
15087 {
15088 if (temp3)
15089 delete arg3;
15090 }
15091 return NULL;
15092 }
15093
15094
15095 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15096 PyObject *resultobj;
15097 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15098 PyObject * obj0 = 0 ;
15099 char *kwnames[] = {
15100 (char *) "self", NULL
15101 };
15102
15103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15105 if (SWIG_arg_fail(1)) SWIG_fail;
15106 {
15107 PyThreadState* __tstate = wxPyBeginAllowThreads();
15108 (arg1)->ClearData();
15109
15110 wxPyEndAllowThreads(__tstate);
15111 if (PyErr_Occurred()) SWIG_fail;
15112 }
15113 Py_INCREF(Py_None); resultobj = Py_None;
15114 return resultobj;
15115 fail:
15116 return NULL;
15117 }
15118
15119
15120 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15121 PyObject *resultobj;
15122 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15123 wxString *arg2 = 0 ;
15124 wxFileType *result;
15125 bool temp2 = false ;
15126 PyObject * obj0 = 0 ;
15127 PyObject * obj1 = 0 ;
15128 char *kwnames[] = {
15129 (char *) "self",(char *) "ext", NULL
15130 };
15131
15132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15134 if (SWIG_arg_fail(1)) SWIG_fail;
15135 {
15136 arg2 = wxString_in_helper(obj1);
15137 if (arg2 == NULL) SWIG_fail;
15138 temp2 = true;
15139 }
15140 {
15141 PyThreadState* __tstate = wxPyBeginAllowThreads();
15142 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15143
15144 wxPyEndAllowThreads(__tstate);
15145 if (PyErr_Occurred()) SWIG_fail;
15146 }
15147 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15148 {
15149 if (temp2)
15150 delete arg2;
15151 }
15152 return resultobj;
15153 fail:
15154 {
15155 if (temp2)
15156 delete arg2;
15157 }
15158 return NULL;
15159 }
15160
15161
15162 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15163 PyObject *resultobj;
15164 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15165 wxString *arg2 = 0 ;
15166 wxFileType *result;
15167 bool temp2 = false ;
15168 PyObject * obj0 = 0 ;
15169 PyObject * obj1 = 0 ;
15170 char *kwnames[] = {
15171 (char *) "self",(char *) "mimeType", NULL
15172 };
15173
15174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15176 if (SWIG_arg_fail(1)) SWIG_fail;
15177 {
15178 arg2 = wxString_in_helper(obj1);
15179 if (arg2 == NULL) SWIG_fail;
15180 temp2 = true;
15181 }
15182 {
15183 PyThreadState* __tstate = wxPyBeginAllowThreads();
15184 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15185
15186 wxPyEndAllowThreads(__tstate);
15187 if (PyErr_Occurred()) SWIG_fail;
15188 }
15189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15190 {
15191 if (temp2)
15192 delete arg2;
15193 }
15194 return resultobj;
15195 fail:
15196 {
15197 if (temp2)
15198 delete arg2;
15199 }
15200 return NULL;
15201 }
15202
15203
15204 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15205 PyObject *resultobj;
15206 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15207 wxString *arg2 = 0 ;
15208 bool arg3 = (bool) false ;
15209 bool result;
15210 bool temp2 = false ;
15211 PyObject * obj0 = 0 ;
15212 PyObject * obj1 = 0 ;
15213 PyObject * obj2 = 0 ;
15214 char *kwnames[] = {
15215 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15216 };
15217
15218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15220 if (SWIG_arg_fail(1)) SWIG_fail;
15221 {
15222 arg2 = wxString_in_helper(obj1);
15223 if (arg2 == NULL) SWIG_fail;
15224 temp2 = true;
15225 }
15226 if (obj2) {
15227 {
15228 arg3 = (bool)(SWIG_As_bool(obj2));
15229 if (SWIG_arg_fail(3)) SWIG_fail;
15230 }
15231 }
15232 {
15233 PyThreadState* __tstate = wxPyBeginAllowThreads();
15234 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15235
15236 wxPyEndAllowThreads(__tstate);
15237 if (PyErr_Occurred()) SWIG_fail;
15238 }
15239 {
15240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15241 }
15242 {
15243 if (temp2)
15244 delete arg2;
15245 }
15246 return resultobj;
15247 fail:
15248 {
15249 if (temp2)
15250 delete arg2;
15251 }
15252 return NULL;
15253 }
15254
15255
15256 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15257 PyObject *resultobj;
15258 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15259 wxString *arg2 = 0 ;
15260 bool result;
15261 bool temp2 = false ;
15262 PyObject * obj0 = 0 ;
15263 PyObject * obj1 = 0 ;
15264 char *kwnames[] = {
15265 (char *) "self",(char *) "filename", NULL
15266 };
15267
15268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15270 if (SWIG_arg_fail(1)) SWIG_fail;
15271 {
15272 arg2 = wxString_in_helper(obj1);
15273 if (arg2 == NULL) SWIG_fail;
15274 temp2 = true;
15275 }
15276 {
15277 PyThreadState* __tstate = wxPyBeginAllowThreads();
15278 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15279
15280 wxPyEndAllowThreads(__tstate);
15281 if (PyErr_Occurred()) SWIG_fail;
15282 }
15283 {
15284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15285 }
15286 {
15287 if (temp2)
15288 delete arg2;
15289 }
15290 return resultobj;
15291 fail:
15292 {
15293 if (temp2)
15294 delete arg2;
15295 }
15296 return NULL;
15297 }
15298
15299
15300 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15301 PyObject *resultobj;
15302 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15303 PyObject *result;
15304 PyObject * obj0 = 0 ;
15305 char *kwnames[] = {
15306 (char *) "self", NULL
15307 };
15308
15309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15311 if (SWIG_arg_fail(1)) SWIG_fail;
15312 {
15313 PyThreadState* __tstate = wxPyBeginAllowThreads();
15314 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15315
15316 wxPyEndAllowThreads(__tstate);
15317 if (PyErr_Occurred()) SWIG_fail;
15318 }
15319 resultobj = result;
15320 return resultobj;
15321 fail:
15322 return NULL;
15323 }
15324
15325
15326 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15327 PyObject *resultobj;
15328 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15329 wxFileTypeInfo *arg2 = 0 ;
15330 PyObject * obj0 = 0 ;
15331 PyObject * obj1 = 0 ;
15332 char *kwnames[] = {
15333 (char *) "self",(char *) "ft", NULL
15334 };
15335
15336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15338 if (SWIG_arg_fail(1)) SWIG_fail;
15339 {
15340 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15341 if (SWIG_arg_fail(2)) SWIG_fail;
15342 if (arg2 == NULL) {
15343 SWIG_null_ref("wxFileTypeInfo");
15344 }
15345 if (SWIG_arg_fail(2)) SWIG_fail;
15346 }
15347 {
15348 PyThreadState* __tstate = wxPyBeginAllowThreads();
15349 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15350
15351 wxPyEndAllowThreads(__tstate);
15352 if (PyErr_Occurred()) SWIG_fail;
15353 }
15354 Py_INCREF(Py_None); resultobj = Py_None;
15355 return resultobj;
15356 fail:
15357 return NULL;
15358 }
15359
15360
15361 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15362 PyObject *resultobj;
15363 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15364 wxFileTypeInfo *arg2 = 0 ;
15365 wxFileType *result;
15366 PyObject * obj0 = 0 ;
15367 PyObject * obj1 = 0 ;
15368 char *kwnames[] = {
15369 (char *) "self",(char *) "ftInfo", NULL
15370 };
15371
15372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15374 if (SWIG_arg_fail(1)) SWIG_fail;
15375 {
15376 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15377 if (SWIG_arg_fail(2)) SWIG_fail;
15378 if (arg2 == NULL) {
15379 SWIG_null_ref("wxFileTypeInfo");
15380 }
15381 if (SWIG_arg_fail(2)) SWIG_fail;
15382 }
15383 {
15384 PyThreadState* __tstate = wxPyBeginAllowThreads();
15385 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15386
15387 wxPyEndAllowThreads(__tstate);
15388 if (PyErr_Occurred()) SWIG_fail;
15389 }
15390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15391 return resultobj;
15392 fail:
15393 return NULL;
15394 }
15395
15396
15397 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15398 PyObject *resultobj;
15399 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15400 wxFileType *arg2 = (wxFileType *) 0 ;
15401 bool result;
15402 PyObject * obj0 = 0 ;
15403 PyObject * obj1 = 0 ;
15404 char *kwnames[] = {
15405 (char *) "self",(char *) "ft", NULL
15406 };
15407
15408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15410 if (SWIG_arg_fail(1)) SWIG_fail;
15411 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15412 if (SWIG_arg_fail(2)) SWIG_fail;
15413 {
15414 PyThreadState* __tstate = wxPyBeginAllowThreads();
15415 result = (bool)(arg1)->Unassociate(arg2);
15416
15417 wxPyEndAllowThreads(__tstate);
15418 if (PyErr_Occurred()) SWIG_fail;
15419 }
15420 {
15421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15422 }
15423 return resultobj;
15424 fail:
15425 return NULL;
15426 }
15427
15428
15429 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15430 PyObject *resultobj;
15431 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15432 PyObject * obj0 = 0 ;
15433 char *kwnames[] = {
15434 (char *) "self", NULL
15435 };
15436
15437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15439 if (SWIG_arg_fail(1)) SWIG_fail;
15440 {
15441 PyThreadState* __tstate = wxPyBeginAllowThreads();
15442 delete arg1;
15443
15444 wxPyEndAllowThreads(__tstate);
15445 if (PyErr_Occurred()) SWIG_fail;
15446 }
15447 Py_INCREF(Py_None); resultobj = Py_None;
15448 return resultobj;
15449 fail:
15450 return NULL;
15451 }
15452
15453
15454 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15455 PyObject *obj;
15456 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15457 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15458 Py_INCREF(obj);
15459 return Py_BuildValue((char *)"");
15460 }
15461 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15462 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15463 return 1;
15464 }
15465
15466
15467 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15468 PyObject *pyobj;
15469
15470 {
15471 #if wxUSE_UNICODE
15472 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15473 #else
15474 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15475 #endif
15476 }
15477 return pyobj;
15478 }
15479
15480
15481 static int _wrap_ART_MENU_set(PyObject *) {
15482 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15483 return 1;
15484 }
15485
15486
15487 static PyObject *_wrap_ART_MENU_get(void) {
15488 PyObject *pyobj;
15489
15490 {
15491 #if wxUSE_UNICODE
15492 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15493 #else
15494 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15495 #endif
15496 }
15497 return pyobj;
15498 }
15499
15500
15501 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15502 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15503 return 1;
15504 }
15505
15506
15507 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15508 PyObject *pyobj;
15509
15510 {
15511 #if wxUSE_UNICODE
15512 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15513 #else
15514 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15515 #endif
15516 }
15517 return pyobj;
15518 }
15519
15520
15521 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15522 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15523 return 1;
15524 }
15525
15526
15527 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15528 PyObject *pyobj;
15529
15530 {
15531 #if wxUSE_UNICODE
15532 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15533 #else
15534 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15535 #endif
15536 }
15537 return pyobj;
15538 }
15539
15540
15541 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15542 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15543 return 1;
15544 }
15545
15546
15547 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15548 PyObject *pyobj;
15549
15550 {
15551 #if wxUSE_UNICODE
15552 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15553 #else
15554 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15555 #endif
15556 }
15557 return pyobj;
15558 }
15559
15560
15561 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15562 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15563 return 1;
15564 }
15565
15566
15567 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15568 PyObject *pyobj;
15569
15570 {
15571 #if wxUSE_UNICODE
15572 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15573 #else
15574 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15575 #endif
15576 }
15577 return pyobj;
15578 }
15579
15580
15581 static int _wrap_ART_BUTTON_set(PyObject *) {
15582 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15583 return 1;
15584 }
15585
15586
15587 static PyObject *_wrap_ART_BUTTON_get(void) {
15588 PyObject *pyobj;
15589
15590 {
15591 #if wxUSE_UNICODE
15592 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15593 #else
15594 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15595 #endif
15596 }
15597 return pyobj;
15598 }
15599
15600
15601 static int _wrap_ART_OTHER_set(PyObject *) {
15602 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15603 return 1;
15604 }
15605
15606
15607 static PyObject *_wrap_ART_OTHER_get(void) {
15608 PyObject *pyobj;
15609
15610 {
15611 #if wxUSE_UNICODE
15612 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15613 #else
15614 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15615 #endif
15616 }
15617 return pyobj;
15618 }
15619
15620
15621 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15622 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15623 return 1;
15624 }
15625
15626
15627 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15628 PyObject *pyobj;
15629
15630 {
15631 #if wxUSE_UNICODE
15632 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15633 #else
15634 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15635 #endif
15636 }
15637 return pyobj;
15638 }
15639
15640
15641 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15642 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15643 return 1;
15644 }
15645
15646
15647 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15648 PyObject *pyobj;
15649
15650 {
15651 #if wxUSE_UNICODE
15652 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15653 #else
15654 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15655 #endif
15656 }
15657 return pyobj;
15658 }
15659
15660
15661 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15662 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15663 return 1;
15664 }
15665
15666
15667 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15668 PyObject *pyobj;
15669
15670 {
15671 #if wxUSE_UNICODE
15672 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15673 #else
15674 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15675 #endif
15676 }
15677 return pyobj;
15678 }
15679
15680
15681 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15682 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15683 return 1;
15684 }
15685
15686
15687 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15688 PyObject *pyobj;
15689
15690 {
15691 #if wxUSE_UNICODE
15692 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15693 #else
15694 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15695 #endif
15696 }
15697 return pyobj;
15698 }
15699
15700
15701 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15702 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15703 return 1;
15704 }
15705
15706
15707 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15708 PyObject *pyobj;
15709
15710 {
15711 #if wxUSE_UNICODE
15712 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15713 #else
15714 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15715 #endif
15716 }
15717 return pyobj;
15718 }
15719
15720
15721 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15722 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15723 return 1;
15724 }
15725
15726
15727 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15728 PyObject *pyobj;
15729
15730 {
15731 #if wxUSE_UNICODE
15732 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15733 #else
15734 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15735 #endif
15736 }
15737 return pyobj;
15738 }
15739
15740
15741 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15742 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15743 return 1;
15744 }
15745
15746
15747 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15748 PyObject *pyobj;
15749
15750 {
15751 #if wxUSE_UNICODE
15752 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15753 #else
15754 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15755 #endif
15756 }
15757 return pyobj;
15758 }
15759
15760
15761 static int _wrap_ART_GO_BACK_set(PyObject *) {
15762 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15763 return 1;
15764 }
15765
15766
15767 static PyObject *_wrap_ART_GO_BACK_get(void) {
15768 PyObject *pyobj;
15769
15770 {
15771 #if wxUSE_UNICODE
15772 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15773 #else
15774 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15775 #endif
15776 }
15777 return pyobj;
15778 }
15779
15780
15781 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15782 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15783 return 1;
15784 }
15785
15786
15787 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15788 PyObject *pyobj;
15789
15790 {
15791 #if wxUSE_UNICODE
15792 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15793 #else
15794 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15795 #endif
15796 }
15797 return pyobj;
15798 }
15799
15800
15801 static int _wrap_ART_GO_UP_set(PyObject *) {
15802 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15803 return 1;
15804 }
15805
15806
15807 static PyObject *_wrap_ART_GO_UP_get(void) {
15808 PyObject *pyobj;
15809
15810 {
15811 #if wxUSE_UNICODE
15812 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15813 #else
15814 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15815 #endif
15816 }
15817 return pyobj;
15818 }
15819
15820
15821 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15822 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15823 return 1;
15824 }
15825
15826
15827 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15828 PyObject *pyobj;
15829
15830 {
15831 #if wxUSE_UNICODE
15832 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15833 #else
15834 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15835 #endif
15836 }
15837 return pyobj;
15838 }
15839
15840
15841 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15842 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15843 return 1;
15844 }
15845
15846
15847 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15848 PyObject *pyobj;
15849
15850 {
15851 #if wxUSE_UNICODE
15852 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15853 #else
15854 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15855 #endif
15856 }
15857 return pyobj;
15858 }
15859
15860
15861 static int _wrap_ART_GO_HOME_set(PyObject *) {
15862 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15863 return 1;
15864 }
15865
15866
15867 static PyObject *_wrap_ART_GO_HOME_get(void) {
15868 PyObject *pyobj;
15869
15870 {
15871 #if wxUSE_UNICODE
15872 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15873 #else
15874 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15875 #endif
15876 }
15877 return pyobj;
15878 }
15879
15880
15881 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15882 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15883 return 1;
15884 }
15885
15886
15887 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15888 PyObject *pyobj;
15889
15890 {
15891 #if wxUSE_UNICODE
15892 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15893 #else
15894 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15895 #endif
15896 }
15897 return pyobj;
15898 }
15899
15900
15901 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15902 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15903 return 1;
15904 }
15905
15906
15907 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15908 PyObject *pyobj;
15909
15910 {
15911 #if wxUSE_UNICODE
15912 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15913 #else
15914 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15915 #endif
15916 }
15917 return pyobj;
15918 }
15919
15920
15921 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15922 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15923 return 1;
15924 }
15925
15926
15927 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15928 PyObject *pyobj;
15929
15930 {
15931 #if wxUSE_UNICODE
15932 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15933 #else
15934 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15935 #endif
15936 }
15937 return pyobj;
15938 }
15939
15940
15941 static int _wrap_ART_PRINT_set(PyObject *) {
15942 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15943 return 1;
15944 }
15945
15946
15947 static PyObject *_wrap_ART_PRINT_get(void) {
15948 PyObject *pyobj;
15949
15950 {
15951 #if wxUSE_UNICODE
15952 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15953 #else
15954 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15955 #endif
15956 }
15957 return pyobj;
15958 }
15959
15960
15961 static int _wrap_ART_HELP_set(PyObject *) {
15962 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15963 return 1;
15964 }
15965
15966
15967 static PyObject *_wrap_ART_HELP_get(void) {
15968 PyObject *pyobj;
15969
15970 {
15971 #if wxUSE_UNICODE
15972 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15973 #else
15974 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15975 #endif
15976 }
15977 return pyobj;
15978 }
15979
15980
15981 static int _wrap_ART_TIP_set(PyObject *) {
15982 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15983 return 1;
15984 }
15985
15986
15987 static PyObject *_wrap_ART_TIP_get(void) {
15988 PyObject *pyobj;
15989
15990 {
15991 #if wxUSE_UNICODE
15992 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15993 #else
15994 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15995 #endif
15996 }
15997 return pyobj;
15998 }
15999
16000
16001 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16002 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16003 return 1;
16004 }
16005
16006
16007 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16008 PyObject *pyobj;
16009
16010 {
16011 #if wxUSE_UNICODE
16012 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16013 #else
16014 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16015 #endif
16016 }
16017 return pyobj;
16018 }
16019
16020
16021 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16022 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16023 return 1;
16024 }
16025
16026
16027 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16028 PyObject *pyobj;
16029
16030 {
16031 #if wxUSE_UNICODE
16032 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16033 #else
16034 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16035 #endif
16036 }
16037 return pyobj;
16038 }
16039
16040
16041 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16042 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16043 return 1;
16044 }
16045
16046
16047 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16048 PyObject *pyobj;
16049
16050 {
16051 #if wxUSE_UNICODE
16052 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16053 #else
16054 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16055 #endif
16056 }
16057 return pyobj;
16058 }
16059
16060
16061 static int _wrap_ART_HARDDISK_set(PyObject *) {
16062 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16063 return 1;
16064 }
16065
16066
16067 static PyObject *_wrap_ART_HARDDISK_get(void) {
16068 PyObject *pyobj;
16069
16070 {
16071 #if wxUSE_UNICODE
16072 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16073 #else
16074 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16075 #endif
16076 }
16077 return pyobj;
16078 }
16079
16080
16081 static int _wrap_ART_FLOPPY_set(PyObject *) {
16082 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16083 return 1;
16084 }
16085
16086
16087 static PyObject *_wrap_ART_FLOPPY_get(void) {
16088 PyObject *pyobj;
16089
16090 {
16091 #if wxUSE_UNICODE
16092 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16093 #else
16094 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16095 #endif
16096 }
16097 return pyobj;
16098 }
16099
16100
16101 static int _wrap_ART_CDROM_set(PyObject *) {
16102 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16103 return 1;
16104 }
16105
16106
16107 static PyObject *_wrap_ART_CDROM_get(void) {
16108 PyObject *pyobj;
16109
16110 {
16111 #if wxUSE_UNICODE
16112 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16113 #else
16114 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16115 #endif
16116 }
16117 return pyobj;
16118 }
16119
16120
16121 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16122 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16123 return 1;
16124 }
16125
16126
16127 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16128 PyObject *pyobj;
16129
16130 {
16131 #if wxUSE_UNICODE
16132 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16133 #else
16134 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16135 #endif
16136 }
16137 return pyobj;
16138 }
16139
16140
16141 static int _wrap_ART_FOLDER_set(PyObject *) {
16142 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16143 return 1;
16144 }
16145
16146
16147 static PyObject *_wrap_ART_FOLDER_get(void) {
16148 PyObject *pyobj;
16149
16150 {
16151 #if wxUSE_UNICODE
16152 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16153 #else
16154 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16155 #endif
16156 }
16157 return pyobj;
16158 }
16159
16160
16161 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16162 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16163 return 1;
16164 }
16165
16166
16167 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16168 PyObject *pyobj;
16169
16170 {
16171 #if wxUSE_UNICODE
16172 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16173 #else
16174 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16175 #endif
16176 }
16177 return pyobj;
16178 }
16179
16180
16181 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16182 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16183 return 1;
16184 }
16185
16186
16187 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16188 PyObject *pyobj;
16189
16190 {
16191 #if wxUSE_UNICODE
16192 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16193 #else
16194 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16195 #endif
16196 }
16197 return pyobj;
16198 }
16199
16200
16201 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16202 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16203 return 1;
16204 }
16205
16206
16207 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16208 PyObject *pyobj;
16209
16210 {
16211 #if wxUSE_UNICODE
16212 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16213 #else
16214 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16215 #endif
16216 }
16217 return pyobj;
16218 }
16219
16220
16221 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16222 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16223 return 1;
16224 }
16225
16226
16227 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16228 PyObject *pyobj;
16229
16230 {
16231 #if wxUSE_UNICODE
16232 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16233 #else
16234 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16235 #endif
16236 }
16237 return pyobj;
16238 }
16239
16240
16241 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16242 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16243 return 1;
16244 }
16245
16246
16247 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16248 PyObject *pyobj;
16249
16250 {
16251 #if wxUSE_UNICODE
16252 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16253 #else
16254 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16255 #endif
16256 }
16257 return pyobj;
16258 }
16259
16260
16261 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16262 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16263 return 1;
16264 }
16265
16266
16267 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16268 PyObject *pyobj;
16269
16270 {
16271 #if wxUSE_UNICODE
16272 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16273 #else
16274 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16275 #endif
16276 }
16277 return pyobj;
16278 }
16279
16280
16281 static int _wrap_ART_ERROR_set(PyObject *) {
16282 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16283 return 1;
16284 }
16285
16286
16287 static PyObject *_wrap_ART_ERROR_get(void) {
16288 PyObject *pyobj;
16289
16290 {
16291 #if wxUSE_UNICODE
16292 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16293 #else
16294 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16295 #endif
16296 }
16297 return pyobj;
16298 }
16299
16300
16301 static int _wrap_ART_QUESTION_set(PyObject *) {
16302 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16303 return 1;
16304 }
16305
16306
16307 static PyObject *_wrap_ART_QUESTION_get(void) {
16308 PyObject *pyobj;
16309
16310 {
16311 #if wxUSE_UNICODE
16312 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16313 #else
16314 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16315 #endif
16316 }
16317 return pyobj;
16318 }
16319
16320
16321 static int _wrap_ART_WARNING_set(PyObject *) {
16322 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16323 return 1;
16324 }
16325
16326
16327 static PyObject *_wrap_ART_WARNING_get(void) {
16328 PyObject *pyobj;
16329
16330 {
16331 #if wxUSE_UNICODE
16332 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16333 #else
16334 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16335 #endif
16336 }
16337 return pyobj;
16338 }
16339
16340
16341 static int _wrap_ART_INFORMATION_set(PyObject *) {
16342 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16343 return 1;
16344 }
16345
16346
16347 static PyObject *_wrap_ART_INFORMATION_get(void) {
16348 PyObject *pyobj;
16349
16350 {
16351 #if wxUSE_UNICODE
16352 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16353 #else
16354 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16355 #endif
16356 }
16357 return pyobj;
16358 }
16359
16360
16361 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16362 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16363 return 1;
16364 }
16365
16366
16367 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16368 PyObject *pyobj;
16369
16370 {
16371 #if wxUSE_UNICODE
16372 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16373 #else
16374 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16375 #endif
16376 }
16377 return pyobj;
16378 }
16379
16380
16381 static int _wrap_ART_COPY_set(PyObject *) {
16382 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16383 return 1;
16384 }
16385
16386
16387 static PyObject *_wrap_ART_COPY_get(void) {
16388 PyObject *pyobj;
16389
16390 {
16391 #if wxUSE_UNICODE
16392 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16393 #else
16394 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16395 #endif
16396 }
16397 return pyobj;
16398 }
16399
16400
16401 static int _wrap_ART_CUT_set(PyObject *) {
16402 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16403 return 1;
16404 }
16405
16406
16407 static PyObject *_wrap_ART_CUT_get(void) {
16408 PyObject *pyobj;
16409
16410 {
16411 #if wxUSE_UNICODE
16412 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16413 #else
16414 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16415 #endif
16416 }
16417 return pyobj;
16418 }
16419
16420
16421 static int _wrap_ART_PASTE_set(PyObject *) {
16422 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16423 return 1;
16424 }
16425
16426
16427 static PyObject *_wrap_ART_PASTE_get(void) {
16428 PyObject *pyobj;
16429
16430 {
16431 #if wxUSE_UNICODE
16432 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16433 #else
16434 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16435 #endif
16436 }
16437 return pyobj;
16438 }
16439
16440
16441 static int _wrap_ART_DELETE_set(PyObject *) {
16442 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16443 return 1;
16444 }
16445
16446
16447 static PyObject *_wrap_ART_DELETE_get(void) {
16448 PyObject *pyobj;
16449
16450 {
16451 #if wxUSE_UNICODE
16452 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16453 #else
16454 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16455 #endif
16456 }
16457 return pyobj;
16458 }
16459
16460
16461 static int _wrap_ART_UNDO_set(PyObject *) {
16462 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16463 return 1;
16464 }
16465
16466
16467 static PyObject *_wrap_ART_UNDO_get(void) {
16468 PyObject *pyobj;
16469
16470 {
16471 #if wxUSE_UNICODE
16472 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16473 #else
16474 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16475 #endif
16476 }
16477 return pyobj;
16478 }
16479
16480
16481 static int _wrap_ART_REDO_set(PyObject *) {
16482 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16483 return 1;
16484 }
16485
16486
16487 static PyObject *_wrap_ART_REDO_get(void) {
16488 PyObject *pyobj;
16489
16490 {
16491 #if wxUSE_UNICODE
16492 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16493 #else
16494 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16495 #endif
16496 }
16497 return pyobj;
16498 }
16499
16500
16501 static int _wrap_ART_QUIT_set(PyObject *) {
16502 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16503 return 1;
16504 }
16505
16506
16507 static PyObject *_wrap_ART_QUIT_get(void) {
16508 PyObject *pyobj;
16509
16510 {
16511 #if wxUSE_UNICODE
16512 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16513 #else
16514 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16515 #endif
16516 }
16517 return pyobj;
16518 }
16519
16520
16521 static int _wrap_ART_FIND_set(PyObject *) {
16522 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16523 return 1;
16524 }
16525
16526
16527 static PyObject *_wrap_ART_FIND_get(void) {
16528 PyObject *pyobj;
16529
16530 {
16531 #if wxUSE_UNICODE
16532 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16533 #else
16534 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16535 #endif
16536 }
16537 return pyobj;
16538 }
16539
16540
16541 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16542 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16543 return 1;
16544 }
16545
16546
16547 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16548 PyObject *pyobj;
16549
16550 {
16551 #if wxUSE_UNICODE
16552 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16553 #else
16554 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16555 #endif
16556 }
16557 return pyobj;
16558 }
16559
16560
16561 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16562 PyObject *resultobj;
16563 wxPyArtProvider *result;
16564 char *kwnames[] = {
16565 NULL
16566 };
16567
16568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16569 {
16570 if (!wxPyCheckForApp()) SWIG_fail;
16571 PyThreadState* __tstate = wxPyBeginAllowThreads();
16572 result = (wxPyArtProvider *)new wxPyArtProvider();
16573
16574 wxPyEndAllowThreads(__tstate);
16575 if (PyErr_Occurred()) SWIG_fail;
16576 }
16577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16578 return resultobj;
16579 fail:
16580 return NULL;
16581 }
16582
16583
16584 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16585 PyObject *resultobj;
16586 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16587 PyObject *arg2 = (PyObject *) 0 ;
16588 PyObject *arg3 = (PyObject *) 0 ;
16589 PyObject * obj0 = 0 ;
16590 PyObject * obj1 = 0 ;
16591 PyObject * obj2 = 0 ;
16592 char *kwnames[] = {
16593 (char *) "self",(char *) "self",(char *) "_class", NULL
16594 };
16595
16596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16598 if (SWIG_arg_fail(1)) SWIG_fail;
16599 arg2 = obj1;
16600 arg3 = obj2;
16601 {
16602 PyThreadState* __tstate = wxPyBeginAllowThreads();
16603 (arg1)->_setCallbackInfo(arg2,arg3);
16604
16605 wxPyEndAllowThreads(__tstate);
16606 if (PyErr_Occurred()) SWIG_fail;
16607 }
16608 Py_INCREF(Py_None); resultobj = Py_None;
16609 return resultobj;
16610 fail:
16611 return NULL;
16612 }
16613
16614
16615 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16616 PyObject *resultobj;
16617 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16618 PyObject * obj0 = 0 ;
16619 char *kwnames[] = {
16620 (char *) "provider", NULL
16621 };
16622
16623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16625 if (SWIG_arg_fail(1)) SWIG_fail;
16626 {
16627 PyThreadState* __tstate = wxPyBeginAllowThreads();
16628 wxPyArtProvider::PushProvider(arg1);
16629
16630 wxPyEndAllowThreads(__tstate);
16631 if (PyErr_Occurred()) SWIG_fail;
16632 }
16633 Py_INCREF(Py_None); resultobj = Py_None;
16634 return resultobj;
16635 fail:
16636 return NULL;
16637 }
16638
16639
16640 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16641 PyObject *resultobj;
16642 bool result;
16643 char *kwnames[] = {
16644 NULL
16645 };
16646
16647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16648 {
16649 PyThreadState* __tstate = wxPyBeginAllowThreads();
16650 result = (bool)wxPyArtProvider::PopProvider();
16651
16652 wxPyEndAllowThreads(__tstate);
16653 if (PyErr_Occurred()) SWIG_fail;
16654 }
16655 {
16656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16657 }
16658 return resultobj;
16659 fail:
16660 return NULL;
16661 }
16662
16663
16664 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16665 PyObject *resultobj;
16666 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16667 bool result;
16668 PyObject * obj0 = 0 ;
16669 char *kwnames[] = {
16670 (char *) "provider", NULL
16671 };
16672
16673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16675 if (SWIG_arg_fail(1)) SWIG_fail;
16676 {
16677 PyThreadState* __tstate = wxPyBeginAllowThreads();
16678 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16679
16680 wxPyEndAllowThreads(__tstate);
16681 if (PyErr_Occurred()) SWIG_fail;
16682 }
16683 {
16684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16685 }
16686 return resultobj;
16687 fail:
16688 return NULL;
16689 }
16690
16691
16692 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16693 PyObject *resultobj;
16694 wxString *arg1 = 0 ;
16695 wxString const &arg2_defvalue = wxPyART_OTHER ;
16696 wxString *arg2 = (wxString *) &arg2_defvalue ;
16697 wxSize const &arg3_defvalue = wxDefaultSize ;
16698 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16699 wxBitmap result;
16700 bool temp1 = false ;
16701 bool temp2 = false ;
16702 wxSize temp3 ;
16703 PyObject * obj0 = 0 ;
16704 PyObject * obj1 = 0 ;
16705 PyObject * obj2 = 0 ;
16706 char *kwnames[] = {
16707 (char *) "id",(char *) "client",(char *) "size", NULL
16708 };
16709
16710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16711 {
16712 arg1 = wxString_in_helper(obj0);
16713 if (arg1 == NULL) SWIG_fail;
16714 temp1 = true;
16715 }
16716 if (obj1) {
16717 {
16718 arg2 = wxString_in_helper(obj1);
16719 if (arg2 == NULL) SWIG_fail;
16720 temp2 = true;
16721 }
16722 }
16723 if (obj2) {
16724 {
16725 arg3 = &temp3;
16726 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16727 }
16728 }
16729 {
16730 if (!wxPyCheckForApp()) SWIG_fail;
16731 PyThreadState* __tstate = wxPyBeginAllowThreads();
16732 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16733
16734 wxPyEndAllowThreads(__tstate);
16735 if (PyErr_Occurred()) SWIG_fail;
16736 }
16737 {
16738 wxBitmap * resultptr;
16739 resultptr = new wxBitmap((wxBitmap &)(result));
16740 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16741 }
16742 {
16743 if (temp1)
16744 delete arg1;
16745 }
16746 {
16747 if (temp2)
16748 delete arg2;
16749 }
16750 return resultobj;
16751 fail:
16752 {
16753 if (temp1)
16754 delete arg1;
16755 }
16756 {
16757 if (temp2)
16758 delete arg2;
16759 }
16760 return NULL;
16761 }
16762
16763
16764 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16765 PyObject *resultobj;
16766 wxString *arg1 = 0 ;
16767 wxString const &arg2_defvalue = wxPyART_OTHER ;
16768 wxString *arg2 = (wxString *) &arg2_defvalue ;
16769 wxSize const &arg3_defvalue = wxDefaultSize ;
16770 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16771 wxIcon result;
16772 bool temp1 = false ;
16773 bool temp2 = false ;
16774 wxSize temp3 ;
16775 PyObject * obj0 = 0 ;
16776 PyObject * obj1 = 0 ;
16777 PyObject * obj2 = 0 ;
16778 char *kwnames[] = {
16779 (char *) "id",(char *) "client",(char *) "size", NULL
16780 };
16781
16782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16783 {
16784 arg1 = wxString_in_helper(obj0);
16785 if (arg1 == NULL) SWIG_fail;
16786 temp1 = true;
16787 }
16788 if (obj1) {
16789 {
16790 arg2 = wxString_in_helper(obj1);
16791 if (arg2 == NULL) SWIG_fail;
16792 temp2 = true;
16793 }
16794 }
16795 if (obj2) {
16796 {
16797 arg3 = &temp3;
16798 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16799 }
16800 }
16801 {
16802 if (!wxPyCheckForApp()) SWIG_fail;
16803 PyThreadState* __tstate = wxPyBeginAllowThreads();
16804 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16805
16806 wxPyEndAllowThreads(__tstate);
16807 if (PyErr_Occurred()) SWIG_fail;
16808 }
16809 {
16810 wxIcon * resultptr;
16811 resultptr = new wxIcon((wxIcon &)(result));
16812 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16813 }
16814 {
16815 if (temp1)
16816 delete arg1;
16817 }
16818 {
16819 if (temp2)
16820 delete arg2;
16821 }
16822 return resultobj;
16823 fail:
16824 {
16825 if (temp1)
16826 delete arg1;
16827 }
16828 {
16829 if (temp2)
16830 delete arg2;
16831 }
16832 return NULL;
16833 }
16834
16835
16836 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16837 PyObject *resultobj;
16838 wxString *arg1 = 0 ;
16839 bool arg2 = (bool) false ;
16840 wxSize result;
16841 bool temp1 = false ;
16842 PyObject * obj0 = 0 ;
16843 PyObject * obj1 = 0 ;
16844 char *kwnames[] = {
16845 (char *) "client",(char *) "platform_dependent", NULL
16846 };
16847
16848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16849 {
16850 arg1 = wxString_in_helper(obj0);
16851 if (arg1 == NULL) SWIG_fail;
16852 temp1 = true;
16853 }
16854 if (obj1) {
16855 {
16856 arg2 = (bool)(SWIG_As_bool(obj1));
16857 if (SWIG_arg_fail(2)) SWIG_fail;
16858 }
16859 }
16860 {
16861 PyThreadState* __tstate = wxPyBeginAllowThreads();
16862 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16863
16864 wxPyEndAllowThreads(__tstate);
16865 if (PyErr_Occurred()) SWIG_fail;
16866 }
16867 {
16868 wxSize * resultptr;
16869 resultptr = new wxSize((wxSize &)(result));
16870 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16871 }
16872 {
16873 if (temp1)
16874 delete arg1;
16875 }
16876 return resultobj;
16877 fail:
16878 {
16879 if (temp1)
16880 delete arg1;
16881 }
16882 return NULL;
16883 }
16884
16885
16886 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16887 PyObject *resultobj;
16888 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16889 PyObject * obj0 = 0 ;
16890 char *kwnames[] = {
16891 (char *) "self", NULL
16892 };
16893
16894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16896 if (SWIG_arg_fail(1)) SWIG_fail;
16897 {
16898 PyThreadState* __tstate = wxPyBeginAllowThreads();
16899 wxPyArtProvider_Destroy(arg1);
16900
16901 wxPyEndAllowThreads(__tstate);
16902 if (PyErr_Occurred()) SWIG_fail;
16903 }
16904 Py_INCREF(Py_None); resultobj = Py_None;
16905 return resultobj;
16906 fail:
16907 return NULL;
16908 }
16909
16910
16911 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16912 PyObject *obj;
16913 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16914 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16915 Py_INCREF(obj);
16916 return Py_BuildValue((char *)"");
16917 }
16918 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16919 PyObject *resultobj;
16920 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16921 PyObject * obj0 = 0 ;
16922 char *kwnames[] = {
16923 (char *) "self", NULL
16924 };
16925
16926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16928 if (SWIG_arg_fail(1)) SWIG_fail;
16929 {
16930 PyThreadState* __tstate = wxPyBeginAllowThreads();
16931 delete arg1;
16932
16933 wxPyEndAllowThreads(__tstate);
16934 if (PyErr_Occurred()) SWIG_fail;
16935 }
16936 Py_INCREF(Py_None); resultobj = Py_None;
16937 return resultobj;
16938 fail:
16939 return NULL;
16940 }
16941
16942
16943 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16944 PyObject *resultobj;
16945 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16946 wxConfigBase *result;
16947 PyObject * obj0 = 0 ;
16948 char *kwnames[] = {
16949 (char *) "config", NULL
16950 };
16951
16952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16954 if (SWIG_arg_fail(1)) SWIG_fail;
16955 {
16956 PyThreadState* __tstate = wxPyBeginAllowThreads();
16957 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16958
16959 wxPyEndAllowThreads(__tstate);
16960 if (PyErr_Occurred()) SWIG_fail;
16961 }
16962 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16963 return resultobj;
16964 fail:
16965 return NULL;
16966 }
16967
16968
16969 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16970 PyObject *resultobj;
16971 bool arg1 = (bool) true ;
16972 wxConfigBase *result;
16973 PyObject * obj0 = 0 ;
16974 char *kwnames[] = {
16975 (char *) "createOnDemand", NULL
16976 };
16977
16978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16979 if (obj0) {
16980 {
16981 arg1 = (bool)(SWIG_As_bool(obj0));
16982 if (SWIG_arg_fail(1)) SWIG_fail;
16983 }
16984 }
16985 {
16986 PyThreadState* __tstate = wxPyBeginAllowThreads();
16987 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16988
16989 wxPyEndAllowThreads(__tstate);
16990 if (PyErr_Occurred()) SWIG_fail;
16991 }
16992 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16993 return resultobj;
16994 fail:
16995 return NULL;
16996 }
16997
16998
16999 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17000 PyObject *resultobj;
17001 wxConfigBase *result;
17002 char *kwnames[] = {
17003 NULL
17004 };
17005
17006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
17007 {
17008 PyThreadState* __tstate = wxPyBeginAllowThreads();
17009 result = (wxConfigBase *)wxConfigBase::Create();
17010
17011 wxPyEndAllowThreads(__tstate);
17012 if (PyErr_Occurred()) SWIG_fail;
17013 }
17014 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17015 return resultobj;
17016 fail:
17017 return NULL;
17018 }
17019
17020
17021 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17022 PyObject *resultobj;
17023 char *kwnames[] = {
17024 NULL
17025 };
17026
17027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17028 {
17029 PyThreadState* __tstate = wxPyBeginAllowThreads();
17030 wxConfigBase::DontCreateOnDemand();
17031
17032 wxPyEndAllowThreads(__tstate);
17033 if (PyErr_Occurred()) SWIG_fail;
17034 }
17035 Py_INCREF(Py_None); resultobj = Py_None;
17036 return resultobj;
17037 fail:
17038 return NULL;
17039 }
17040
17041
17042 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17043 PyObject *resultobj;
17044 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17045 wxString *arg2 = 0 ;
17046 bool temp2 = false ;
17047 PyObject * obj0 = 0 ;
17048 PyObject * obj1 = 0 ;
17049 char *kwnames[] = {
17050 (char *) "self",(char *) "path", NULL
17051 };
17052
17053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17055 if (SWIG_arg_fail(1)) SWIG_fail;
17056 {
17057 arg2 = wxString_in_helper(obj1);
17058 if (arg2 == NULL) SWIG_fail;
17059 temp2 = true;
17060 }
17061 {
17062 PyThreadState* __tstate = wxPyBeginAllowThreads();
17063 (arg1)->SetPath((wxString const &)*arg2);
17064
17065 wxPyEndAllowThreads(__tstate);
17066 if (PyErr_Occurred()) SWIG_fail;
17067 }
17068 Py_INCREF(Py_None); resultobj = Py_None;
17069 {
17070 if (temp2)
17071 delete arg2;
17072 }
17073 return resultobj;
17074 fail:
17075 {
17076 if (temp2)
17077 delete arg2;
17078 }
17079 return NULL;
17080 }
17081
17082
17083 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17084 PyObject *resultobj;
17085 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17086 wxString *result;
17087 PyObject * obj0 = 0 ;
17088 char *kwnames[] = {
17089 (char *) "self", NULL
17090 };
17091
17092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17094 if (SWIG_arg_fail(1)) SWIG_fail;
17095 {
17096 PyThreadState* __tstate = wxPyBeginAllowThreads();
17097 {
17098 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17099 result = (wxString *) &_result_ref;
17100 }
17101
17102 wxPyEndAllowThreads(__tstate);
17103 if (PyErr_Occurred()) SWIG_fail;
17104 }
17105 {
17106 #if wxUSE_UNICODE
17107 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17108 #else
17109 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17110 #endif
17111 }
17112 return resultobj;
17113 fail:
17114 return NULL;
17115 }
17116
17117
17118 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17119 PyObject *resultobj;
17120 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17121 PyObject *result;
17122 PyObject * obj0 = 0 ;
17123 char *kwnames[] = {
17124 (char *) "self", NULL
17125 };
17126
17127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17129 if (SWIG_arg_fail(1)) SWIG_fail;
17130 {
17131 PyThreadState* __tstate = wxPyBeginAllowThreads();
17132 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17133
17134 wxPyEndAllowThreads(__tstate);
17135 if (PyErr_Occurred()) SWIG_fail;
17136 }
17137 resultobj = result;
17138 return resultobj;
17139 fail:
17140 return NULL;
17141 }
17142
17143
17144 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17145 PyObject *resultobj;
17146 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17147 long arg2 ;
17148 PyObject *result;
17149 PyObject * obj0 = 0 ;
17150 PyObject * obj1 = 0 ;
17151 char *kwnames[] = {
17152 (char *) "self",(char *) "index", NULL
17153 };
17154
17155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17157 if (SWIG_arg_fail(1)) SWIG_fail;
17158 {
17159 arg2 = (long)(SWIG_As_long(obj1));
17160 if (SWIG_arg_fail(2)) SWIG_fail;
17161 }
17162 {
17163 PyThreadState* __tstate = wxPyBeginAllowThreads();
17164 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17165
17166 wxPyEndAllowThreads(__tstate);
17167 if (PyErr_Occurred()) SWIG_fail;
17168 }
17169 resultobj = result;
17170 return resultobj;
17171 fail:
17172 return NULL;
17173 }
17174
17175
17176 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17177 PyObject *resultobj;
17178 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17179 PyObject *result;
17180 PyObject * obj0 = 0 ;
17181 char *kwnames[] = {
17182 (char *) "self", NULL
17183 };
17184
17185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17187 if (SWIG_arg_fail(1)) SWIG_fail;
17188 {
17189 PyThreadState* __tstate = wxPyBeginAllowThreads();
17190 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17191
17192 wxPyEndAllowThreads(__tstate);
17193 if (PyErr_Occurred()) SWIG_fail;
17194 }
17195 resultobj = result;
17196 return resultobj;
17197 fail:
17198 return NULL;
17199 }
17200
17201
17202 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17203 PyObject *resultobj;
17204 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17205 long arg2 ;
17206 PyObject *result;
17207 PyObject * obj0 = 0 ;
17208 PyObject * obj1 = 0 ;
17209 char *kwnames[] = {
17210 (char *) "self",(char *) "index", NULL
17211 };
17212
17213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17215 if (SWIG_arg_fail(1)) SWIG_fail;
17216 {
17217 arg2 = (long)(SWIG_As_long(obj1));
17218 if (SWIG_arg_fail(2)) SWIG_fail;
17219 }
17220 {
17221 PyThreadState* __tstate = wxPyBeginAllowThreads();
17222 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17223
17224 wxPyEndAllowThreads(__tstate);
17225 if (PyErr_Occurred()) SWIG_fail;
17226 }
17227 resultobj = result;
17228 return resultobj;
17229 fail:
17230 return NULL;
17231 }
17232
17233
17234 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17235 PyObject *resultobj;
17236 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17237 bool arg2 = (bool) false ;
17238 size_t result;
17239 PyObject * obj0 = 0 ;
17240 PyObject * obj1 = 0 ;
17241 char *kwnames[] = {
17242 (char *) "self",(char *) "recursive", NULL
17243 };
17244
17245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17247 if (SWIG_arg_fail(1)) SWIG_fail;
17248 if (obj1) {
17249 {
17250 arg2 = (bool)(SWIG_As_bool(obj1));
17251 if (SWIG_arg_fail(2)) SWIG_fail;
17252 }
17253 }
17254 {
17255 PyThreadState* __tstate = wxPyBeginAllowThreads();
17256 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17257
17258 wxPyEndAllowThreads(__tstate);
17259 if (PyErr_Occurred()) SWIG_fail;
17260 }
17261 {
17262 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17263 }
17264 return resultobj;
17265 fail:
17266 return NULL;
17267 }
17268
17269
17270 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17271 PyObject *resultobj;
17272 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17273 bool arg2 = (bool) false ;
17274 size_t result;
17275 PyObject * obj0 = 0 ;
17276 PyObject * obj1 = 0 ;
17277 char *kwnames[] = {
17278 (char *) "self",(char *) "recursive", NULL
17279 };
17280
17281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17283 if (SWIG_arg_fail(1)) SWIG_fail;
17284 if (obj1) {
17285 {
17286 arg2 = (bool)(SWIG_As_bool(obj1));
17287 if (SWIG_arg_fail(2)) SWIG_fail;
17288 }
17289 }
17290 {
17291 PyThreadState* __tstate = wxPyBeginAllowThreads();
17292 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17293
17294 wxPyEndAllowThreads(__tstate);
17295 if (PyErr_Occurred()) SWIG_fail;
17296 }
17297 {
17298 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17299 }
17300 return resultobj;
17301 fail:
17302 return NULL;
17303 }
17304
17305
17306 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17307 PyObject *resultobj;
17308 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17309 wxString *arg2 = 0 ;
17310 bool result;
17311 bool temp2 = false ;
17312 PyObject * obj0 = 0 ;
17313 PyObject * obj1 = 0 ;
17314 char *kwnames[] = {
17315 (char *) "self",(char *) "name", NULL
17316 };
17317
17318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17320 if (SWIG_arg_fail(1)) SWIG_fail;
17321 {
17322 arg2 = wxString_in_helper(obj1);
17323 if (arg2 == NULL) SWIG_fail;
17324 temp2 = true;
17325 }
17326 {
17327 PyThreadState* __tstate = wxPyBeginAllowThreads();
17328 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17329
17330 wxPyEndAllowThreads(__tstate);
17331 if (PyErr_Occurred()) SWIG_fail;
17332 }
17333 {
17334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17335 }
17336 {
17337 if (temp2)
17338 delete arg2;
17339 }
17340 return resultobj;
17341 fail:
17342 {
17343 if (temp2)
17344 delete arg2;
17345 }
17346 return NULL;
17347 }
17348
17349
17350 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17351 PyObject *resultobj;
17352 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17353 wxString *arg2 = 0 ;
17354 bool result;
17355 bool temp2 = false ;
17356 PyObject * obj0 = 0 ;
17357 PyObject * obj1 = 0 ;
17358 char *kwnames[] = {
17359 (char *) "self",(char *) "name", NULL
17360 };
17361
17362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17364 if (SWIG_arg_fail(1)) SWIG_fail;
17365 {
17366 arg2 = wxString_in_helper(obj1);
17367 if (arg2 == NULL) SWIG_fail;
17368 temp2 = true;
17369 }
17370 {
17371 PyThreadState* __tstate = wxPyBeginAllowThreads();
17372 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17373
17374 wxPyEndAllowThreads(__tstate);
17375 if (PyErr_Occurred()) SWIG_fail;
17376 }
17377 {
17378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17379 }
17380 {
17381 if (temp2)
17382 delete arg2;
17383 }
17384 return resultobj;
17385 fail:
17386 {
17387 if (temp2)
17388 delete arg2;
17389 }
17390 return NULL;
17391 }
17392
17393
17394 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17395 PyObject *resultobj;
17396 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17397 wxString *arg2 = 0 ;
17398 bool result;
17399 bool temp2 = false ;
17400 PyObject * obj0 = 0 ;
17401 PyObject * obj1 = 0 ;
17402 char *kwnames[] = {
17403 (char *) "self",(char *) "name", NULL
17404 };
17405
17406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17408 if (SWIG_arg_fail(1)) SWIG_fail;
17409 {
17410 arg2 = wxString_in_helper(obj1);
17411 if (arg2 == NULL) SWIG_fail;
17412 temp2 = true;
17413 }
17414 {
17415 PyThreadState* __tstate = wxPyBeginAllowThreads();
17416 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17417
17418 wxPyEndAllowThreads(__tstate);
17419 if (PyErr_Occurred()) SWIG_fail;
17420 }
17421 {
17422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17423 }
17424 {
17425 if (temp2)
17426 delete arg2;
17427 }
17428 return resultobj;
17429 fail:
17430 {
17431 if (temp2)
17432 delete arg2;
17433 }
17434 return NULL;
17435 }
17436
17437
17438 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17439 PyObject *resultobj;
17440 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17441 wxString *arg2 = 0 ;
17442 wxConfigBase::EntryType result;
17443 bool temp2 = false ;
17444 PyObject * obj0 = 0 ;
17445 PyObject * obj1 = 0 ;
17446 char *kwnames[] = {
17447 (char *) "self",(char *) "name", NULL
17448 };
17449
17450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17452 if (SWIG_arg_fail(1)) SWIG_fail;
17453 {
17454 arg2 = wxString_in_helper(obj1);
17455 if (arg2 == NULL) SWIG_fail;
17456 temp2 = true;
17457 }
17458 {
17459 PyThreadState* __tstate = wxPyBeginAllowThreads();
17460 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17461
17462 wxPyEndAllowThreads(__tstate);
17463 if (PyErr_Occurred()) SWIG_fail;
17464 }
17465 resultobj = SWIG_From_int((result));
17466 {
17467 if (temp2)
17468 delete arg2;
17469 }
17470 return resultobj;
17471 fail:
17472 {
17473 if (temp2)
17474 delete arg2;
17475 }
17476 return NULL;
17477 }
17478
17479
17480 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17481 PyObject *resultobj;
17482 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17483 wxString *arg2 = 0 ;
17484 wxString const &arg3_defvalue = wxPyEmptyString ;
17485 wxString *arg3 = (wxString *) &arg3_defvalue ;
17486 wxString result;
17487 bool temp2 = false ;
17488 bool temp3 = false ;
17489 PyObject * obj0 = 0 ;
17490 PyObject * obj1 = 0 ;
17491 PyObject * obj2 = 0 ;
17492 char *kwnames[] = {
17493 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17494 };
17495
17496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17498 if (SWIG_arg_fail(1)) SWIG_fail;
17499 {
17500 arg2 = wxString_in_helper(obj1);
17501 if (arg2 == NULL) SWIG_fail;
17502 temp2 = true;
17503 }
17504 if (obj2) {
17505 {
17506 arg3 = wxString_in_helper(obj2);
17507 if (arg3 == NULL) SWIG_fail;
17508 temp3 = true;
17509 }
17510 }
17511 {
17512 PyThreadState* __tstate = wxPyBeginAllowThreads();
17513 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17514
17515 wxPyEndAllowThreads(__tstate);
17516 if (PyErr_Occurred()) SWIG_fail;
17517 }
17518 {
17519 #if wxUSE_UNICODE
17520 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17521 #else
17522 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17523 #endif
17524 }
17525 {
17526 if (temp2)
17527 delete arg2;
17528 }
17529 {
17530 if (temp3)
17531 delete arg3;
17532 }
17533 return resultobj;
17534 fail:
17535 {
17536 if (temp2)
17537 delete arg2;
17538 }
17539 {
17540 if (temp3)
17541 delete arg3;
17542 }
17543 return NULL;
17544 }
17545
17546
17547 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17548 PyObject *resultobj;
17549 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17550 wxString *arg2 = 0 ;
17551 long arg3 = (long) 0 ;
17552 long result;
17553 bool temp2 = false ;
17554 PyObject * obj0 = 0 ;
17555 PyObject * obj1 = 0 ;
17556 PyObject * obj2 = 0 ;
17557 char *kwnames[] = {
17558 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17559 };
17560
17561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17563 if (SWIG_arg_fail(1)) SWIG_fail;
17564 {
17565 arg2 = wxString_in_helper(obj1);
17566 if (arg2 == NULL) SWIG_fail;
17567 temp2 = true;
17568 }
17569 if (obj2) {
17570 {
17571 arg3 = (long)(SWIG_As_long(obj2));
17572 if (SWIG_arg_fail(3)) SWIG_fail;
17573 }
17574 }
17575 {
17576 PyThreadState* __tstate = wxPyBeginAllowThreads();
17577 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17578
17579 wxPyEndAllowThreads(__tstate);
17580 if (PyErr_Occurred()) SWIG_fail;
17581 }
17582 {
17583 resultobj = SWIG_From_long((long)(result));
17584 }
17585 {
17586 if (temp2)
17587 delete arg2;
17588 }
17589 return resultobj;
17590 fail:
17591 {
17592 if (temp2)
17593 delete arg2;
17594 }
17595 return NULL;
17596 }
17597
17598
17599 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17600 PyObject *resultobj;
17601 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17602 wxString *arg2 = 0 ;
17603 double arg3 = (double) 0.0 ;
17604 double result;
17605 bool temp2 = false ;
17606 PyObject * obj0 = 0 ;
17607 PyObject * obj1 = 0 ;
17608 PyObject * obj2 = 0 ;
17609 char *kwnames[] = {
17610 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17611 };
17612
17613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17615 if (SWIG_arg_fail(1)) SWIG_fail;
17616 {
17617 arg2 = wxString_in_helper(obj1);
17618 if (arg2 == NULL) SWIG_fail;
17619 temp2 = true;
17620 }
17621 if (obj2) {
17622 {
17623 arg3 = (double)(SWIG_As_double(obj2));
17624 if (SWIG_arg_fail(3)) SWIG_fail;
17625 }
17626 }
17627 {
17628 PyThreadState* __tstate = wxPyBeginAllowThreads();
17629 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17630
17631 wxPyEndAllowThreads(__tstate);
17632 if (PyErr_Occurred()) SWIG_fail;
17633 }
17634 {
17635 resultobj = SWIG_From_double((double)(result));
17636 }
17637 {
17638 if (temp2)
17639 delete arg2;
17640 }
17641 return resultobj;
17642 fail:
17643 {
17644 if (temp2)
17645 delete arg2;
17646 }
17647 return NULL;
17648 }
17649
17650
17651 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17652 PyObject *resultobj;
17653 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17654 wxString *arg2 = 0 ;
17655 bool arg3 = (bool) false ;
17656 bool result;
17657 bool temp2 = false ;
17658 PyObject * obj0 = 0 ;
17659 PyObject * obj1 = 0 ;
17660 PyObject * obj2 = 0 ;
17661 char *kwnames[] = {
17662 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17663 };
17664
17665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17667 if (SWIG_arg_fail(1)) SWIG_fail;
17668 {
17669 arg2 = wxString_in_helper(obj1);
17670 if (arg2 == NULL) SWIG_fail;
17671 temp2 = true;
17672 }
17673 if (obj2) {
17674 {
17675 arg3 = (bool)(SWIG_As_bool(obj2));
17676 if (SWIG_arg_fail(3)) SWIG_fail;
17677 }
17678 }
17679 {
17680 PyThreadState* __tstate = wxPyBeginAllowThreads();
17681 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17682
17683 wxPyEndAllowThreads(__tstate);
17684 if (PyErr_Occurred()) SWIG_fail;
17685 }
17686 {
17687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17688 }
17689 {
17690 if (temp2)
17691 delete arg2;
17692 }
17693 return resultobj;
17694 fail:
17695 {
17696 if (temp2)
17697 delete arg2;
17698 }
17699 return NULL;
17700 }
17701
17702
17703 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17704 PyObject *resultobj;
17705 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17706 wxString *arg2 = 0 ;
17707 wxString *arg3 = 0 ;
17708 bool result;
17709 bool temp2 = false ;
17710 bool temp3 = false ;
17711 PyObject * obj0 = 0 ;
17712 PyObject * obj1 = 0 ;
17713 PyObject * obj2 = 0 ;
17714 char *kwnames[] = {
17715 (char *) "self",(char *) "key",(char *) "value", NULL
17716 };
17717
17718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17720 if (SWIG_arg_fail(1)) SWIG_fail;
17721 {
17722 arg2 = wxString_in_helper(obj1);
17723 if (arg2 == NULL) SWIG_fail;
17724 temp2 = true;
17725 }
17726 {
17727 arg3 = wxString_in_helper(obj2);
17728 if (arg3 == NULL) SWIG_fail;
17729 temp3 = true;
17730 }
17731 {
17732 PyThreadState* __tstate = wxPyBeginAllowThreads();
17733 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17734
17735 wxPyEndAllowThreads(__tstate);
17736 if (PyErr_Occurred()) SWIG_fail;
17737 }
17738 {
17739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17740 }
17741 {
17742 if (temp2)
17743 delete arg2;
17744 }
17745 {
17746 if (temp3)
17747 delete arg3;
17748 }
17749 return resultobj;
17750 fail:
17751 {
17752 if (temp2)
17753 delete arg2;
17754 }
17755 {
17756 if (temp3)
17757 delete arg3;
17758 }
17759 return NULL;
17760 }
17761
17762
17763 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17764 PyObject *resultobj;
17765 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17766 wxString *arg2 = 0 ;
17767 long arg3 ;
17768 bool result;
17769 bool temp2 = false ;
17770 PyObject * obj0 = 0 ;
17771 PyObject * obj1 = 0 ;
17772 PyObject * obj2 = 0 ;
17773 char *kwnames[] = {
17774 (char *) "self",(char *) "key",(char *) "value", NULL
17775 };
17776
17777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17779 if (SWIG_arg_fail(1)) SWIG_fail;
17780 {
17781 arg2 = wxString_in_helper(obj1);
17782 if (arg2 == NULL) SWIG_fail;
17783 temp2 = true;
17784 }
17785 {
17786 arg3 = (long)(SWIG_As_long(obj2));
17787 if (SWIG_arg_fail(3)) SWIG_fail;
17788 }
17789 {
17790 PyThreadState* __tstate = wxPyBeginAllowThreads();
17791 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17792
17793 wxPyEndAllowThreads(__tstate);
17794 if (PyErr_Occurred()) SWIG_fail;
17795 }
17796 {
17797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17798 }
17799 {
17800 if (temp2)
17801 delete arg2;
17802 }
17803 return resultobj;
17804 fail:
17805 {
17806 if (temp2)
17807 delete arg2;
17808 }
17809 return NULL;
17810 }
17811
17812
17813 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17814 PyObject *resultobj;
17815 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17816 wxString *arg2 = 0 ;
17817 double arg3 ;
17818 bool result;
17819 bool temp2 = false ;
17820 PyObject * obj0 = 0 ;
17821 PyObject * obj1 = 0 ;
17822 PyObject * obj2 = 0 ;
17823 char *kwnames[] = {
17824 (char *) "self",(char *) "key",(char *) "value", NULL
17825 };
17826
17827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17829 if (SWIG_arg_fail(1)) SWIG_fail;
17830 {
17831 arg2 = wxString_in_helper(obj1);
17832 if (arg2 == NULL) SWIG_fail;
17833 temp2 = true;
17834 }
17835 {
17836 arg3 = (double)(SWIG_As_double(obj2));
17837 if (SWIG_arg_fail(3)) SWIG_fail;
17838 }
17839 {
17840 PyThreadState* __tstate = wxPyBeginAllowThreads();
17841 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17842
17843 wxPyEndAllowThreads(__tstate);
17844 if (PyErr_Occurred()) SWIG_fail;
17845 }
17846 {
17847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17848 }
17849 {
17850 if (temp2)
17851 delete arg2;
17852 }
17853 return resultobj;
17854 fail:
17855 {
17856 if (temp2)
17857 delete arg2;
17858 }
17859 return NULL;
17860 }
17861
17862
17863 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17864 PyObject *resultobj;
17865 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17866 wxString *arg2 = 0 ;
17867 bool arg3 ;
17868 bool result;
17869 bool temp2 = false ;
17870 PyObject * obj0 = 0 ;
17871 PyObject * obj1 = 0 ;
17872 PyObject * obj2 = 0 ;
17873 char *kwnames[] = {
17874 (char *) "self",(char *) "key",(char *) "value", NULL
17875 };
17876
17877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17879 if (SWIG_arg_fail(1)) SWIG_fail;
17880 {
17881 arg2 = wxString_in_helper(obj1);
17882 if (arg2 == NULL) SWIG_fail;
17883 temp2 = true;
17884 }
17885 {
17886 arg3 = (bool)(SWIG_As_bool(obj2));
17887 if (SWIG_arg_fail(3)) SWIG_fail;
17888 }
17889 {
17890 PyThreadState* __tstate = wxPyBeginAllowThreads();
17891 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17892
17893 wxPyEndAllowThreads(__tstate);
17894 if (PyErr_Occurred()) SWIG_fail;
17895 }
17896 {
17897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17898 }
17899 {
17900 if (temp2)
17901 delete arg2;
17902 }
17903 return resultobj;
17904 fail:
17905 {
17906 if (temp2)
17907 delete arg2;
17908 }
17909 return NULL;
17910 }
17911
17912
17913 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17914 PyObject *resultobj;
17915 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17916 bool arg2 = (bool) false ;
17917 bool result;
17918 PyObject * obj0 = 0 ;
17919 PyObject * obj1 = 0 ;
17920 char *kwnames[] = {
17921 (char *) "self",(char *) "currentOnly", NULL
17922 };
17923
17924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17926 if (SWIG_arg_fail(1)) SWIG_fail;
17927 if (obj1) {
17928 {
17929 arg2 = (bool)(SWIG_As_bool(obj1));
17930 if (SWIG_arg_fail(2)) SWIG_fail;
17931 }
17932 }
17933 {
17934 PyThreadState* __tstate = wxPyBeginAllowThreads();
17935 result = (bool)(arg1)->Flush(arg2);
17936
17937 wxPyEndAllowThreads(__tstate);
17938 if (PyErr_Occurred()) SWIG_fail;
17939 }
17940 {
17941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17942 }
17943 return resultobj;
17944 fail:
17945 return NULL;
17946 }
17947
17948
17949 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17950 PyObject *resultobj;
17951 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17952 wxString *arg2 = 0 ;
17953 wxString *arg3 = 0 ;
17954 bool result;
17955 bool temp2 = false ;
17956 bool temp3 = false ;
17957 PyObject * obj0 = 0 ;
17958 PyObject * obj1 = 0 ;
17959 PyObject * obj2 = 0 ;
17960 char *kwnames[] = {
17961 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17962 };
17963
17964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17966 if (SWIG_arg_fail(1)) SWIG_fail;
17967 {
17968 arg2 = wxString_in_helper(obj1);
17969 if (arg2 == NULL) SWIG_fail;
17970 temp2 = true;
17971 }
17972 {
17973 arg3 = wxString_in_helper(obj2);
17974 if (arg3 == NULL) SWIG_fail;
17975 temp3 = true;
17976 }
17977 {
17978 PyThreadState* __tstate = wxPyBeginAllowThreads();
17979 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17980
17981 wxPyEndAllowThreads(__tstate);
17982 if (PyErr_Occurred()) SWIG_fail;
17983 }
17984 {
17985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17986 }
17987 {
17988 if (temp2)
17989 delete arg2;
17990 }
17991 {
17992 if (temp3)
17993 delete arg3;
17994 }
17995 return resultobj;
17996 fail:
17997 {
17998 if (temp2)
17999 delete arg2;
18000 }
18001 {
18002 if (temp3)
18003 delete arg3;
18004 }
18005 return NULL;
18006 }
18007
18008
18009 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18010 PyObject *resultobj;
18011 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18012 wxString *arg2 = 0 ;
18013 wxString *arg3 = 0 ;
18014 bool result;
18015 bool temp2 = false ;
18016 bool temp3 = false ;
18017 PyObject * obj0 = 0 ;
18018 PyObject * obj1 = 0 ;
18019 PyObject * obj2 = 0 ;
18020 char *kwnames[] = {
18021 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18022 };
18023
18024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
18025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18026 if (SWIG_arg_fail(1)) SWIG_fail;
18027 {
18028 arg2 = wxString_in_helper(obj1);
18029 if (arg2 == NULL) SWIG_fail;
18030 temp2 = true;
18031 }
18032 {
18033 arg3 = wxString_in_helper(obj2);
18034 if (arg3 == NULL) SWIG_fail;
18035 temp3 = true;
18036 }
18037 {
18038 PyThreadState* __tstate = wxPyBeginAllowThreads();
18039 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18040
18041 wxPyEndAllowThreads(__tstate);
18042 if (PyErr_Occurred()) SWIG_fail;
18043 }
18044 {
18045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18046 }
18047 {
18048 if (temp2)
18049 delete arg2;
18050 }
18051 {
18052 if (temp3)
18053 delete arg3;
18054 }
18055 return resultobj;
18056 fail:
18057 {
18058 if (temp2)
18059 delete arg2;
18060 }
18061 {
18062 if (temp3)
18063 delete arg3;
18064 }
18065 return NULL;
18066 }
18067
18068
18069 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18070 PyObject *resultobj;
18071 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18072 wxString *arg2 = 0 ;
18073 bool arg3 = (bool) true ;
18074 bool result;
18075 bool temp2 = false ;
18076 PyObject * obj0 = 0 ;
18077 PyObject * obj1 = 0 ;
18078 PyObject * obj2 = 0 ;
18079 char *kwnames[] = {
18080 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18081 };
18082
18083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18085 if (SWIG_arg_fail(1)) SWIG_fail;
18086 {
18087 arg2 = wxString_in_helper(obj1);
18088 if (arg2 == NULL) SWIG_fail;
18089 temp2 = true;
18090 }
18091 if (obj2) {
18092 {
18093 arg3 = (bool)(SWIG_As_bool(obj2));
18094 if (SWIG_arg_fail(3)) SWIG_fail;
18095 }
18096 }
18097 {
18098 PyThreadState* __tstate = wxPyBeginAllowThreads();
18099 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18100
18101 wxPyEndAllowThreads(__tstate);
18102 if (PyErr_Occurred()) SWIG_fail;
18103 }
18104 {
18105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18106 }
18107 {
18108 if (temp2)
18109 delete arg2;
18110 }
18111 return resultobj;
18112 fail:
18113 {
18114 if (temp2)
18115 delete arg2;
18116 }
18117 return NULL;
18118 }
18119
18120
18121 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18122 PyObject *resultobj;
18123 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18124 wxString *arg2 = 0 ;
18125 bool result;
18126 bool temp2 = false ;
18127 PyObject * obj0 = 0 ;
18128 PyObject * obj1 = 0 ;
18129 char *kwnames[] = {
18130 (char *) "self",(char *) "key", NULL
18131 };
18132
18133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18135 if (SWIG_arg_fail(1)) SWIG_fail;
18136 {
18137 arg2 = wxString_in_helper(obj1);
18138 if (arg2 == NULL) SWIG_fail;
18139 temp2 = true;
18140 }
18141 {
18142 PyThreadState* __tstate = wxPyBeginAllowThreads();
18143 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18144
18145 wxPyEndAllowThreads(__tstate);
18146 if (PyErr_Occurred()) SWIG_fail;
18147 }
18148 {
18149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18150 }
18151 {
18152 if (temp2)
18153 delete arg2;
18154 }
18155 return resultobj;
18156 fail:
18157 {
18158 if (temp2)
18159 delete arg2;
18160 }
18161 return NULL;
18162 }
18163
18164
18165 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18166 PyObject *resultobj;
18167 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18168 bool result;
18169 PyObject * obj0 = 0 ;
18170 char *kwnames[] = {
18171 (char *) "self", NULL
18172 };
18173
18174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18176 if (SWIG_arg_fail(1)) SWIG_fail;
18177 {
18178 PyThreadState* __tstate = wxPyBeginAllowThreads();
18179 result = (bool)(arg1)->DeleteAll();
18180
18181 wxPyEndAllowThreads(__tstate);
18182 if (PyErr_Occurred()) SWIG_fail;
18183 }
18184 {
18185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18186 }
18187 return resultobj;
18188 fail:
18189 return NULL;
18190 }
18191
18192
18193 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18194 PyObject *resultobj;
18195 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18196 bool arg2 = (bool) true ;
18197 PyObject * obj0 = 0 ;
18198 PyObject * obj1 = 0 ;
18199 char *kwnames[] = {
18200 (char *) "self",(char *) "doIt", NULL
18201 };
18202
18203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18205 if (SWIG_arg_fail(1)) SWIG_fail;
18206 if (obj1) {
18207 {
18208 arg2 = (bool)(SWIG_As_bool(obj1));
18209 if (SWIG_arg_fail(2)) SWIG_fail;
18210 }
18211 }
18212 {
18213 PyThreadState* __tstate = wxPyBeginAllowThreads();
18214 (arg1)->SetExpandEnvVars(arg2);
18215
18216 wxPyEndAllowThreads(__tstate);
18217 if (PyErr_Occurred()) SWIG_fail;
18218 }
18219 Py_INCREF(Py_None); resultobj = Py_None;
18220 return resultobj;
18221 fail:
18222 return NULL;
18223 }
18224
18225
18226 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18227 PyObject *resultobj;
18228 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18229 bool result;
18230 PyObject * obj0 = 0 ;
18231 char *kwnames[] = {
18232 (char *) "self", NULL
18233 };
18234
18235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18237 if (SWIG_arg_fail(1)) SWIG_fail;
18238 {
18239 PyThreadState* __tstate = wxPyBeginAllowThreads();
18240 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18241
18242 wxPyEndAllowThreads(__tstate);
18243 if (PyErr_Occurred()) SWIG_fail;
18244 }
18245 {
18246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18247 }
18248 return resultobj;
18249 fail:
18250 return NULL;
18251 }
18252
18253
18254 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18255 PyObject *resultobj;
18256 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18257 bool arg2 = (bool) true ;
18258 PyObject * obj0 = 0 ;
18259 PyObject * obj1 = 0 ;
18260 char *kwnames[] = {
18261 (char *) "self",(char *) "doIt", NULL
18262 };
18263
18264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18266 if (SWIG_arg_fail(1)) SWIG_fail;
18267 if (obj1) {
18268 {
18269 arg2 = (bool)(SWIG_As_bool(obj1));
18270 if (SWIG_arg_fail(2)) SWIG_fail;
18271 }
18272 }
18273 {
18274 PyThreadState* __tstate = wxPyBeginAllowThreads();
18275 (arg1)->SetRecordDefaults(arg2);
18276
18277 wxPyEndAllowThreads(__tstate);
18278 if (PyErr_Occurred()) SWIG_fail;
18279 }
18280 Py_INCREF(Py_None); resultobj = Py_None;
18281 return resultobj;
18282 fail:
18283 return NULL;
18284 }
18285
18286
18287 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18288 PyObject *resultobj;
18289 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18290 bool result;
18291 PyObject * obj0 = 0 ;
18292 char *kwnames[] = {
18293 (char *) "self", NULL
18294 };
18295
18296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18298 if (SWIG_arg_fail(1)) SWIG_fail;
18299 {
18300 PyThreadState* __tstate = wxPyBeginAllowThreads();
18301 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18302
18303 wxPyEndAllowThreads(__tstate);
18304 if (PyErr_Occurred()) SWIG_fail;
18305 }
18306 {
18307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18308 }
18309 return resultobj;
18310 fail:
18311 return NULL;
18312 }
18313
18314
18315 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18316 PyObject *resultobj;
18317 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18318 wxString *arg2 = 0 ;
18319 wxString result;
18320 bool temp2 = false ;
18321 PyObject * obj0 = 0 ;
18322 PyObject * obj1 = 0 ;
18323 char *kwnames[] = {
18324 (char *) "self",(char *) "str", NULL
18325 };
18326
18327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18329 if (SWIG_arg_fail(1)) SWIG_fail;
18330 {
18331 arg2 = wxString_in_helper(obj1);
18332 if (arg2 == NULL) SWIG_fail;
18333 temp2 = true;
18334 }
18335 {
18336 PyThreadState* __tstate = wxPyBeginAllowThreads();
18337 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18338
18339 wxPyEndAllowThreads(__tstate);
18340 if (PyErr_Occurred()) SWIG_fail;
18341 }
18342 {
18343 #if wxUSE_UNICODE
18344 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18345 #else
18346 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18347 #endif
18348 }
18349 {
18350 if (temp2)
18351 delete arg2;
18352 }
18353 return resultobj;
18354 fail:
18355 {
18356 if (temp2)
18357 delete arg2;
18358 }
18359 return NULL;
18360 }
18361
18362
18363 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18364 PyObject *resultobj;
18365 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18366 wxString result;
18367 PyObject * obj0 = 0 ;
18368 char *kwnames[] = {
18369 (char *) "self", NULL
18370 };
18371
18372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18374 if (SWIG_arg_fail(1)) SWIG_fail;
18375 {
18376 PyThreadState* __tstate = wxPyBeginAllowThreads();
18377 result = ((wxConfigBase const *)arg1)->GetAppName();
18378
18379 wxPyEndAllowThreads(__tstate);
18380 if (PyErr_Occurred()) SWIG_fail;
18381 }
18382 {
18383 #if wxUSE_UNICODE
18384 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18385 #else
18386 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18387 #endif
18388 }
18389 return resultobj;
18390 fail:
18391 return NULL;
18392 }
18393
18394
18395 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18396 PyObject *resultobj;
18397 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18398 wxString result;
18399 PyObject * obj0 = 0 ;
18400 char *kwnames[] = {
18401 (char *) "self", NULL
18402 };
18403
18404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18406 if (SWIG_arg_fail(1)) SWIG_fail;
18407 {
18408 PyThreadState* __tstate = wxPyBeginAllowThreads();
18409 result = ((wxConfigBase const *)arg1)->GetVendorName();
18410
18411 wxPyEndAllowThreads(__tstate);
18412 if (PyErr_Occurred()) SWIG_fail;
18413 }
18414 {
18415 #if wxUSE_UNICODE
18416 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18417 #else
18418 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18419 #endif
18420 }
18421 return resultobj;
18422 fail:
18423 return NULL;
18424 }
18425
18426
18427 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18428 PyObject *resultobj;
18429 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18430 wxString *arg2 = 0 ;
18431 bool temp2 = false ;
18432 PyObject * obj0 = 0 ;
18433 PyObject * obj1 = 0 ;
18434 char *kwnames[] = {
18435 (char *) "self",(char *) "appName", NULL
18436 };
18437
18438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18440 if (SWIG_arg_fail(1)) SWIG_fail;
18441 {
18442 arg2 = wxString_in_helper(obj1);
18443 if (arg2 == NULL) SWIG_fail;
18444 temp2 = true;
18445 }
18446 {
18447 PyThreadState* __tstate = wxPyBeginAllowThreads();
18448 (arg1)->SetAppName((wxString const &)*arg2);
18449
18450 wxPyEndAllowThreads(__tstate);
18451 if (PyErr_Occurred()) SWIG_fail;
18452 }
18453 Py_INCREF(Py_None); resultobj = Py_None;
18454 {
18455 if (temp2)
18456 delete arg2;
18457 }
18458 return resultobj;
18459 fail:
18460 {
18461 if (temp2)
18462 delete arg2;
18463 }
18464 return NULL;
18465 }
18466
18467
18468 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18469 PyObject *resultobj;
18470 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18471 wxString *arg2 = 0 ;
18472 bool temp2 = false ;
18473 PyObject * obj0 = 0 ;
18474 PyObject * obj1 = 0 ;
18475 char *kwnames[] = {
18476 (char *) "self",(char *) "vendorName", NULL
18477 };
18478
18479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18481 if (SWIG_arg_fail(1)) SWIG_fail;
18482 {
18483 arg2 = wxString_in_helper(obj1);
18484 if (arg2 == NULL) SWIG_fail;
18485 temp2 = true;
18486 }
18487 {
18488 PyThreadState* __tstate = wxPyBeginAllowThreads();
18489 (arg1)->SetVendorName((wxString const &)*arg2);
18490
18491 wxPyEndAllowThreads(__tstate);
18492 if (PyErr_Occurred()) SWIG_fail;
18493 }
18494 Py_INCREF(Py_None); resultobj = Py_None;
18495 {
18496 if (temp2)
18497 delete arg2;
18498 }
18499 return resultobj;
18500 fail:
18501 {
18502 if (temp2)
18503 delete arg2;
18504 }
18505 return NULL;
18506 }
18507
18508
18509 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18510 PyObject *resultobj;
18511 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18512 long arg2 ;
18513 PyObject * obj0 = 0 ;
18514 PyObject * obj1 = 0 ;
18515 char *kwnames[] = {
18516 (char *) "self",(char *) "style", NULL
18517 };
18518
18519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18521 if (SWIG_arg_fail(1)) SWIG_fail;
18522 {
18523 arg2 = (long)(SWIG_As_long(obj1));
18524 if (SWIG_arg_fail(2)) SWIG_fail;
18525 }
18526 {
18527 PyThreadState* __tstate = wxPyBeginAllowThreads();
18528 (arg1)->SetStyle(arg2);
18529
18530 wxPyEndAllowThreads(__tstate);
18531 if (PyErr_Occurred()) SWIG_fail;
18532 }
18533 Py_INCREF(Py_None); resultobj = Py_None;
18534 return resultobj;
18535 fail:
18536 return NULL;
18537 }
18538
18539
18540 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18541 PyObject *resultobj;
18542 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18543 long result;
18544 PyObject * obj0 = 0 ;
18545 char *kwnames[] = {
18546 (char *) "self", NULL
18547 };
18548
18549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18551 if (SWIG_arg_fail(1)) SWIG_fail;
18552 {
18553 PyThreadState* __tstate = wxPyBeginAllowThreads();
18554 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18555
18556 wxPyEndAllowThreads(__tstate);
18557 if (PyErr_Occurred()) SWIG_fail;
18558 }
18559 {
18560 resultobj = SWIG_From_long((long)(result));
18561 }
18562 return resultobj;
18563 fail:
18564 return NULL;
18565 }
18566
18567
18568 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18569 PyObject *obj;
18570 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18571 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18572 Py_INCREF(obj);
18573 return Py_BuildValue((char *)"");
18574 }
18575 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18576 PyObject *resultobj;
18577 wxString const &arg1_defvalue = wxPyEmptyString ;
18578 wxString *arg1 = (wxString *) &arg1_defvalue ;
18579 wxString const &arg2_defvalue = wxPyEmptyString ;
18580 wxString *arg2 = (wxString *) &arg2_defvalue ;
18581 wxString const &arg3_defvalue = wxPyEmptyString ;
18582 wxString *arg3 = (wxString *) &arg3_defvalue ;
18583 wxString const &arg4_defvalue = wxPyEmptyString ;
18584 wxString *arg4 = (wxString *) &arg4_defvalue ;
18585 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18586 wxConfig *result;
18587 bool temp1 = false ;
18588 bool temp2 = false ;
18589 bool temp3 = false ;
18590 bool temp4 = false ;
18591 PyObject * obj0 = 0 ;
18592 PyObject * obj1 = 0 ;
18593 PyObject * obj2 = 0 ;
18594 PyObject * obj3 = 0 ;
18595 PyObject * obj4 = 0 ;
18596 char *kwnames[] = {
18597 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18598 };
18599
18600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18601 if (obj0) {
18602 {
18603 arg1 = wxString_in_helper(obj0);
18604 if (arg1 == NULL) SWIG_fail;
18605 temp1 = true;
18606 }
18607 }
18608 if (obj1) {
18609 {
18610 arg2 = wxString_in_helper(obj1);
18611 if (arg2 == NULL) SWIG_fail;
18612 temp2 = true;
18613 }
18614 }
18615 if (obj2) {
18616 {
18617 arg3 = wxString_in_helper(obj2);
18618 if (arg3 == NULL) SWIG_fail;
18619 temp3 = true;
18620 }
18621 }
18622 if (obj3) {
18623 {
18624 arg4 = wxString_in_helper(obj3);
18625 if (arg4 == NULL) SWIG_fail;
18626 temp4 = true;
18627 }
18628 }
18629 if (obj4) {
18630 {
18631 arg5 = (long)(SWIG_As_long(obj4));
18632 if (SWIG_arg_fail(5)) SWIG_fail;
18633 }
18634 }
18635 {
18636 PyThreadState* __tstate = wxPyBeginAllowThreads();
18637 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18638
18639 wxPyEndAllowThreads(__tstate);
18640 if (PyErr_Occurred()) SWIG_fail;
18641 }
18642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18643 {
18644 if (temp1)
18645 delete arg1;
18646 }
18647 {
18648 if (temp2)
18649 delete arg2;
18650 }
18651 {
18652 if (temp3)
18653 delete arg3;
18654 }
18655 {
18656 if (temp4)
18657 delete arg4;
18658 }
18659 return resultobj;
18660 fail:
18661 {
18662 if (temp1)
18663 delete arg1;
18664 }
18665 {
18666 if (temp2)
18667 delete arg2;
18668 }
18669 {
18670 if (temp3)
18671 delete arg3;
18672 }
18673 {
18674 if (temp4)
18675 delete arg4;
18676 }
18677 return NULL;
18678 }
18679
18680
18681 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18682 PyObject *resultobj;
18683 wxConfig *arg1 = (wxConfig *) 0 ;
18684 PyObject * obj0 = 0 ;
18685 char *kwnames[] = {
18686 (char *) "self", NULL
18687 };
18688
18689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18691 if (SWIG_arg_fail(1)) SWIG_fail;
18692 {
18693 PyThreadState* __tstate = wxPyBeginAllowThreads();
18694 delete arg1;
18695
18696 wxPyEndAllowThreads(__tstate);
18697 if (PyErr_Occurred()) SWIG_fail;
18698 }
18699 Py_INCREF(Py_None); resultobj = Py_None;
18700 return resultobj;
18701 fail:
18702 return NULL;
18703 }
18704
18705
18706 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18707 PyObject *obj;
18708 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18709 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18710 Py_INCREF(obj);
18711 return Py_BuildValue((char *)"");
18712 }
18713 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18714 PyObject *resultobj;
18715 wxString const &arg1_defvalue = wxPyEmptyString ;
18716 wxString *arg1 = (wxString *) &arg1_defvalue ;
18717 wxString const &arg2_defvalue = wxPyEmptyString ;
18718 wxString *arg2 = (wxString *) &arg2_defvalue ;
18719 wxString const &arg3_defvalue = wxPyEmptyString ;
18720 wxString *arg3 = (wxString *) &arg3_defvalue ;
18721 wxString const &arg4_defvalue = wxPyEmptyString ;
18722 wxString *arg4 = (wxString *) &arg4_defvalue ;
18723 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18724 wxFileConfig *result;
18725 bool temp1 = false ;
18726 bool temp2 = false ;
18727 bool temp3 = false ;
18728 bool temp4 = false ;
18729 PyObject * obj0 = 0 ;
18730 PyObject * obj1 = 0 ;
18731 PyObject * obj2 = 0 ;
18732 PyObject * obj3 = 0 ;
18733 PyObject * obj4 = 0 ;
18734 char *kwnames[] = {
18735 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18736 };
18737
18738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18739 if (obj0) {
18740 {
18741 arg1 = wxString_in_helper(obj0);
18742 if (arg1 == NULL) SWIG_fail;
18743 temp1 = true;
18744 }
18745 }
18746 if (obj1) {
18747 {
18748 arg2 = wxString_in_helper(obj1);
18749 if (arg2 == NULL) SWIG_fail;
18750 temp2 = true;
18751 }
18752 }
18753 if (obj2) {
18754 {
18755 arg3 = wxString_in_helper(obj2);
18756 if (arg3 == NULL) SWIG_fail;
18757 temp3 = true;
18758 }
18759 }
18760 if (obj3) {
18761 {
18762 arg4 = wxString_in_helper(obj3);
18763 if (arg4 == NULL) SWIG_fail;
18764 temp4 = true;
18765 }
18766 }
18767 if (obj4) {
18768 {
18769 arg5 = (long)(SWIG_As_long(obj4));
18770 if (SWIG_arg_fail(5)) SWIG_fail;
18771 }
18772 }
18773 {
18774 PyThreadState* __tstate = wxPyBeginAllowThreads();
18775 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18776
18777 wxPyEndAllowThreads(__tstate);
18778 if (PyErr_Occurred()) SWIG_fail;
18779 }
18780 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18781 {
18782 if (temp1)
18783 delete arg1;
18784 }
18785 {
18786 if (temp2)
18787 delete arg2;
18788 }
18789 {
18790 if (temp3)
18791 delete arg3;
18792 }
18793 {
18794 if (temp4)
18795 delete arg4;
18796 }
18797 return resultobj;
18798 fail:
18799 {
18800 if (temp1)
18801 delete arg1;
18802 }
18803 {
18804 if (temp2)
18805 delete arg2;
18806 }
18807 {
18808 if (temp3)
18809 delete arg3;
18810 }
18811 {
18812 if (temp4)
18813 delete arg4;
18814 }
18815 return NULL;
18816 }
18817
18818
18819 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18820 PyObject *resultobj;
18821 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18822 PyObject * obj0 = 0 ;
18823 char *kwnames[] = {
18824 (char *) "self", NULL
18825 };
18826
18827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18829 if (SWIG_arg_fail(1)) SWIG_fail;
18830 {
18831 PyThreadState* __tstate = wxPyBeginAllowThreads();
18832 delete arg1;
18833
18834 wxPyEndAllowThreads(__tstate);
18835 if (PyErr_Occurred()) SWIG_fail;
18836 }
18837 Py_INCREF(Py_None); resultobj = Py_None;
18838 return resultobj;
18839 fail:
18840 return NULL;
18841 }
18842
18843
18844 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18845 PyObject *obj;
18846 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18847 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18848 Py_INCREF(obj);
18849 return Py_BuildValue((char *)"");
18850 }
18851 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18852 PyObject *resultobj;
18853 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18854 wxString *arg2 = 0 ;
18855 wxConfigPathChanger *result;
18856 bool temp2 = false ;
18857 PyObject * obj0 = 0 ;
18858 PyObject * obj1 = 0 ;
18859 char *kwnames[] = {
18860 (char *) "config",(char *) "entry", NULL
18861 };
18862
18863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18865 if (SWIG_arg_fail(1)) SWIG_fail;
18866 {
18867 arg2 = wxString_in_helper(obj1);
18868 if (arg2 == NULL) SWIG_fail;
18869 temp2 = true;
18870 }
18871 {
18872 PyThreadState* __tstate = wxPyBeginAllowThreads();
18873 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18874
18875 wxPyEndAllowThreads(__tstate);
18876 if (PyErr_Occurred()) SWIG_fail;
18877 }
18878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18879 {
18880 if (temp2)
18881 delete arg2;
18882 }
18883 return resultobj;
18884 fail:
18885 {
18886 if (temp2)
18887 delete arg2;
18888 }
18889 return NULL;
18890 }
18891
18892
18893 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18894 PyObject *resultobj;
18895 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18896 PyObject * obj0 = 0 ;
18897 char *kwnames[] = {
18898 (char *) "self", NULL
18899 };
18900
18901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18903 if (SWIG_arg_fail(1)) SWIG_fail;
18904 {
18905 PyThreadState* __tstate = wxPyBeginAllowThreads();
18906 delete arg1;
18907
18908 wxPyEndAllowThreads(__tstate);
18909 if (PyErr_Occurred()) SWIG_fail;
18910 }
18911 Py_INCREF(Py_None); resultobj = Py_None;
18912 return resultobj;
18913 fail:
18914 return NULL;
18915 }
18916
18917
18918 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18919 PyObject *resultobj;
18920 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18921 wxString *result;
18922 PyObject * obj0 = 0 ;
18923 char *kwnames[] = {
18924 (char *) "self", NULL
18925 };
18926
18927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18929 if (SWIG_arg_fail(1)) SWIG_fail;
18930 {
18931 PyThreadState* __tstate = wxPyBeginAllowThreads();
18932 {
18933 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18934 result = (wxString *) &_result_ref;
18935 }
18936
18937 wxPyEndAllowThreads(__tstate);
18938 if (PyErr_Occurred()) SWIG_fail;
18939 }
18940 {
18941 #if wxUSE_UNICODE
18942 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18943 #else
18944 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18945 #endif
18946 }
18947 return resultobj;
18948 fail:
18949 return NULL;
18950 }
18951
18952
18953 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18954 PyObject *obj;
18955 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18956 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18957 Py_INCREF(obj);
18958 return Py_BuildValue((char *)"");
18959 }
18960 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18961 PyObject *resultobj;
18962 wxString *arg1 = 0 ;
18963 wxString result;
18964 bool temp1 = false ;
18965 PyObject * obj0 = 0 ;
18966 char *kwnames[] = {
18967 (char *) "sz", NULL
18968 };
18969
18970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18971 {
18972 arg1 = wxString_in_helper(obj0);
18973 if (arg1 == NULL) SWIG_fail;
18974 temp1 = true;
18975 }
18976 {
18977 PyThreadState* __tstate = wxPyBeginAllowThreads();
18978 result = wxExpandEnvVars((wxString const &)*arg1);
18979
18980 wxPyEndAllowThreads(__tstate);
18981 if (PyErr_Occurred()) SWIG_fail;
18982 }
18983 {
18984 #if wxUSE_UNICODE
18985 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18986 #else
18987 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18988 #endif
18989 }
18990 {
18991 if (temp1)
18992 delete arg1;
18993 }
18994 return resultobj;
18995 fail:
18996 {
18997 if (temp1)
18998 delete arg1;
18999 }
19000 return NULL;
19001 }
19002
19003
19004 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
19005 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
19006 return 1;
19007 }
19008
19009
19010 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
19011 PyObject *pyobj;
19012
19013 {
19014 #if wxUSE_UNICODE
19015 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19016 #else
19017 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19018 #endif
19019 }
19020 return pyobj;
19021 }
19022
19023
19024 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19025 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19026 return 1;
19027 }
19028
19029
19030 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19031 PyObject *pyobj;
19032
19033 {
19034 #if wxUSE_UNICODE
19035 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19036 #else
19037 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19038 #endif
19039 }
19040 return pyobj;
19041 }
19042
19043
19044 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19045 PyObject *resultobj;
19046 wxDateTime::Country arg1 ;
19047 PyObject * obj0 = 0 ;
19048 char *kwnames[] = {
19049 (char *) "country", NULL
19050 };
19051
19052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19053 {
19054 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19055 if (SWIG_arg_fail(1)) SWIG_fail;
19056 }
19057 {
19058 PyThreadState* __tstate = wxPyBeginAllowThreads();
19059 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19060
19061 wxPyEndAllowThreads(__tstate);
19062 if (PyErr_Occurred()) SWIG_fail;
19063 }
19064 Py_INCREF(Py_None); resultobj = Py_None;
19065 return resultobj;
19066 fail:
19067 return NULL;
19068 }
19069
19070
19071 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19072 PyObject *resultobj;
19073 wxDateTime::Country result;
19074 char *kwnames[] = {
19075 NULL
19076 };
19077
19078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19079 {
19080 PyThreadState* __tstate = wxPyBeginAllowThreads();
19081 result = (wxDateTime::Country)wxDateTime::GetCountry();
19082
19083 wxPyEndAllowThreads(__tstate);
19084 if (PyErr_Occurred()) SWIG_fail;
19085 }
19086 resultobj = SWIG_From_int((result));
19087 return resultobj;
19088 fail:
19089 return NULL;
19090 }
19091
19092
19093 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19094 PyObject *resultobj;
19095 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19096 bool result;
19097 PyObject * obj0 = 0 ;
19098 char *kwnames[] = {
19099 (char *) "country", NULL
19100 };
19101
19102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19103 if (obj0) {
19104 {
19105 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19106 if (SWIG_arg_fail(1)) SWIG_fail;
19107 }
19108 }
19109 {
19110 PyThreadState* __tstate = wxPyBeginAllowThreads();
19111 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19112
19113 wxPyEndAllowThreads(__tstate);
19114 if (PyErr_Occurred()) SWIG_fail;
19115 }
19116 {
19117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19118 }
19119 return resultobj;
19120 fail:
19121 return NULL;
19122 }
19123
19124
19125 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19126 PyObject *resultobj;
19127 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19128 int result;
19129 PyObject * obj0 = 0 ;
19130 char *kwnames[] = {
19131 (char *) "cal", NULL
19132 };
19133
19134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19135 if (obj0) {
19136 {
19137 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19138 if (SWIG_arg_fail(1)) SWIG_fail;
19139 }
19140 }
19141 {
19142 PyThreadState* __tstate = wxPyBeginAllowThreads();
19143 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19144
19145 wxPyEndAllowThreads(__tstate);
19146 if (PyErr_Occurred()) SWIG_fail;
19147 }
19148 {
19149 resultobj = SWIG_From_int((int)(result));
19150 }
19151 return resultobj;
19152 fail:
19153 return NULL;
19154 }
19155
19156
19157 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19158 PyObject *resultobj;
19159 int arg1 ;
19160 int result;
19161 PyObject * obj0 = 0 ;
19162 char *kwnames[] = {
19163 (char *) "year", NULL
19164 };
19165
19166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19167 {
19168 arg1 = (int)(SWIG_As_int(obj0));
19169 if (SWIG_arg_fail(1)) SWIG_fail;
19170 }
19171 {
19172 PyThreadState* __tstate = wxPyBeginAllowThreads();
19173 result = (int)wxDateTime::ConvertYearToBC(arg1);
19174
19175 wxPyEndAllowThreads(__tstate);
19176 if (PyErr_Occurred()) SWIG_fail;
19177 }
19178 {
19179 resultobj = SWIG_From_int((int)(result));
19180 }
19181 return resultobj;
19182 fail:
19183 return NULL;
19184 }
19185
19186
19187 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19188 PyObject *resultobj;
19189 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19190 wxDateTime::Month result;
19191 PyObject * obj0 = 0 ;
19192 char *kwnames[] = {
19193 (char *) "cal", NULL
19194 };
19195
19196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19197 if (obj0) {
19198 {
19199 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19200 if (SWIG_arg_fail(1)) SWIG_fail;
19201 }
19202 }
19203 {
19204 PyThreadState* __tstate = wxPyBeginAllowThreads();
19205 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19206
19207 wxPyEndAllowThreads(__tstate);
19208 if (PyErr_Occurred()) SWIG_fail;
19209 }
19210 resultobj = SWIG_From_int((result));
19211 return resultobj;
19212 fail:
19213 return NULL;
19214 }
19215
19216
19217 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19218 PyObject *resultobj;
19219 int arg1 = (int) wxDateTime::Inv_Year ;
19220 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19221 bool result;
19222 PyObject * obj0 = 0 ;
19223 PyObject * obj1 = 0 ;
19224 char *kwnames[] = {
19225 (char *) "year",(char *) "cal", NULL
19226 };
19227
19228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19229 if (obj0) {
19230 {
19231 arg1 = (int)(SWIG_As_int(obj0));
19232 if (SWIG_arg_fail(1)) SWIG_fail;
19233 }
19234 }
19235 if (obj1) {
19236 {
19237 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19238 if (SWIG_arg_fail(2)) SWIG_fail;
19239 }
19240 }
19241 {
19242 PyThreadState* __tstate = wxPyBeginAllowThreads();
19243 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19244
19245 wxPyEndAllowThreads(__tstate);
19246 if (PyErr_Occurred()) SWIG_fail;
19247 }
19248 {
19249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19250 }
19251 return resultobj;
19252 fail:
19253 return NULL;
19254 }
19255
19256
19257 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19258 PyObject *resultobj;
19259 int arg1 = (int) wxDateTime::Inv_Year ;
19260 int result;
19261 PyObject * obj0 = 0 ;
19262 char *kwnames[] = {
19263 (char *) "year", NULL
19264 };
19265
19266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19267 if (obj0) {
19268 {
19269 arg1 = (int)(SWIG_As_int(obj0));
19270 if (SWIG_arg_fail(1)) SWIG_fail;
19271 }
19272 }
19273 {
19274 PyThreadState* __tstate = wxPyBeginAllowThreads();
19275 result = (int)wxDateTime::GetCentury(arg1);
19276
19277 wxPyEndAllowThreads(__tstate);
19278 if (PyErr_Occurred()) SWIG_fail;
19279 }
19280 {
19281 resultobj = SWIG_From_int((int)(result));
19282 }
19283 return resultobj;
19284 fail:
19285 return NULL;
19286 }
19287
19288
19289 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19290 PyObject *resultobj;
19291 int arg1 ;
19292 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19293 int result;
19294 PyObject * obj0 = 0 ;
19295 PyObject * obj1 = 0 ;
19296 char *kwnames[] = {
19297 (char *) "year",(char *) "cal", NULL
19298 };
19299
19300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19301 {
19302 arg1 = (int)(SWIG_As_int(obj0));
19303 if (SWIG_arg_fail(1)) SWIG_fail;
19304 }
19305 if (obj1) {
19306 {
19307 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19308 if (SWIG_arg_fail(2)) SWIG_fail;
19309 }
19310 }
19311 {
19312 PyThreadState* __tstate = wxPyBeginAllowThreads();
19313 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19314
19315 wxPyEndAllowThreads(__tstate);
19316 if (PyErr_Occurred()) SWIG_fail;
19317 }
19318 {
19319 resultobj = SWIG_From_int((int)(result));
19320 }
19321 return resultobj;
19322 fail:
19323 return NULL;
19324 }
19325
19326
19327 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19328 PyObject *resultobj;
19329 wxDateTime::Month arg1 ;
19330 int arg2 = (int) wxDateTime::Inv_Year ;
19331 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19332 int result;
19333 PyObject * obj0 = 0 ;
19334 PyObject * obj1 = 0 ;
19335 PyObject * obj2 = 0 ;
19336 char *kwnames[] = {
19337 (char *) "month",(char *) "year",(char *) "cal", NULL
19338 };
19339
19340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19341 {
19342 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19343 if (SWIG_arg_fail(1)) SWIG_fail;
19344 }
19345 if (obj1) {
19346 {
19347 arg2 = (int)(SWIG_As_int(obj1));
19348 if (SWIG_arg_fail(2)) SWIG_fail;
19349 }
19350 }
19351 if (obj2) {
19352 {
19353 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19354 if (SWIG_arg_fail(3)) SWIG_fail;
19355 }
19356 }
19357 {
19358 PyThreadState* __tstate = wxPyBeginAllowThreads();
19359 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19360
19361 wxPyEndAllowThreads(__tstate);
19362 if (PyErr_Occurred()) SWIG_fail;
19363 }
19364 {
19365 resultobj = SWIG_From_int((int)(result));
19366 }
19367 return resultobj;
19368 fail:
19369 return NULL;
19370 }
19371
19372
19373 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19374 PyObject *resultobj;
19375 wxDateTime::Month arg1 ;
19376 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19377 wxString result;
19378 PyObject * obj0 = 0 ;
19379 PyObject * obj1 = 0 ;
19380 char *kwnames[] = {
19381 (char *) "month",(char *) "flags", NULL
19382 };
19383
19384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19385 {
19386 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19387 if (SWIG_arg_fail(1)) SWIG_fail;
19388 }
19389 if (obj1) {
19390 {
19391 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19392 if (SWIG_arg_fail(2)) SWIG_fail;
19393 }
19394 }
19395 {
19396 PyThreadState* __tstate = wxPyBeginAllowThreads();
19397 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19398
19399 wxPyEndAllowThreads(__tstate);
19400 if (PyErr_Occurred()) SWIG_fail;
19401 }
19402 {
19403 #if wxUSE_UNICODE
19404 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19405 #else
19406 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19407 #endif
19408 }
19409 return resultobj;
19410 fail:
19411 return NULL;
19412 }
19413
19414
19415 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19416 PyObject *resultobj;
19417 wxDateTime::WeekDay arg1 ;
19418 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19419 wxString result;
19420 PyObject * obj0 = 0 ;
19421 PyObject * obj1 = 0 ;
19422 char *kwnames[] = {
19423 (char *) "weekday",(char *) "flags", NULL
19424 };
19425
19426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19427 {
19428 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19429 if (SWIG_arg_fail(1)) SWIG_fail;
19430 }
19431 if (obj1) {
19432 {
19433 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19434 if (SWIG_arg_fail(2)) SWIG_fail;
19435 }
19436 }
19437 {
19438 PyThreadState* __tstate = wxPyBeginAllowThreads();
19439 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19440
19441 wxPyEndAllowThreads(__tstate);
19442 if (PyErr_Occurred()) SWIG_fail;
19443 }
19444 {
19445 #if wxUSE_UNICODE
19446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19447 #else
19448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19449 #endif
19450 }
19451 return resultobj;
19452 fail:
19453 return NULL;
19454 }
19455
19456
19457 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19458 PyObject *resultobj;
19459 PyObject *result;
19460 char *kwnames[] = {
19461 NULL
19462 };
19463
19464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19465 {
19466 PyThreadState* __tstate = wxPyBeginAllowThreads();
19467 result = (PyObject *)DateTime_GetAmPmStrings();
19468
19469 wxPyEndAllowThreads(__tstate);
19470 if (PyErr_Occurred()) SWIG_fail;
19471 }
19472 resultobj = result;
19473 return resultobj;
19474 fail:
19475 return NULL;
19476 }
19477
19478
19479 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19480 PyObject *resultobj;
19481 int arg1 = (int) wxDateTime::Inv_Year ;
19482 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19483 bool result;
19484 PyObject * obj0 = 0 ;
19485 PyObject * obj1 = 0 ;
19486 char *kwnames[] = {
19487 (char *) "year",(char *) "country", NULL
19488 };
19489
19490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19491 if (obj0) {
19492 {
19493 arg1 = (int)(SWIG_As_int(obj0));
19494 if (SWIG_arg_fail(1)) SWIG_fail;
19495 }
19496 }
19497 if (obj1) {
19498 {
19499 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19500 if (SWIG_arg_fail(2)) SWIG_fail;
19501 }
19502 }
19503 {
19504 PyThreadState* __tstate = wxPyBeginAllowThreads();
19505 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19506
19507 wxPyEndAllowThreads(__tstate);
19508 if (PyErr_Occurred()) SWIG_fail;
19509 }
19510 {
19511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19512 }
19513 return resultobj;
19514 fail:
19515 return NULL;
19516 }
19517
19518
19519 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19520 PyObject *resultobj;
19521 int arg1 = (int) wxDateTime::Inv_Year ;
19522 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19523 wxDateTime result;
19524 PyObject * obj0 = 0 ;
19525 PyObject * obj1 = 0 ;
19526 char *kwnames[] = {
19527 (char *) "year",(char *) "country", NULL
19528 };
19529
19530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19531 if (obj0) {
19532 {
19533 arg1 = (int)(SWIG_As_int(obj0));
19534 if (SWIG_arg_fail(1)) SWIG_fail;
19535 }
19536 }
19537 if (obj1) {
19538 {
19539 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19540 if (SWIG_arg_fail(2)) SWIG_fail;
19541 }
19542 }
19543 {
19544 PyThreadState* __tstate = wxPyBeginAllowThreads();
19545 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19546
19547 wxPyEndAllowThreads(__tstate);
19548 if (PyErr_Occurred()) SWIG_fail;
19549 }
19550 {
19551 wxDateTime * resultptr;
19552 resultptr = new wxDateTime((wxDateTime &)(result));
19553 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19554 }
19555 return resultobj;
19556 fail:
19557 return NULL;
19558 }
19559
19560
19561 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19562 PyObject *resultobj;
19563 int arg1 = (int) wxDateTime::Inv_Year ;
19564 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19565 wxDateTime result;
19566 PyObject * obj0 = 0 ;
19567 PyObject * obj1 = 0 ;
19568 char *kwnames[] = {
19569 (char *) "year",(char *) "country", NULL
19570 };
19571
19572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19573 if (obj0) {
19574 {
19575 arg1 = (int)(SWIG_As_int(obj0));
19576 if (SWIG_arg_fail(1)) SWIG_fail;
19577 }
19578 }
19579 if (obj1) {
19580 {
19581 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19582 if (SWIG_arg_fail(2)) SWIG_fail;
19583 }
19584 }
19585 {
19586 PyThreadState* __tstate = wxPyBeginAllowThreads();
19587 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19588
19589 wxPyEndAllowThreads(__tstate);
19590 if (PyErr_Occurred()) SWIG_fail;
19591 }
19592 {
19593 wxDateTime * resultptr;
19594 resultptr = new wxDateTime((wxDateTime &)(result));
19595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19596 }
19597 return resultobj;
19598 fail:
19599 return NULL;
19600 }
19601
19602
19603 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19604 PyObject *resultobj;
19605 wxDateTime result;
19606 char *kwnames[] = {
19607 NULL
19608 };
19609
19610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19611 {
19612 PyThreadState* __tstate = wxPyBeginAllowThreads();
19613 result = wxDateTime::Now();
19614
19615 wxPyEndAllowThreads(__tstate);
19616 if (PyErr_Occurred()) SWIG_fail;
19617 }
19618 {
19619 wxDateTime * resultptr;
19620 resultptr = new wxDateTime((wxDateTime &)(result));
19621 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19622 }
19623 return resultobj;
19624 fail:
19625 return NULL;
19626 }
19627
19628
19629 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19630 PyObject *resultobj;
19631 wxDateTime result;
19632 char *kwnames[] = {
19633 NULL
19634 };
19635
19636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19637 {
19638 PyThreadState* __tstate = wxPyBeginAllowThreads();
19639 result = wxDateTime::UNow();
19640
19641 wxPyEndAllowThreads(__tstate);
19642 if (PyErr_Occurred()) SWIG_fail;
19643 }
19644 {
19645 wxDateTime * resultptr;
19646 resultptr = new wxDateTime((wxDateTime &)(result));
19647 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19648 }
19649 return resultobj;
19650 fail:
19651 return NULL;
19652 }
19653
19654
19655 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19656 PyObject *resultobj;
19657 wxDateTime result;
19658 char *kwnames[] = {
19659 NULL
19660 };
19661
19662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19663 {
19664 PyThreadState* __tstate = wxPyBeginAllowThreads();
19665 result = wxDateTime::Today();
19666
19667 wxPyEndAllowThreads(__tstate);
19668 if (PyErr_Occurred()) SWIG_fail;
19669 }
19670 {
19671 wxDateTime * resultptr;
19672 resultptr = new wxDateTime((wxDateTime &)(result));
19673 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19674 }
19675 return resultobj;
19676 fail:
19677 return NULL;
19678 }
19679
19680
19681 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19682 PyObject *resultobj;
19683 wxDateTime *result;
19684 char *kwnames[] = {
19685 NULL
19686 };
19687
19688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19689 {
19690 PyThreadState* __tstate = wxPyBeginAllowThreads();
19691 result = (wxDateTime *)new wxDateTime();
19692
19693 wxPyEndAllowThreads(__tstate);
19694 if (PyErr_Occurred()) SWIG_fail;
19695 }
19696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19697 return resultobj;
19698 fail:
19699 return NULL;
19700 }
19701
19702
19703 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19704 PyObject *resultobj;
19705 time_t arg1 ;
19706 wxDateTime *result;
19707 PyObject * obj0 = 0 ;
19708 char *kwnames[] = {
19709 (char *) "timet", NULL
19710 };
19711
19712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19713 {
19714 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19715 if (SWIG_arg_fail(1)) SWIG_fail;
19716 }
19717 {
19718 PyThreadState* __tstate = wxPyBeginAllowThreads();
19719 result = (wxDateTime *)new wxDateTime(arg1);
19720
19721 wxPyEndAllowThreads(__tstate);
19722 if (PyErr_Occurred()) SWIG_fail;
19723 }
19724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19725 return resultobj;
19726 fail:
19727 return NULL;
19728 }
19729
19730
19731 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19732 PyObject *resultobj;
19733 double arg1 ;
19734 wxDateTime *result;
19735 PyObject * obj0 = 0 ;
19736 char *kwnames[] = {
19737 (char *) "jdn", NULL
19738 };
19739
19740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19741 {
19742 arg1 = (double)(SWIG_As_double(obj0));
19743 if (SWIG_arg_fail(1)) SWIG_fail;
19744 }
19745 {
19746 PyThreadState* __tstate = wxPyBeginAllowThreads();
19747 result = (wxDateTime *)new wxDateTime(arg1);
19748
19749 wxPyEndAllowThreads(__tstate);
19750 if (PyErr_Occurred()) SWIG_fail;
19751 }
19752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19753 return resultobj;
19754 fail:
19755 return NULL;
19756 }
19757
19758
19759 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19760 PyObject *resultobj;
19761 int arg1 ;
19762 int arg2 = (int) 0 ;
19763 int arg3 = (int) 0 ;
19764 int arg4 = (int) 0 ;
19765 wxDateTime *result;
19766 PyObject * obj0 = 0 ;
19767 PyObject * obj1 = 0 ;
19768 PyObject * obj2 = 0 ;
19769 PyObject * obj3 = 0 ;
19770 char *kwnames[] = {
19771 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19772 };
19773
19774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19775 {
19776 arg1 = (int)(SWIG_As_int(obj0));
19777 if (SWIG_arg_fail(1)) SWIG_fail;
19778 }
19779 if (obj1) {
19780 {
19781 arg2 = (int)(SWIG_As_int(obj1));
19782 if (SWIG_arg_fail(2)) SWIG_fail;
19783 }
19784 }
19785 if (obj2) {
19786 {
19787 arg3 = (int)(SWIG_As_int(obj2));
19788 if (SWIG_arg_fail(3)) SWIG_fail;
19789 }
19790 }
19791 if (obj3) {
19792 {
19793 arg4 = (int)(SWIG_As_int(obj3));
19794 if (SWIG_arg_fail(4)) SWIG_fail;
19795 }
19796 }
19797 {
19798 PyThreadState* __tstate = wxPyBeginAllowThreads();
19799 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19800
19801 wxPyEndAllowThreads(__tstate);
19802 if (PyErr_Occurred()) SWIG_fail;
19803 }
19804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19805 return resultobj;
19806 fail:
19807 return NULL;
19808 }
19809
19810
19811 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19812 PyObject *resultobj;
19813 int arg1 ;
19814 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19815 int arg3 = (int) wxDateTime::Inv_Year ;
19816 int arg4 = (int) 0 ;
19817 int arg5 = (int) 0 ;
19818 int arg6 = (int) 0 ;
19819 int arg7 = (int) 0 ;
19820 wxDateTime *result;
19821 PyObject * obj0 = 0 ;
19822 PyObject * obj1 = 0 ;
19823 PyObject * obj2 = 0 ;
19824 PyObject * obj3 = 0 ;
19825 PyObject * obj4 = 0 ;
19826 PyObject * obj5 = 0 ;
19827 PyObject * obj6 = 0 ;
19828 char *kwnames[] = {
19829 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19830 };
19831
19832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19833 {
19834 arg1 = (int)(SWIG_As_int(obj0));
19835 if (SWIG_arg_fail(1)) SWIG_fail;
19836 }
19837 if (obj1) {
19838 {
19839 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19840 if (SWIG_arg_fail(2)) SWIG_fail;
19841 }
19842 }
19843 if (obj2) {
19844 {
19845 arg3 = (int)(SWIG_As_int(obj2));
19846 if (SWIG_arg_fail(3)) SWIG_fail;
19847 }
19848 }
19849 if (obj3) {
19850 {
19851 arg4 = (int)(SWIG_As_int(obj3));
19852 if (SWIG_arg_fail(4)) SWIG_fail;
19853 }
19854 }
19855 if (obj4) {
19856 {
19857 arg5 = (int)(SWIG_As_int(obj4));
19858 if (SWIG_arg_fail(5)) SWIG_fail;
19859 }
19860 }
19861 if (obj5) {
19862 {
19863 arg6 = (int)(SWIG_As_int(obj5));
19864 if (SWIG_arg_fail(6)) SWIG_fail;
19865 }
19866 }
19867 if (obj6) {
19868 {
19869 arg7 = (int)(SWIG_As_int(obj6));
19870 if (SWIG_arg_fail(7)) SWIG_fail;
19871 }
19872 }
19873 {
19874 PyThreadState* __tstate = wxPyBeginAllowThreads();
19875 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19876
19877 wxPyEndAllowThreads(__tstate);
19878 if (PyErr_Occurred()) SWIG_fail;
19879 }
19880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19881 return resultobj;
19882 fail:
19883 return NULL;
19884 }
19885
19886
19887 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19888 PyObject *resultobj;
19889 wxDateTime *arg1 = (wxDateTime *) 0 ;
19890 PyObject * obj0 = 0 ;
19891 char *kwnames[] = {
19892 (char *) "self", NULL
19893 };
19894
19895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19897 if (SWIG_arg_fail(1)) SWIG_fail;
19898 {
19899 PyThreadState* __tstate = wxPyBeginAllowThreads();
19900 delete arg1;
19901
19902 wxPyEndAllowThreads(__tstate);
19903 if (PyErr_Occurred()) SWIG_fail;
19904 }
19905 Py_INCREF(Py_None); resultobj = Py_None;
19906 return resultobj;
19907 fail:
19908 return NULL;
19909 }
19910
19911
19912 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19913 PyObject *resultobj;
19914 wxDateTime *arg1 = (wxDateTime *) 0 ;
19915 wxDateTime *result;
19916 PyObject * obj0 = 0 ;
19917 char *kwnames[] = {
19918 (char *) "self", NULL
19919 };
19920
19921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19923 if (SWIG_arg_fail(1)) SWIG_fail;
19924 {
19925 PyThreadState* __tstate = wxPyBeginAllowThreads();
19926 {
19927 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19928 result = (wxDateTime *) &_result_ref;
19929 }
19930
19931 wxPyEndAllowThreads(__tstate);
19932 if (PyErr_Occurred()) SWIG_fail;
19933 }
19934 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19935 return resultobj;
19936 fail:
19937 return NULL;
19938 }
19939
19940
19941 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19942 PyObject *resultobj;
19943 wxDateTime *arg1 = (wxDateTime *) 0 ;
19944 time_t arg2 ;
19945 wxDateTime *result;
19946 PyObject * obj0 = 0 ;
19947 PyObject * obj1 = 0 ;
19948 char *kwnames[] = {
19949 (char *) "self",(char *) "timet", NULL
19950 };
19951
19952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19954 if (SWIG_arg_fail(1)) SWIG_fail;
19955 {
19956 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19957 if (SWIG_arg_fail(2)) SWIG_fail;
19958 }
19959 {
19960 PyThreadState* __tstate = wxPyBeginAllowThreads();
19961 {
19962 wxDateTime &_result_ref = (arg1)->Set(arg2);
19963 result = (wxDateTime *) &_result_ref;
19964 }
19965
19966 wxPyEndAllowThreads(__tstate);
19967 if (PyErr_Occurred()) SWIG_fail;
19968 }
19969 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19970 return resultobj;
19971 fail:
19972 return NULL;
19973 }
19974
19975
19976 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19977 PyObject *resultobj;
19978 wxDateTime *arg1 = (wxDateTime *) 0 ;
19979 double arg2 ;
19980 wxDateTime *result;
19981 PyObject * obj0 = 0 ;
19982 PyObject * obj1 = 0 ;
19983 char *kwnames[] = {
19984 (char *) "self",(char *) "jdn", NULL
19985 };
19986
19987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19989 if (SWIG_arg_fail(1)) SWIG_fail;
19990 {
19991 arg2 = (double)(SWIG_As_double(obj1));
19992 if (SWIG_arg_fail(2)) SWIG_fail;
19993 }
19994 {
19995 PyThreadState* __tstate = wxPyBeginAllowThreads();
19996 {
19997 wxDateTime &_result_ref = (arg1)->Set(arg2);
19998 result = (wxDateTime *) &_result_ref;
19999 }
20000
20001 wxPyEndAllowThreads(__tstate);
20002 if (PyErr_Occurred()) SWIG_fail;
20003 }
20004 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20005 return resultobj;
20006 fail:
20007 return NULL;
20008 }
20009
20010
20011 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20012 PyObject *resultobj;
20013 wxDateTime *arg1 = (wxDateTime *) 0 ;
20014 int arg2 ;
20015 int arg3 = (int) 0 ;
20016 int arg4 = (int) 0 ;
20017 int arg5 = (int) 0 ;
20018 wxDateTime *result;
20019 PyObject * obj0 = 0 ;
20020 PyObject * obj1 = 0 ;
20021 PyObject * obj2 = 0 ;
20022 PyObject * obj3 = 0 ;
20023 PyObject * obj4 = 0 ;
20024 char *kwnames[] = {
20025 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20026 };
20027
20028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20030 if (SWIG_arg_fail(1)) SWIG_fail;
20031 {
20032 arg2 = (int)(SWIG_As_int(obj1));
20033 if (SWIG_arg_fail(2)) SWIG_fail;
20034 }
20035 if (obj2) {
20036 {
20037 arg3 = (int)(SWIG_As_int(obj2));
20038 if (SWIG_arg_fail(3)) SWIG_fail;
20039 }
20040 }
20041 if (obj3) {
20042 {
20043 arg4 = (int)(SWIG_As_int(obj3));
20044 if (SWIG_arg_fail(4)) SWIG_fail;
20045 }
20046 }
20047 if (obj4) {
20048 {
20049 arg5 = (int)(SWIG_As_int(obj4));
20050 if (SWIG_arg_fail(5)) SWIG_fail;
20051 }
20052 }
20053 {
20054 PyThreadState* __tstate = wxPyBeginAllowThreads();
20055 {
20056 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20057 result = (wxDateTime *) &_result_ref;
20058 }
20059
20060 wxPyEndAllowThreads(__tstate);
20061 if (PyErr_Occurred()) SWIG_fail;
20062 }
20063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20064 return resultobj;
20065 fail:
20066 return NULL;
20067 }
20068
20069
20070 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20071 PyObject *resultobj;
20072 wxDateTime *arg1 = (wxDateTime *) 0 ;
20073 int arg2 ;
20074 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20075 int arg4 = (int) wxDateTime::Inv_Year ;
20076 int arg5 = (int) 0 ;
20077 int arg6 = (int) 0 ;
20078 int arg7 = (int) 0 ;
20079 int arg8 = (int) 0 ;
20080 wxDateTime *result;
20081 PyObject * obj0 = 0 ;
20082 PyObject * obj1 = 0 ;
20083 PyObject * obj2 = 0 ;
20084 PyObject * obj3 = 0 ;
20085 PyObject * obj4 = 0 ;
20086 PyObject * obj5 = 0 ;
20087 PyObject * obj6 = 0 ;
20088 PyObject * obj7 = 0 ;
20089 char *kwnames[] = {
20090 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20091 };
20092
20093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) 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 = (int)(SWIG_As_int(obj1));
20098 if (SWIG_arg_fail(2)) SWIG_fail;
20099 }
20100 if (obj2) {
20101 {
20102 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20103 if (SWIG_arg_fail(3)) SWIG_fail;
20104 }
20105 }
20106 if (obj3) {
20107 {
20108 arg4 = (int)(SWIG_As_int(obj3));
20109 if (SWIG_arg_fail(4)) SWIG_fail;
20110 }
20111 }
20112 if (obj4) {
20113 {
20114 arg5 = (int)(SWIG_As_int(obj4));
20115 if (SWIG_arg_fail(5)) SWIG_fail;
20116 }
20117 }
20118 if (obj5) {
20119 {
20120 arg6 = (int)(SWIG_As_int(obj5));
20121 if (SWIG_arg_fail(6)) SWIG_fail;
20122 }
20123 }
20124 if (obj6) {
20125 {
20126 arg7 = (int)(SWIG_As_int(obj6));
20127 if (SWIG_arg_fail(7)) SWIG_fail;
20128 }
20129 }
20130 if (obj7) {
20131 {
20132 arg8 = (int)(SWIG_As_int(obj7));
20133 if (SWIG_arg_fail(8)) SWIG_fail;
20134 }
20135 }
20136 {
20137 PyThreadState* __tstate = wxPyBeginAllowThreads();
20138 {
20139 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20140 result = (wxDateTime *) &_result_ref;
20141 }
20142
20143 wxPyEndAllowThreads(__tstate);
20144 if (PyErr_Occurred()) SWIG_fail;
20145 }
20146 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20147 return resultobj;
20148 fail:
20149 return NULL;
20150 }
20151
20152
20153 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20154 PyObject *resultobj;
20155 wxDateTime *arg1 = (wxDateTime *) 0 ;
20156 wxDateTime *result;
20157 PyObject * obj0 = 0 ;
20158 char *kwnames[] = {
20159 (char *) "self", NULL
20160 };
20161
20162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20164 if (SWIG_arg_fail(1)) SWIG_fail;
20165 {
20166 PyThreadState* __tstate = wxPyBeginAllowThreads();
20167 {
20168 wxDateTime &_result_ref = (arg1)->ResetTime();
20169 result = (wxDateTime *) &_result_ref;
20170 }
20171
20172 wxPyEndAllowThreads(__tstate);
20173 if (PyErr_Occurred()) SWIG_fail;
20174 }
20175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20176 return resultobj;
20177 fail:
20178 return NULL;
20179 }
20180
20181
20182 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20183 PyObject *resultobj;
20184 wxDateTime *arg1 = (wxDateTime *) 0 ;
20185 int arg2 ;
20186 wxDateTime *result;
20187 PyObject * obj0 = 0 ;
20188 PyObject * obj1 = 0 ;
20189 char *kwnames[] = {
20190 (char *) "self",(char *) "year", NULL
20191 };
20192
20193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20195 if (SWIG_arg_fail(1)) SWIG_fail;
20196 {
20197 arg2 = (int)(SWIG_As_int(obj1));
20198 if (SWIG_arg_fail(2)) SWIG_fail;
20199 }
20200 {
20201 PyThreadState* __tstate = wxPyBeginAllowThreads();
20202 {
20203 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20204 result = (wxDateTime *) &_result_ref;
20205 }
20206
20207 wxPyEndAllowThreads(__tstate);
20208 if (PyErr_Occurred()) SWIG_fail;
20209 }
20210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20211 return resultobj;
20212 fail:
20213 return NULL;
20214 }
20215
20216
20217 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20218 PyObject *resultobj;
20219 wxDateTime *arg1 = (wxDateTime *) 0 ;
20220 wxDateTime::Month arg2 ;
20221 wxDateTime *result;
20222 PyObject * obj0 = 0 ;
20223 PyObject * obj1 = 0 ;
20224 char *kwnames[] = {
20225 (char *) "self",(char *) "month", NULL
20226 };
20227
20228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20230 if (SWIG_arg_fail(1)) SWIG_fail;
20231 {
20232 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20233 if (SWIG_arg_fail(2)) SWIG_fail;
20234 }
20235 {
20236 PyThreadState* __tstate = wxPyBeginAllowThreads();
20237 {
20238 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20239 result = (wxDateTime *) &_result_ref;
20240 }
20241
20242 wxPyEndAllowThreads(__tstate);
20243 if (PyErr_Occurred()) SWIG_fail;
20244 }
20245 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20246 return resultobj;
20247 fail:
20248 return NULL;
20249 }
20250
20251
20252 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20253 PyObject *resultobj;
20254 wxDateTime *arg1 = (wxDateTime *) 0 ;
20255 int arg2 ;
20256 wxDateTime *result;
20257 PyObject * obj0 = 0 ;
20258 PyObject * obj1 = 0 ;
20259 char *kwnames[] = {
20260 (char *) "self",(char *) "day", NULL
20261 };
20262
20263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20265 if (SWIG_arg_fail(1)) SWIG_fail;
20266 {
20267 arg2 = (int)(SWIG_As_int(obj1));
20268 if (SWIG_arg_fail(2)) SWIG_fail;
20269 }
20270 {
20271 PyThreadState* __tstate = wxPyBeginAllowThreads();
20272 {
20273 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20274 result = (wxDateTime *) &_result_ref;
20275 }
20276
20277 wxPyEndAllowThreads(__tstate);
20278 if (PyErr_Occurred()) SWIG_fail;
20279 }
20280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20281 return resultobj;
20282 fail:
20283 return NULL;
20284 }
20285
20286
20287 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20288 PyObject *resultobj;
20289 wxDateTime *arg1 = (wxDateTime *) 0 ;
20290 int arg2 ;
20291 wxDateTime *result;
20292 PyObject * obj0 = 0 ;
20293 PyObject * obj1 = 0 ;
20294 char *kwnames[] = {
20295 (char *) "self",(char *) "hour", NULL
20296 };
20297
20298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20300 if (SWIG_arg_fail(1)) SWIG_fail;
20301 {
20302 arg2 = (int)(SWIG_As_int(obj1));
20303 if (SWIG_arg_fail(2)) SWIG_fail;
20304 }
20305 {
20306 PyThreadState* __tstate = wxPyBeginAllowThreads();
20307 {
20308 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20309 result = (wxDateTime *) &_result_ref;
20310 }
20311
20312 wxPyEndAllowThreads(__tstate);
20313 if (PyErr_Occurred()) SWIG_fail;
20314 }
20315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20316 return resultobj;
20317 fail:
20318 return NULL;
20319 }
20320
20321
20322 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20323 PyObject *resultobj;
20324 wxDateTime *arg1 = (wxDateTime *) 0 ;
20325 int arg2 ;
20326 wxDateTime *result;
20327 PyObject * obj0 = 0 ;
20328 PyObject * obj1 = 0 ;
20329 char *kwnames[] = {
20330 (char *) "self",(char *) "minute", NULL
20331 };
20332
20333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20335 if (SWIG_arg_fail(1)) SWIG_fail;
20336 {
20337 arg2 = (int)(SWIG_As_int(obj1));
20338 if (SWIG_arg_fail(2)) SWIG_fail;
20339 }
20340 {
20341 PyThreadState* __tstate = wxPyBeginAllowThreads();
20342 {
20343 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20344 result = (wxDateTime *) &_result_ref;
20345 }
20346
20347 wxPyEndAllowThreads(__tstate);
20348 if (PyErr_Occurred()) SWIG_fail;
20349 }
20350 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20351 return resultobj;
20352 fail:
20353 return NULL;
20354 }
20355
20356
20357 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20358 PyObject *resultobj;
20359 wxDateTime *arg1 = (wxDateTime *) 0 ;
20360 int arg2 ;
20361 wxDateTime *result;
20362 PyObject * obj0 = 0 ;
20363 PyObject * obj1 = 0 ;
20364 char *kwnames[] = {
20365 (char *) "self",(char *) "second", NULL
20366 };
20367
20368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20370 if (SWIG_arg_fail(1)) SWIG_fail;
20371 {
20372 arg2 = (int)(SWIG_As_int(obj1));
20373 if (SWIG_arg_fail(2)) SWIG_fail;
20374 }
20375 {
20376 PyThreadState* __tstate = wxPyBeginAllowThreads();
20377 {
20378 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20379 result = (wxDateTime *) &_result_ref;
20380 }
20381
20382 wxPyEndAllowThreads(__tstate);
20383 if (PyErr_Occurred()) SWIG_fail;
20384 }
20385 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20386 return resultobj;
20387 fail:
20388 return NULL;
20389 }
20390
20391
20392 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20393 PyObject *resultobj;
20394 wxDateTime *arg1 = (wxDateTime *) 0 ;
20395 int arg2 ;
20396 wxDateTime *result;
20397 PyObject * obj0 = 0 ;
20398 PyObject * obj1 = 0 ;
20399 char *kwnames[] = {
20400 (char *) "self",(char *) "millisecond", NULL
20401 };
20402
20403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20405 if (SWIG_arg_fail(1)) SWIG_fail;
20406 {
20407 arg2 = (int)(SWIG_As_int(obj1));
20408 if (SWIG_arg_fail(2)) SWIG_fail;
20409 }
20410 {
20411 PyThreadState* __tstate = wxPyBeginAllowThreads();
20412 {
20413 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20414 result = (wxDateTime *) &_result_ref;
20415 }
20416
20417 wxPyEndAllowThreads(__tstate);
20418 if (PyErr_Occurred()) SWIG_fail;
20419 }
20420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20421 return resultobj;
20422 fail:
20423 return NULL;
20424 }
20425
20426
20427 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20428 PyObject *resultobj;
20429 wxDateTime *arg1 = (wxDateTime *) 0 ;
20430 wxDateTime::WeekDay arg2 ;
20431 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20432 wxDateTime *result;
20433 PyObject * obj0 = 0 ;
20434 PyObject * obj1 = 0 ;
20435 PyObject * obj2 = 0 ;
20436 char *kwnames[] = {
20437 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20438 };
20439
20440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20442 if (SWIG_arg_fail(1)) SWIG_fail;
20443 {
20444 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20445 if (SWIG_arg_fail(2)) SWIG_fail;
20446 }
20447 if (obj2) {
20448 {
20449 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20450 if (SWIG_arg_fail(3)) SWIG_fail;
20451 }
20452 }
20453 {
20454 PyThreadState* __tstate = wxPyBeginAllowThreads();
20455 {
20456 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20457 result = (wxDateTime *) &_result_ref;
20458 }
20459
20460 wxPyEndAllowThreads(__tstate);
20461 if (PyErr_Occurred()) SWIG_fail;
20462 }
20463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20464 return resultobj;
20465 fail:
20466 return NULL;
20467 }
20468
20469
20470 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20471 PyObject *resultobj;
20472 wxDateTime *arg1 = (wxDateTime *) 0 ;
20473 wxDateTime::WeekDay arg2 ;
20474 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20475 wxDateTime result;
20476 PyObject * obj0 = 0 ;
20477 PyObject * obj1 = 0 ;
20478 PyObject * obj2 = 0 ;
20479 char *kwnames[] = {
20480 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20481 };
20482
20483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20485 if (SWIG_arg_fail(1)) SWIG_fail;
20486 {
20487 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20488 if (SWIG_arg_fail(2)) SWIG_fail;
20489 }
20490 if (obj2) {
20491 {
20492 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20493 if (SWIG_arg_fail(3)) SWIG_fail;
20494 }
20495 }
20496 {
20497 PyThreadState* __tstate = wxPyBeginAllowThreads();
20498 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20499
20500 wxPyEndAllowThreads(__tstate);
20501 if (PyErr_Occurred()) SWIG_fail;
20502 }
20503 {
20504 wxDateTime * resultptr;
20505 resultptr = new wxDateTime((wxDateTime &)(result));
20506 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20507 }
20508 return resultobj;
20509 fail:
20510 return NULL;
20511 }
20512
20513
20514 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20515 PyObject *resultobj;
20516 wxDateTime *arg1 = (wxDateTime *) 0 ;
20517 wxDateTime::WeekDay arg2 ;
20518 wxDateTime *result;
20519 PyObject * obj0 = 0 ;
20520 PyObject * obj1 = 0 ;
20521 char *kwnames[] = {
20522 (char *) "self",(char *) "weekday", NULL
20523 };
20524
20525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20527 if (SWIG_arg_fail(1)) SWIG_fail;
20528 {
20529 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20530 if (SWIG_arg_fail(2)) SWIG_fail;
20531 }
20532 {
20533 PyThreadState* __tstate = wxPyBeginAllowThreads();
20534 {
20535 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20536 result = (wxDateTime *) &_result_ref;
20537 }
20538
20539 wxPyEndAllowThreads(__tstate);
20540 if (PyErr_Occurred()) SWIG_fail;
20541 }
20542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20543 return resultobj;
20544 fail:
20545 return NULL;
20546 }
20547
20548
20549 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20550 PyObject *resultobj;
20551 wxDateTime *arg1 = (wxDateTime *) 0 ;
20552 wxDateTime::WeekDay arg2 ;
20553 wxDateTime result;
20554 PyObject * obj0 = 0 ;
20555 PyObject * obj1 = 0 ;
20556 char *kwnames[] = {
20557 (char *) "self",(char *) "weekday", NULL
20558 };
20559
20560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20562 if (SWIG_arg_fail(1)) SWIG_fail;
20563 {
20564 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20565 if (SWIG_arg_fail(2)) SWIG_fail;
20566 }
20567 {
20568 PyThreadState* __tstate = wxPyBeginAllowThreads();
20569 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20570
20571 wxPyEndAllowThreads(__tstate);
20572 if (PyErr_Occurred()) SWIG_fail;
20573 }
20574 {
20575 wxDateTime * resultptr;
20576 resultptr = new wxDateTime((wxDateTime &)(result));
20577 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20578 }
20579 return resultobj;
20580 fail:
20581 return NULL;
20582 }
20583
20584
20585 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20586 PyObject *resultobj;
20587 wxDateTime *arg1 = (wxDateTime *) 0 ;
20588 wxDateTime::WeekDay arg2 ;
20589 wxDateTime *result;
20590 PyObject * obj0 = 0 ;
20591 PyObject * obj1 = 0 ;
20592 char *kwnames[] = {
20593 (char *) "self",(char *) "weekday", NULL
20594 };
20595
20596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20598 if (SWIG_arg_fail(1)) SWIG_fail;
20599 {
20600 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20601 if (SWIG_arg_fail(2)) SWIG_fail;
20602 }
20603 {
20604 PyThreadState* __tstate = wxPyBeginAllowThreads();
20605 {
20606 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20607 result = (wxDateTime *) &_result_ref;
20608 }
20609
20610 wxPyEndAllowThreads(__tstate);
20611 if (PyErr_Occurred()) SWIG_fail;
20612 }
20613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20614 return resultobj;
20615 fail:
20616 return NULL;
20617 }
20618
20619
20620 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20621 PyObject *resultobj;
20622 wxDateTime *arg1 = (wxDateTime *) 0 ;
20623 wxDateTime::WeekDay arg2 ;
20624 wxDateTime result;
20625 PyObject * obj0 = 0 ;
20626 PyObject * obj1 = 0 ;
20627 char *kwnames[] = {
20628 (char *) "self",(char *) "weekday", NULL
20629 };
20630
20631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20633 if (SWIG_arg_fail(1)) SWIG_fail;
20634 {
20635 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20636 if (SWIG_arg_fail(2)) SWIG_fail;
20637 }
20638 {
20639 PyThreadState* __tstate = wxPyBeginAllowThreads();
20640 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20641
20642 wxPyEndAllowThreads(__tstate);
20643 if (PyErr_Occurred()) SWIG_fail;
20644 }
20645 {
20646 wxDateTime * resultptr;
20647 resultptr = new wxDateTime((wxDateTime &)(result));
20648 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20649 }
20650 return resultobj;
20651 fail:
20652 return NULL;
20653 }
20654
20655
20656 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20657 PyObject *resultobj;
20658 wxDateTime *arg1 = (wxDateTime *) 0 ;
20659 wxDateTime::WeekDay arg2 ;
20660 int arg3 = (int) 1 ;
20661 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20662 int arg5 = (int) wxDateTime::Inv_Year ;
20663 bool result;
20664 PyObject * obj0 = 0 ;
20665 PyObject * obj1 = 0 ;
20666 PyObject * obj2 = 0 ;
20667 PyObject * obj3 = 0 ;
20668 PyObject * obj4 = 0 ;
20669 char *kwnames[] = {
20670 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20671 };
20672
20673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20675 if (SWIG_arg_fail(1)) SWIG_fail;
20676 {
20677 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20678 if (SWIG_arg_fail(2)) SWIG_fail;
20679 }
20680 if (obj2) {
20681 {
20682 arg3 = (int)(SWIG_As_int(obj2));
20683 if (SWIG_arg_fail(3)) SWIG_fail;
20684 }
20685 }
20686 if (obj3) {
20687 {
20688 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20689 if (SWIG_arg_fail(4)) SWIG_fail;
20690 }
20691 }
20692 if (obj4) {
20693 {
20694 arg5 = (int)(SWIG_As_int(obj4));
20695 if (SWIG_arg_fail(5)) SWIG_fail;
20696 }
20697 }
20698 {
20699 PyThreadState* __tstate = wxPyBeginAllowThreads();
20700 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20701
20702 wxPyEndAllowThreads(__tstate);
20703 if (PyErr_Occurred()) SWIG_fail;
20704 }
20705 {
20706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20707 }
20708 return resultobj;
20709 fail:
20710 return NULL;
20711 }
20712
20713
20714 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20715 PyObject *resultobj;
20716 wxDateTime *arg1 = (wxDateTime *) 0 ;
20717 wxDateTime::WeekDay arg2 ;
20718 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20719 int arg4 = (int) wxDateTime::Inv_Year ;
20720 bool result;
20721 PyObject * obj0 = 0 ;
20722 PyObject * obj1 = 0 ;
20723 PyObject * obj2 = 0 ;
20724 PyObject * obj3 = 0 ;
20725 char *kwnames[] = {
20726 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20727 };
20728
20729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20731 if (SWIG_arg_fail(1)) SWIG_fail;
20732 {
20733 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20734 if (SWIG_arg_fail(2)) SWIG_fail;
20735 }
20736 if (obj2) {
20737 {
20738 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20739 if (SWIG_arg_fail(3)) SWIG_fail;
20740 }
20741 }
20742 if (obj3) {
20743 {
20744 arg4 = (int)(SWIG_As_int(obj3));
20745 if (SWIG_arg_fail(4)) SWIG_fail;
20746 }
20747 }
20748 {
20749 PyThreadState* __tstate = wxPyBeginAllowThreads();
20750 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20751
20752 wxPyEndAllowThreads(__tstate);
20753 if (PyErr_Occurred()) SWIG_fail;
20754 }
20755 {
20756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20757 }
20758 return resultobj;
20759 fail:
20760 return NULL;
20761 }
20762
20763
20764 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20765 PyObject *resultobj;
20766 wxDateTime *arg1 = (wxDateTime *) 0 ;
20767 wxDateTime::WeekDay arg2 ;
20768 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20769 int arg4 = (int) wxDateTime::Inv_Year ;
20770 wxDateTime result;
20771 PyObject * obj0 = 0 ;
20772 PyObject * obj1 = 0 ;
20773 PyObject * obj2 = 0 ;
20774 PyObject * obj3 = 0 ;
20775 char *kwnames[] = {
20776 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20777 };
20778
20779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20781 if (SWIG_arg_fail(1)) SWIG_fail;
20782 {
20783 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20784 if (SWIG_arg_fail(2)) SWIG_fail;
20785 }
20786 if (obj2) {
20787 {
20788 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20789 if (SWIG_arg_fail(3)) SWIG_fail;
20790 }
20791 }
20792 if (obj3) {
20793 {
20794 arg4 = (int)(SWIG_As_int(obj3));
20795 if (SWIG_arg_fail(4)) SWIG_fail;
20796 }
20797 }
20798 {
20799 PyThreadState* __tstate = wxPyBeginAllowThreads();
20800 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20801
20802 wxPyEndAllowThreads(__tstate);
20803 if (PyErr_Occurred()) SWIG_fail;
20804 }
20805 {
20806 wxDateTime * resultptr;
20807 resultptr = new wxDateTime((wxDateTime &)(result));
20808 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20809 }
20810 return resultobj;
20811 fail:
20812 return NULL;
20813 }
20814
20815
20816 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20817 PyObject *resultobj;
20818 wxDateTime *arg1 = (wxDateTime *) 0 ;
20819 int arg2 ;
20820 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20821 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20822 bool result;
20823 PyObject * obj0 = 0 ;
20824 PyObject * obj1 = 0 ;
20825 PyObject * obj2 = 0 ;
20826 PyObject * obj3 = 0 ;
20827 char *kwnames[] = {
20828 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20829 };
20830
20831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20833 if (SWIG_arg_fail(1)) SWIG_fail;
20834 {
20835 arg2 = (int)(SWIG_As_int(obj1));
20836 if (SWIG_arg_fail(2)) SWIG_fail;
20837 }
20838 if (obj2) {
20839 {
20840 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20841 if (SWIG_arg_fail(3)) SWIG_fail;
20842 }
20843 }
20844 if (obj3) {
20845 {
20846 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20847 if (SWIG_arg_fail(4)) SWIG_fail;
20848 }
20849 }
20850 {
20851 PyThreadState* __tstate = wxPyBeginAllowThreads();
20852 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20853
20854 wxPyEndAllowThreads(__tstate);
20855 if (PyErr_Occurred()) SWIG_fail;
20856 }
20857 {
20858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20859 }
20860 return resultobj;
20861 fail:
20862 return NULL;
20863 }
20864
20865
20866 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20867 PyObject *resultobj;
20868 wxDateTime *arg1 = (wxDateTime *) 0 ;
20869 int arg2 ;
20870 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20871 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20872 wxDateTime result;
20873 PyObject * obj0 = 0 ;
20874 PyObject * obj1 = 0 ;
20875 PyObject * obj2 = 0 ;
20876 PyObject * obj3 = 0 ;
20877 char *kwnames[] = {
20878 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20879 };
20880
20881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20883 if (SWIG_arg_fail(1)) SWIG_fail;
20884 {
20885 arg2 = (int)(SWIG_As_int(obj1));
20886 if (SWIG_arg_fail(2)) SWIG_fail;
20887 }
20888 if (obj2) {
20889 {
20890 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20891 if (SWIG_arg_fail(3)) SWIG_fail;
20892 }
20893 }
20894 if (obj3) {
20895 {
20896 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20897 if (SWIG_arg_fail(4)) SWIG_fail;
20898 }
20899 }
20900 {
20901 PyThreadState* __tstate = wxPyBeginAllowThreads();
20902 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20903
20904 wxPyEndAllowThreads(__tstate);
20905 if (PyErr_Occurred()) SWIG_fail;
20906 }
20907 {
20908 wxDateTime * resultptr;
20909 resultptr = new wxDateTime((wxDateTime &)(result));
20910 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20911 }
20912 return resultobj;
20913 fail:
20914 return NULL;
20915 }
20916
20917
20918 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20919 PyObject *resultobj;
20920 int arg1 ;
20921 int arg2 ;
20922 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20923 wxDateTime result;
20924 PyObject * obj0 = 0 ;
20925 PyObject * obj1 = 0 ;
20926 PyObject * obj2 = 0 ;
20927 char *kwnames[] = {
20928 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20929 };
20930
20931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20932 {
20933 arg1 = (int)(SWIG_As_int(obj0));
20934 if (SWIG_arg_fail(1)) SWIG_fail;
20935 }
20936 {
20937 arg2 = (int)(SWIG_As_int(obj1));
20938 if (SWIG_arg_fail(2)) SWIG_fail;
20939 }
20940 if (obj2) {
20941 {
20942 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20943 if (SWIG_arg_fail(3)) SWIG_fail;
20944 }
20945 }
20946 {
20947 PyThreadState* __tstate = wxPyBeginAllowThreads();
20948 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20949
20950 wxPyEndAllowThreads(__tstate);
20951 if (PyErr_Occurred()) SWIG_fail;
20952 }
20953 {
20954 wxDateTime * resultptr;
20955 resultptr = new wxDateTime((wxDateTime &)(result));
20956 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20957 }
20958 return resultobj;
20959 fail:
20960 return NULL;
20961 }
20962
20963
20964 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20965 PyObject *resultobj;
20966 wxDateTime *arg1 = (wxDateTime *) 0 ;
20967 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20968 int arg3 = (int) wxDateTime::Inv_Year ;
20969 wxDateTime *result;
20970 PyObject * obj0 = 0 ;
20971 PyObject * obj1 = 0 ;
20972 PyObject * obj2 = 0 ;
20973 char *kwnames[] = {
20974 (char *) "self",(char *) "month",(char *) "year", NULL
20975 };
20976
20977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20979 if (SWIG_arg_fail(1)) SWIG_fail;
20980 if (obj1) {
20981 {
20982 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20983 if (SWIG_arg_fail(2)) SWIG_fail;
20984 }
20985 }
20986 if (obj2) {
20987 {
20988 arg3 = (int)(SWIG_As_int(obj2));
20989 if (SWIG_arg_fail(3)) SWIG_fail;
20990 }
20991 }
20992 {
20993 PyThreadState* __tstate = wxPyBeginAllowThreads();
20994 {
20995 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20996 result = (wxDateTime *) &_result_ref;
20997 }
20998
20999 wxPyEndAllowThreads(__tstate);
21000 if (PyErr_Occurred()) SWIG_fail;
21001 }
21002 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21003 return resultobj;
21004 fail:
21005 return NULL;
21006 }
21007
21008
21009 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21010 PyObject *resultobj;
21011 wxDateTime *arg1 = (wxDateTime *) 0 ;
21012 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21013 int arg3 = (int) wxDateTime::Inv_Year ;
21014 wxDateTime result;
21015 PyObject * obj0 = 0 ;
21016 PyObject * obj1 = 0 ;
21017 PyObject * obj2 = 0 ;
21018 char *kwnames[] = {
21019 (char *) "self",(char *) "month",(char *) "year", NULL
21020 };
21021
21022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) 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 if (obj1) {
21026 {
21027 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21028 if (SWIG_arg_fail(2)) SWIG_fail;
21029 }
21030 }
21031 if (obj2) {
21032 {
21033 arg3 = (int)(SWIG_As_int(obj2));
21034 if (SWIG_arg_fail(3)) SWIG_fail;
21035 }
21036 }
21037 {
21038 PyThreadState* __tstate = wxPyBeginAllowThreads();
21039 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
21040
21041 wxPyEndAllowThreads(__tstate);
21042 if (PyErr_Occurred()) SWIG_fail;
21043 }
21044 {
21045 wxDateTime * resultptr;
21046 resultptr = new wxDateTime((wxDateTime &)(result));
21047 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21048 }
21049 return resultobj;
21050 fail:
21051 return NULL;
21052 }
21053
21054
21055 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21056 PyObject *resultobj;
21057 wxDateTime *arg1 = (wxDateTime *) 0 ;
21058 int arg2 ;
21059 wxDateTime *result;
21060 PyObject * obj0 = 0 ;
21061 PyObject * obj1 = 0 ;
21062 char *kwnames[] = {
21063 (char *) "self",(char *) "yday", NULL
21064 };
21065
21066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21068 if (SWIG_arg_fail(1)) SWIG_fail;
21069 {
21070 arg2 = (int)(SWIG_As_int(obj1));
21071 if (SWIG_arg_fail(2)) SWIG_fail;
21072 }
21073 {
21074 PyThreadState* __tstate = wxPyBeginAllowThreads();
21075 {
21076 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21077 result = (wxDateTime *) &_result_ref;
21078 }
21079
21080 wxPyEndAllowThreads(__tstate);
21081 if (PyErr_Occurred()) SWIG_fail;
21082 }
21083 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21084 return resultobj;
21085 fail:
21086 return NULL;
21087 }
21088
21089
21090 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21091 PyObject *resultobj;
21092 wxDateTime *arg1 = (wxDateTime *) 0 ;
21093 int arg2 ;
21094 wxDateTime result;
21095 PyObject * obj0 = 0 ;
21096 PyObject * obj1 = 0 ;
21097 char *kwnames[] = {
21098 (char *) "self",(char *) "yday", NULL
21099 };
21100
21101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21103 if (SWIG_arg_fail(1)) SWIG_fail;
21104 {
21105 arg2 = (int)(SWIG_As_int(obj1));
21106 if (SWIG_arg_fail(2)) SWIG_fail;
21107 }
21108 {
21109 PyThreadState* __tstate = wxPyBeginAllowThreads();
21110 result = (arg1)->GetYearDay(arg2);
21111
21112 wxPyEndAllowThreads(__tstate);
21113 if (PyErr_Occurred()) SWIG_fail;
21114 }
21115 {
21116 wxDateTime * resultptr;
21117 resultptr = new wxDateTime((wxDateTime &)(result));
21118 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21119 }
21120 return resultobj;
21121 fail:
21122 return NULL;
21123 }
21124
21125
21126 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21127 PyObject *resultobj;
21128 wxDateTime *arg1 = (wxDateTime *) 0 ;
21129 double result;
21130 PyObject * obj0 = 0 ;
21131 char *kwnames[] = {
21132 (char *) "self", NULL
21133 };
21134
21135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21137 if (SWIG_arg_fail(1)) SWIG_fail;
21138 {
21139 PyThreadState* __tstate = wxPyBeginAllowThreads();
21140 result = (double)(arg1)->GetJulianDayNumber();
21141
21142 wxPyEndAllowThreads(__tstate);
21143 if (PyErr_Occurred()) SWIG_fail;
21144 }
21145 {
21146 resultobj = SWIG_From_double((double)(result));
21147 }
21148 return resultobj;
21149 fail:
21150 return NULL;
21151 }
21152
21153
21154 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21155 PyObject *resultobj;
21156 wxDateTime *arg1 = (wxDateTime *) 0 ;
21157 double result;
21158 PyObject * obj0 = 0 ;
21159 char *kwnames[] = {
21160 (char *) "self", NULL
21161 };
21162
21163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) 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 {
21167 PyThreadState* __tstate = wxPyBeginAllowThreads();
21168 result = (double)(arg1)->GetJDN();
21169
21170 wxPyEndAllowThreads(__tstate);
21171 if (PyErr_Occurred()) SWIG_fail;
21172 }
21173 {
21174 resultobj = SWIG_From_double((double)(result));
21175 }
21176 return resultobj;
21177 fail:
21178 return NULL;
21179 }
21180
21181
21182 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21183 PyObject *resultobj;
21184 wxDateTime *arg1 = (wxDateTime *) 0 ;
21185 double result;
21186 PyObject * obj0 = 0 ;
21187 char *kwnames[] = {
21188 (char *) "self", NULL
21189 };
21190
21191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21193 if (SWIG_arg_fail(1)) SWIG_fail;
21194 {
21195 PyThreadState* __tstate = wxPyBeginAllowThreads();
21196 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21197
21198 wxPyEndAllowThreads(__tstate);
21199 if (PyErr_Occurred()) SWIG_fail;
21200 }
21201 {
21202 resultobj = SWIG_From_double((double)(result));
21203 }
21204 return resultobj;
21205 fail:
21206 return NULL;
21207 }
21208
21209
21210 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21211 PyObject *resultobj;
21212 wxDateTime *arg1 = (wxDateTime *) 0 ;
21213 double result;
21214 PyObject * obj0 = 0 ;
21215 char *kwnames[] = {
21216 (char *) "self", NULL
21217 };
21218
21219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21221 if (SWIG_arg_fail(1)) SWIG_fail;
21222 {
21223 PyThreadState* __tstate = wxPyBeginAllowThreads();
21224 result = (double)(arg1)->GetMJD();
21225
21226 wxPyEndAllowThreads(__tstate);
21227 if (PyErr_Occurred()) SWIG_fail;
21228 }
21229 {
21230 resultobj = SWIG_From_double((double)(result));
21231 }
21232 return resultobj;
21233 fail:
21234 return NULL;
21235 }
21236
21237
21238 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21239 PyObject *resultobj;
21240 wxDateTime *arg1 = (wxDateTime *) 0 ;
21241 double result;
21242 PyObject * obj0 = 0 ;
21243 char *kwnames[] = {
21244 (char *) "self", NULL
21245 };
21246
21247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21249 if (SWIG_arg_fail(1)) SWIG_fail;
21250 {
21251 PyThreadState* __tstate = wxPyBeginAllowThreads();
21252 result = (double)(arg1)->GetRataDie();
21253
21254 wxPyEndAllowThreads(__tstate);
21255 if (PyErr_Occurred()) SWIG_fail;
21256 }
21257 {
21258 resultobj = SWIG_From_double((double)(result));
21259 }
21260 return resultobj;
21261 fail:
21262 return NULL;
21263 }
21264
21265
21266 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21267 PyObject *resultobj;
21268 wxDateTime *arg1 = (wxDateTime *) 0 ;
21269 wxDateTime::TimeZone *arg2 = 0 ;
21270 bool arg3 = (bool) false ;
21271 wxDateTime result;
21272 bool temp2 = false ;
21273 PyObject * obj0 = 0 ;
21274 PyObject * obj1 = 0 ;
21275 PyObject * obj2 = 0 ;
21276 char *kwnames[] = {
21277 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21278 };
21279
21280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21282 if (SWIG_arg_fail(1)) SWIG_fail;
21283 {
21284 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21285 temp2 = true;
21286 }
21287 if (obj2) {
21288 {
21289 arg3 = (bool)(SWIG_As_bool(obj2));
21290 if (SWIG_arg_fail(3)) SWIG_fail;
21291 }
21292 }
21293 {
21294 PyThreadState* __tstate = wxPyBeginAllowThreads();
21295 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21296
21297 wxPyEndAllowThreads(__tstate);
21298 if (PyErr_Occurred()) SWIG_fail;
21299 }
21300 {
21301 wxDateTime * resultptr;
21302 resultptr = new wxDateTime((wxDateTime &)(result));
21303 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21304 }
21305 {
21306 if (temp2) delete arg2;
21307 }
21308 return resultobj;
21309 fail:
21310 {
21311 if (temp2) delete arg2;
21312 }
21313 return NULL;
21314 }
21315
21316
21317 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21318 PyObject *resultobj;
21319 wxDateTime *arg1 = (wxDateTime *) 0 ;
21320 wxDateTime::TimeZone *arg2 = 0 ;
21321 bool arg3 = (bool) false ;
21322 wxDateTime *result;
21323 bool temp2 = false ;
21324 PyObject * obj0 = 0 ;
21325 PyObject * obj1 = 0 ;
21326 PyObject * obj2 = 0 ;
21327 char *kwnames[] = {
21328 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21329 };
21330
21331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21333 if (SWIG_arg_fail(1)) SWIG_fail;
21334 {
21335 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21336 temp2 = true;
21337 }
21338 if (obj2) {
21339 {
21340 arg3 = (bool)(SWIG_As_bool(obj2));
21341 if (SWIG_arg_fail(3)) SWIG_fail;
21342 }
21343 }
21344 {
21345 PyThreadState* __tstate = wxPyBeginAllowThreads();
21346 {
21347 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21348 result = (wxDateTime *) &_result_ref;
21349 }
21350
21351 wxPyEndAllowThreads(__tstate);
21352 if (PyErr_Occurred()) SWIG_fail;
21353 }
21354 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21355 {
21356 if (temp2) delete arg2;
21357 }
21358 return resultobj;
21359 fail:
21360 {
21361 if (temp2) delete arg2;
21362 }
21363 return NULL;
21364 }
21365
21366
21367 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21368 PyObject *resultobj;
21369 wxDateTime *arg1 = (wxDateTime *) 0 ;
21370 bool arg2 = (bool) false ;
21371 wxDateTime result;
21372 PyObject * obj0 = 0 ;
21373 PyObject * obj1 = 0 ;
21374 char *kwnames[] = {
21375 (char *) "self",(char *) "noDST", NULL
21376 };
21377
21378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21380 if (SWIG_arg_fail(1)) SWIG_fail;
21381 if (obj1) {
21382 {
21383 arg2 = (bool)(SWIG_As_bool(obj1));
21384 if (SWIG_arg_fail(2)) SWIG_fail;
21385 }
21386 }
21387 {
21388 PyThreadState* __tstate = wxPyBeginAllowThreads();
21389 result = (arg1)->ToGMT(arg2);
21390
21391 wxPyEndAllowThreads(__tstate);
21392 if (PyErr_Occurred()) SWIG_fail;
21393 }
21394 {
21395 wxDateTime * resultptr;
21396 resultptr = new wxDateTime((wxDateTime &)(result));
21397 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21398 }
21399 return resultobj;
21400 fail:
21401 return NULL;
21402 }
21403
21404
21405 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21406 PyObject *resultobj;
21407 wxDateTime *arg1 = (wxDateTime *) 0 ;
21408 bool arg2 = (bool) false ;
21409 wxDateTime *result;
21410 PyObject * obj0 = 0 ;
21411 PyObject * obj1 = 0 ;
21412 char *kwnames[] = {
21413 (char *) "self",(char *) "noDST", NULL
21414 };
21415
21416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21418 if (SWIG_arg_fail(1)) SWIG_fail;
21419 if (obj1) {
21420 {
21421 arg2 = (bool)(SWIG_As_bool(obj1));
21422 if (SWIG_arg_fail(2)) SWIG_fail;
21423 }
21424 }
21425 {
21426 PyThreadState* __tstate = wxPyBeginAllowThreads();
21427 {
21428 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21429 result = (wxDateTime *) &_result_ref;
21430 }
21431
21432 wxPyEndAllowThreads(__tstate);
21433 if (PyErr_Occurred()) SWIG_fail;
21434 }
21435 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21436 return resultobj;
21437 fail:
21438 return NULL;
21439 }
21440
21441
21442 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21443 PyObject *resultobj;
21444 wxDateTime *arg1 = (wxDateTime *) 0 ;
21445 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21446 int result;
21447 PyObject * obj0 = 0 ;
21448 PyObject * obj1 = 0 ;
21449 char *kwnames[] = {
21450 (char *) "self",(char *) "country", NULL
21451 };
21452
21453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21455 if (SWIG_arg_fail(1)) SWIG_fail;
21456 if (obj1) {
21457 {
21458 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21459 if (SWIG_arg_fail(2)) SWIG_fail;
21460 }
21461 }
21462 {
21463 PyThreadState* __tstate = wxPyBeginAllowThreads();
21464 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21465
21466 wxPyEndAllowThreads(__tstate);
21467 if (PyErr_Occurred()) SWIG_fail;
21468 }
21469 {
21470 resultobj = SWIG_From_int((int)(result));
21471 }
21472 return resultobj;
21473 fail:
21474 return NULL;
21475 }
21476
21477
21478 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21479 PyObject *resultobj;
21480 wxDateTime *arg1 = (wxDateTime *) 0 ;
21481 bool result;
21482 PyObject * obj0 = 0 ;
21483 char *kwnames[] = {
21484 (char *) "self", NULL
21485 };
21486
21487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21489 if (SWIG_arg_fail(1)) SWIG_fail;
21490 {
21491 PyThreadState* __tstate = wxPyBeginAllowThreads();
21492 result = (bool)((wxDateTime const *)arg1)->IsValid();
21493
21494 wxPyEndAllowThreads(__tstate);
21495 if (PyErr_Occurred()) SWIG_fail;
21496 }
21497 {
21498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21499 }
21500 return resultobj;
21501 fail:
21502 return NULL;
21503 }
21504
21505
21506 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21507 PyObject *resultobj;
21508 wxDateTime *arg1 = (wxDateTime *) 0 ;
21509 time_t result;
21510 PyObject * obj0 = 0 ;
21511 char *kwnames[] = {
21512 (char *) "self", NULL
21513 };
21514
21515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21517 if (SWIG_arg_fail(1)) SWIG_fail;
21518 {
21519 PyThreadState* __tstate = wxPyBeginAllowThreads();
21520 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21521
21522 wxPyEndAllowThreads(__tstate);
21523 if (PyErr_Occurred()) SWIG_fail;
21524 }
21525 {
21526 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21527 }
21528 return resultobj;
21529 fail:
21530 return NULL;
21531 }
21532
21533
21534 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21535 PyObject *resultobj;
21536 wxDateTime *arg1 = (wxDateTime *) 0 ;
21537 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21538 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21539 int result;
21540 bool temp2 = false ;
21541 PyObject * obj0 = 0 ;
21542 PyObject * obj1 = 0 ;
21543 char *kwnames[] = {
21544 (char *) "self",(char *) "tz", NULL
21545 };
21546
21547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21549 if (SWIG_arg_fail(1)) SWIG_fail;
21550 if (obj1) {
21551 {
21552 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21553 temp2 = true;
21554 }
21555 }
21556 {
21557 PyThreadState* __tstate = wxPyBeginAllowThreads();
21558 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21559
21560 wxPyEndAllowThreads(__tstate);
21561 if (PyErr_Occurred()) SWIG_fail;
21562 }
21563 {
21564 resultobj = SWIG_From_int((int)(result));
21565 }
21566 {
21567 if (temp2) delete arg2;
21568 }
21569 return resultobj;
21570 fail:
21571 {
21572 if (temp2) delete arg2;
21573 }
21574 return NULL;
21575 }
21576
21577
21578 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21579 PyObject *resultobj;
21580 wxDateTime *arg1 = (wxDateTime *) 0 ;
21581 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21582 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21583 wxDateTime::Month result;
21584 bool temp2 = false ;
21585 PyObject * obj0 = 0 ;
21586 PyObject * obj1 = 0 ;
21587 char *kwnames[] = {
21588 (char *) "self",(char *) "tz", NULL
21589 };
21590
21591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21593 if (SWIG_arg_fail(1)) SWIG_fail;
21594 if (obj1) {
21595 {
21596 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21597 temp2 = true;
21598 }
21599 }
21600 {
21601 PyThreadState* __tstate = wxPyBeginAllowThreads();
21602 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21603
21604 wxPyEndAllowThreads(__tstate);
21605 if (PyErr_Occurred()) SWIG_fail;
21606 }
21607 resultobj = SWIG_From_int((result));
21608 {
21609 if (temp2) delete arg2;
21610 }
21611 return resultobj;
21612 fail:
21613 {
21614 if (temp2) delete arg2;
21615 }
21616 return NULL;
21617 }
21618
21619
21620 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21621 PyObject *resultobj;
21622 wxDateTime *arg1 = (wxDateTime *) 0 ;
21623 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21624 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21625 int result;
21626 bool temp2 = false ;
21627 PyObject * obj0 = 0 ;
21628 PyObject * obj1 = 0 ;
21629 char *kwnames[] = {
21630 (char *) "self",(char *) "tz", NULL
21631 };
21632
21633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21635 if (SWIG_arg_fail(1)) SWIG_fail;
21636 if (obj1) {
21637 {
21638 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21639 temp2 = true;
21640 }
21641 }
21642 {
21643 PyThreadState* __tstate = wxPyBeginAllowThreads();
21644 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21645
21646 wxPyEndAllowThreads(__tstate);
21647 if (PyErr_Occurred()) SWIG_fail;
21648 }
21649 {
21650 resultobj = SWIG_From_int((int)(result));
21651 }
21652 {
21653 if (temp2) delete arg2;
21654 }
21655 return resultobj;
21656 fail:
21657 {
21658 if (temp2) delete arg2;
21659 }
21660 return NULL;
21661 }
21662
21663
21664 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21665 PyObject *resultobj;
21666 wxDateTime *arg1 = (wxDateTime *) 0 ;
21667 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21668 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21669 wxDateTime::WeekDay result;
21670 bool temp2 = false ;
21671 PyObject * obj0 = 0 ;
21672 PyObject * obj1 = 0 ;
21673 char *kwnames[] = {
21674 (char *) "self",(char *) "tz", NULL
21675 };
21676
21677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21679 if (SWIG_arg_fail(1)) SWIG_fail;
21680 if (obj1) {
21681 {
21682 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21683 temp2 = true;
21684 }
21685 }
21686 {
21687 PyThreadState* __tstate = wxPyBeginAllowThreads();
21688 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21689
21690 wxPyEndAllowThreads(__tstate);
21691 if (PyErr_Occurred()) SWIG_fail;
21692 }
21693 resultobj = SWIG_From_int((result));
21694 {
21695 if (temp2) delete arg2;
21696 }
21697 return resultobj;
21698 fail:
21699 {
21700 if (temp2) delete arg2;
21701 }
21702 return NULL;
21703 }
21704
21705
21706 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21707 PyObject *resultobj;
21708 wxDateTime *arg1 = (wxDateTime *) 0 ;
21709 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21710 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21711 int result;
21712 bool temp2 = false ;
21713 PyObject * obj0 = 0 ;
21714 PyObject * obj1 = 0 ;
21715 char *kwnames[] = {
21716 (char *) "self",(char *) "tz", NULL
21717 };
21718
21719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21721 if (SWIG_arg_fail(1)) SWIG_fail;
21722 if (obj1) {
21723 {
21724 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21725 temp2 = true;
21726 }
21727 }
21728 {
21729 PyThreadState* __tstate = wxPyBeginAllowThreads();
21730 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21731
21732 wxPyEndAllowThreads(__tstate);
21733 if (PyErr_Occurred()) SWIG_fail;
21734 }
21735 {
21736 resultobj = SWIG_From_int((int)(result));
21737 }
21738 {
21739 if (temp2) delete arg2;
21740 }
21741 return resultobj;
21742 fail:
21743 {
21744 if (temp2) delete arg2;
21745 }
21746 return NULL;
21747 }
21748
21749
21750 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21751 PyObject *resultobj;
21752 wxDateTime *arg1 = (wxDateTime *) 0 ;
21753 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21754 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21755 int result;
21756 bool temp2 = false ;
21757 PyObject * obj0 = 0 ;
21758 PyObject * obj1 = 0 ;
21759 char *kwnames[] = {
21760 (char *) "self",(char *) "tz", NULL
21761 };
21762
21763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21765 if (SWIG_arg_fail(1)) SWIG_fail;
21766 if (obj1) {
21767 {
21768 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21769 temp2 = true;
21770 }
21771 }
21772 {
21773 PyThreadState* __tstate = wxPyBeginAllowThreads();
21774 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21775
21776 wxPyEndAllowThreads(__tstate);
21777 if (PyErr_Occurred()) SWIG_fail;
21778 }
21779 {
21780 resultobj = SWIG_From_int((int)(result));
21781 }
21782 {
21783 if (temp2) delete arg2;
21784 }
21785 return resultobj;
21786 fail:
21787 {
21788 if (temp2) delete arg2;
21789 }
21790 return NULL;
21791 }
21792
21793
21794 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21795 PyObject *resultobj;
21796 wxDateTime *arg1 = (wxDateTime *) 0 ;
21797 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21798 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21799 int result;
21800 bool temp2 = false ;
21801 PyObject * obj0 = 0 ;
21802 PyObject * obj1 = 0 ;
21803 char *kwnames[] = {
21804 (char *) "self",(char *) "tz", NULL
21805 };
21806
21807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21809 if (SWIG_arg_fail(1)) SWIG_fail;
21810 if (obj1) {
21811 {
21812 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21813 temp2 = true;
21814 }
21815 }
21816 {
21817 PyThreadState* __tstate = wxPyBeginAllowThreads();
21818 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21819
21820 wxPyEndAllowThreads(__tstate);
21821 if (PyErr_Occurred()) SWIG_fail;
21822 }
21823 {
21824 resultobj = SWIG_From_int((int)(result));
21825 }
21826 {
21827 if (temp2) delete arg2;
21828 }
21829 return resultobj;
21830 fail:
21831 {
21832 if (temp2) delete arg2;
21833 }
21834 return NULL;
21835 }
21836
21837
21838 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21839 PyObject *resultobj;
21840 wxDateTime *arg1 = (wxDateTime *) 0 ;
21841 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21842 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21843 int result;
21844 bool temp2 = false ;
21845 PyObject * obj0 = 0 ;
21846 PyObject * obj1 = 0 ;
21847 char *kwnames[] = {
21848 (char *) "self",(char *) "tz", NULL
21849 };
21850
21851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21853 if (SWIG_arg_fail(1)) SWIG_fail;
21854 if (obj1) {
21855 {
21856 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21857 temp2 = true;
21858 }
21859 }
21860 {
21861 PyThreadState* __tstate = wxPyBeginAllowThreads();
21862 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21863
21864 wxPyEndAllowThreads(__tstate);
21865 if (PyErr_Occurred()) SWIG_fail;
21866 }
21867 {
21868 resultobj = SWIG_From_int((int)(result));
21869 }
21870 {
21871 if (temp2) delete arg2;
21872 }
21873 return resultobj;
21874 fail:
21875 {
21876 if (temp2) delete arg2;
21877 }
21878 return NULL;
21879 }
21880
21881
21882 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21883 PyObject *resultobj;
21884 wxDateTime *arg1 = (wxDateTime *) 0 ;
21885 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21886 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21887 int result;
21888 bool temp2 = false ;
21889 PyObject * obj0 = 0 ;
21890 PyObject * obj1 = 0 ;
21891 char *kwnames[] = {
21892 (char *) "self",(char *) "tz", NULL
21893 };
21894
21895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21897 if (SWIG_arg_fail(1)) SWIG_fail;
21898 if (obj1) {
21899 {
21900 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21901 temp2 = true;
21902 }
21903 }
21904 {
21905 PyThreadState* __tstate = wxPyBeginAllowThreads();
21906 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21907
21908 wxPyEndAllowThreads(__tstate);
21909 if (PyErr_Occurred()) SWIG_fail;
21910 }
21911 {
21912 resultobj = SWIG_From_int((int)(result));
21913 }
21914 {
21915 if (temp2) delete arg2;
21916 }
21917 return resultobj;
21918 fail:
21919 {
21920 if (temp2) delete arg2;
21921 }
21922 return NULL;
21923 }
21924
21925
21926 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21927 PyObject *resultobj;
21928 wxDateTime *arg1 = (wxDateTime *) 0 ;
21929 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21930 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21931 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21932 int result;
21933 bool temp3 = false ;
21934 PyObject * obj0 = 0 ;
21935 PyObject * obj1 = 0 ;
21936 PyObject * obj2 = 0 ;
21937 char *kwnames[] = {
21938 (char *) "self",(char *) "flags",(char *) "tz", NULL
21939 };
21940
21941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21943 if (SWIG_arg_fail(1)) SWIG_fail;
21944 if (obj1) {
21945 {
21946 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21947 if (SWIG_arg_fail(2)) SWIG_fail;
21948 }
21949 }
21950 if (obj2) {
21951 {
21952 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21953 temp3 = true;
21954 }
21955 }
21956 {
21957 PyThreadState* __tstate = wxPyBeginAllowThreads();
21958 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21959
21960 wxPyEndAllowThreads(__tstate);
21961 if (PyErr_Occurred()) SWIG_fail;
21962 }
21963 {
21964 resultobj = SWIG_From_int((int)(result));
21965 }
21966 {
21967 if (temp3) delete arg3;
21968 }
21969 return resultobj;
21970 fail:
21971 {
21972 if (temp3) delete arg3;
21973 }
21974 return NULL;
21975 }
21976
21977
21978 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21979 PyObject *resultobj;
21980 wxDateTime *arg1 = (wxDateTime *) 0 ;
21981 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21982 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21983 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21984 int result;
21985 bool temp3 = false ;
21986 PyObject * obj0 = 0 ;
21987 PyObject * obj1 = 0 ;
21988 PyObject * obj2 = 0 ;
21989 char *kwnames[] = {
21990 (char *) "self",(char *) "flags",(char *) "tz", NULL
21991 };
21992
21993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21995 if (SWIG_arg_fail(1)) SWIG_fail;
21996 if (obj1) {
21997 {
21998 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21999 if (SWIG_arg_fail(2)) SWIG_fail;
22000 }
22001 }
22002 if (obj2) {
22003 {
22004 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22005 temp3 = true;
22006 }
22007 }
22008 {
22009 PyThreadState* __tstate = wxPyBeginAllowThreads();
22010 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22011
22012 wxPyEndAllowThreads(__tstate);
22013 if (PyErr_Occurred()) SWIG_fail;
22014 }
22015 {
22016 resultobj = SWIG_From_int((int)(result));
22017 }
22018 {
22019 if (temp3) delete arg3;
22020 }
22021 return resultobj;
22022 fail:
22023 {
22024 if (temp3) delete arg3;
22025 }
22026 return NULL;
22027 }
22028
22029
22030 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
22031 PyObject *resultobj;
22032 wxDateTime *arg1 = (wxDateTime *) 0 ;
22033 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22034 bool result;
22035 PyObject * obj0 = 0 ;
22036 PyObject * obj1 = 0 ;
22037 char *kwnames[] = {
22038 (char *) "self",(char *) "country", NULL
22039 };
22040
22041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22043 if (SWIG_arg_fail(1)) SWIG_fail;
22044 if (obj1) {
22045 {
22046 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22047 if (SWIG_arg_fail(2)) SWIG_fail;
22048 }
22049 }
22050 {
22051 PyThreadState* __tstate = wxPyBeginAllowThreads();
22052 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22053
22054 wxPyEndAllowThreads(__tstate);
22055 if (PyErr_Occurred()) SWIG_fail;
22056 }
22057 {
22058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22059 }
22060 return resultobj;
22061 fail:
22062 return NULL;
22063 }
22064
22065
22066 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22067 PyObject *resultobj;
22068 wxDateTime *arg1 = (wxDateTime *) 0 ;
22069 wxDateTime *arg2 = 0 ;
22070 bool result;
22071 PyObject * obj0 = 0 ;
22072 PyObject * obj1 = 0 ;
22073 char *kwnames[] = {
22074 (char *) "self",(char *) "datetime", NULL
22075 };
22076
22077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22079 if (SWIG_arg_fail(1)) SWIG_fail;
22080 {
22081 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22082 if (SWIG_arg_fail(2)) SWIG_fail;
22083 if (arg2 == NULL) {
22084 SWIG_null_ref("wxDateTime");
22085 }
22086 if (SWIG_arg_fail(2)) SWIG_fail;
22087 }
22088 {
22089 PyThreadState* __tstate = wxPyBeginAllowThreads();
22090 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22091
22092 wxPyEndAllowThreads(__tstate);
22093 if (PyErr_Occurred()) SWIG_fail;
22094 }
22095 {
22096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22097 }
22098 return resultobj;
22099 fail:
22100 return NULL;
22101 }
22102
22103
22104 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22105 PyObject *resultobj;
22106 wxDateTime *arg1 = (wxDateTime *) 0 ;
22107 wxDateTime *arg2 = 0 ;
22108 bool result;
22109 PyObject * obj0 = 0 ;
22110 PyObject * obj1 = 0 ;
22111 char *kwnames[] = {
22112 (char *) "self",(char *) "datetime", NULL
22113 };
22114
22115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22117 if (SWIG_arg_fail(1)) SWIG_fail;
22118 {
22119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22120 if (SWIG_arg_fail(2)) SWIG_fail;
22121 if (arg2 == NULL) {
22122 SWIG_null_ref("wxDateTime");
22123 }
22124 if (SWIG_arg_fail(2)) SWIG_fail;
22125 }
22126 {
22127 PyThreadState* __tstate = wxPyBeginAllowThreads();
22128 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22129
22130 wxPyEndAllowThreads(__tstate);
22131 if (PyErr_Occurred()) SWIG_fail;
22132 }
22133 {
22134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22135 }
22136 return resultobj;
22137 fail:
22138 return NULL;
22139 }
22140
22141
22142 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22143 PyObject *resultobj;
22144 wxDateTime *arg1 = (wxDateTime *) 0 ;
22145 wxDateTime *arg2 = 0 ;
22146 bool result;
22147 PyObject * obj0 = 0 ;
22148 PyObject * obj1 = 0 ;
22149 char *kwnames[] = {
22150 (char *) "self",(char *) "datetime", NULL
22151 };
22152
22153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22155 if (SWIG_arg_fail(1)) SWIG_fail;
22156 {
22157 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22158 if (SWIG_arg_fail(2)) SWIG_fail;
22159 if (arg2 == NULL) {
22160 SWIG_null_ref("wxDateTime");
22161 }
22162 if (SWIG_arg_fail(2)) SWIG_fail;
22163 }
22164 {
22165 PyThreadState* __tstate = wxPyBeginAllowThreads();
22166 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22167
22168 wxPyEndAllowThreads(__tstate);
22169 if (PyErr_Occurred()) SWIG_fail;
22170 }
22171 {
22172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22173 }
22174 return resultobj;
22175 fail:
22176 return NULL;
22177 }
22178
22179
22180 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22181 PyObject *resultobj;
22182 wxDateTime *arg1 = (wxDateTime *) 0 ;
22183 wxDateTime *arg2 = 0 ;
22184 wxDateTime *arg3 = 0 ;
22185 bool result;
22186 PyObject * obj0 = 0 ;
22187 PyObject * obj1 = 0 ;
22188 PyObject * obj2 = 0 ;
22189 char *kwnames[] = {
22190 (char *) "self",(char *) "t1",(char *) "t2", NULL
22191 };
22192
22193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22195 if (SWIG_arg_fail(1)) SWIG_fail;
22196 {
22197 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22198 if (SWIG_arg_fail(2)) SWIG_fail;
22199 if (arg2 == NULL) {
22200 SWIG_null_ref("wxDateTime");
22201 }
22202 if (SWIG_arg_fail(2)) SWIG_fail;
22203 }
22204 {
22205 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22206 if (SWIG_arg_fail(3)) SWIG_fail;
22207 if (arg3 == NULL) {
22208 SWIG_null_ref("wxDateTime");
22209 }
22210 if (SWIG_arg_fail(3)) SWIG_fail;
22211 }
22212 {
22213 PyThreadState* __tstate = wxPyBeginAllowThreads();
22214 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22215
22216 wxPyEndAllowThreads(__tstate);
22217 if (PyErr_Occurred()) SWIG_fail;
22218 }
22219 {
22220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22221 }
22222 return resultobj;
22223 fail:
22224 return NULL;
22225 }
22226
22227
22228 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22229 PyObject *resultobj;
22230 wxDateTime *arg1 = (wxDateTime *) 0 ;
22231 wxDateTime *arg2 = 0 ;
22232 wxDateTime *arg3 = 0 ;
22233 bool result;
22234 PyObject * obj0 = 0 ;
22235 PyObject * obj1 = 0 ;
22236 PyObject * obj2 = 0 ;
22237 char *kwnames[] = {
22238 (char *) "self",(char *) "t1",(char *) "t2", NULL
22239 };
22240
22241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22243 if (SWIG_arg_fail(1)) SWIG_fail;
22244 {
22245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22246 if (SWIG_arg_fail(2)) SWIG_fail;
22247 if (arg2 == NULL) {
22248 SWIG_null_ref("wxDateTime");
22249 }
22250 if (SWIG_arg_fail(2)) SWIG_fail;
22251 }
22252 {
22253 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22254 if (SWIG_arg_fail(3)) SWIG_fail;
22255 if (arg3 == NULL) {
22256 SWIG_null_ref("wxDateTime");
22257 }
22258 if (SWIG_arg_fail(3)) SWIG_fail;
22259 }
22260 {
22261 PyThreadState* __tstate = wxPyBeginAllowThreads();
22262 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22263
22264 wxPyEndAllowThreads(__tstate);
22265 if (PyErr_Occurred()) SWIG_fail;
22266 }
22267 {
22268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22269 }
22270 return resultobj;
22271 fail:
22272 return NULL;
22273 }
22274
22275
22276 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22277 PyObject *resultobj;
22278 wxDateTime *arg1 = (wxDateTime *) 0 ;
22279 wxDateTime *arg2 = 0 ;
22280 bool result;
22281 PyObject * obj0 = 0 ;
22282 PyObject * obj1 = 0 ;
22283 char *kwnames[] = {
22284 (char *) "self",(char *) "dt", NULL
22285 };
22286
22287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22289 if (SWIG_arg_fail(1)) SWIG_fail;
22290 {
22291 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22292 if (SWIG_arg_fail(2)) SWIG_fail;
22293 if (arg2 == NULL) {
22294 SWIG_null_ref("wxDateTime");
22295 }
22296 if (SWIG_arg_fail(2)) SWIG_fail;
22297 }
22298 {
22299 PyThreadState* __tstate = wxPyBeginAllowThreads();
22300 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22301
22302 wxPyEndAllowThreads(__tstate);
22303 if (PyErr_Occurred()) SWIG_fail;
22304 }
22305 {
22306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22307 }
22308 return resultobj;
22309 fail:
22310 return NULL;
22311 }
22312
22313
22314 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22315 PyObject *resultobj;
22316 wxDateTime *arg1 = (wxDateTime *) 0 ;
22317 wxDateTime *arg2 = 0 ;
22318 bool result;
22319 PyObject * obj0 = 0 ;
22320 PyObject * obj1 = 0 ;
22321 char *kwnames[] = {
22322 (char *) "self",(char *) "dt", NULL
22323 };
22324
22325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22327 if (SWIG_arg_fail(1)) SWIG_fail;
22328 {
22329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22330 if (SWIG_arg_fail(2)) SWIG_fail;
22331 if (arg2 == NULL) {
22332 SWIG_null_ref("wxDateTime");
22333 }
22334 if (SWIG_arg_fail(2)) SWIG_fail;
22335 }
22336 {
22337 PyThreadState* __tstate = wxPyBeginAllowThreads();
22338 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22339
22340 wxPyEndAllowThreads(__tstate);
22341 if (PyErr_Occurred()) SWIG_fail;
22342 }
22343 {
22344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22345 }
22346 return resultobj;
22347 fail:
22348 return NULL;
22349 }
22350
22351
22352 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22353 PyObject *resultobj;
22354 wxDateTime *arg1 = (wxDateTime *) 0 ;
22355 wxDateTime *arg2 = 0 ;
22356 wxTimeSpan *arg3 = 0 ;
22357 bool result;
22358 PyObject * obj0 = 0 ;
22359 PyObject * obj1 = 0 ;
22360 PyObject * obj2 = 0 ;
22361 char *kwnames[] = {
22362 (char *) "self",(char *) "dt",(char *) "ts", NULL
22363 };
22364
22365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22367 if (SWIG_arg_fail(1)) SWIG_fail;
22368 {
22369 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22370 if (SWIG_arg_fail(2)) SWIG_fail;
22371 if (arg2 == NULL) {
22372 SWIG_null_ref("wxDateTime");
22373 }
22374 if (SWIG_arg_fail(2)) SWIG_fail;
22375 }
22376 {
22377 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22378 if (SWIG_arg_fail(3)) SWIG_fail;
22379 if (arg3 == NULL) {
22380 SWIG_null_ref("wxTimeSpan");
22381 }
22382 if (SWIG_arg_fail(3)) SWIG_fail;
22383 }
22384 {
22385 PyThreadState* __tstate = wxPyBeginAllowThreads();
22386 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22387
22388 wxPyEndAllowThreads(__tstate);
22389 if (PyErr_Occurred()) SWIG_fail;
22390 }
22391 {
22392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22393 }
22394 return resultobj;
22395 fail:
22396 return NULL;
22397 }
22398
22399
22400 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22401 PyObject *resultobj;
22402 wxDateTime *arg1 = (wxDateTime *) 0 ;
22403 wxTimeSpan *arg2 = 0 ;
22404 wxDateTime *result;
22405 PyObject * obj0 = 0 ;
22406 PyObject * obj1 = 0 ;
22407 char *kwnames[] = {
22408 (char *) "self",(char *) "diff", NULL
22409 };
22410
22411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22413 if (SWIG_arg_fail(1)) SWIG_fail;
22414 {
22415 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22416 if (SWIG_arg_fail(2)) SWIG_fail;
22417 if (arg2 == NULL) {
22418 SWIG_null_ref("wxTimeSpan");
22419 }
22420 if (SWIG_arg_fail(2)) SWIG_fail;
22421 }
22422 {
22423 PyThreadState* __tstate = wxPyBeginAllowThreads();
22424 {
22425 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22426 result = (wxDateTime *) &_result_ref;
22427 }
22428
22429 wxPyEndAllowThreads(__tstate);
22430 if (PyErr_Occurred()) SWIG_fail;
22431 }
22432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22433 return resultobj;
22434 fail:
22435 return NULL;
22436 }
22437
22438
22439 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22440 PyObject *resultobj;
22441 wxDateTime *arg1 = (wxDateTime *) 0 ;
22442 wxDateSpan *arg2 = 0 ;
22443 wxDateTime *result;
22444 PyObject * obj0 = 0 ;
22445 PyObject * obj1 = 0 ;
22446 char *kwnames[] = {
22447 (char *) "self",(char *) "diff", NULL
22448 };
22449
22450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22452 if (SWIG_arg_fail(1)) SWIG_fail;
22453 {
22454 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22455 if (SWIG_arg_fail(2)) SWIG_fail;
22456 if (arg2 == NULL) {
22457 SWIG_null_ref("wxDateSpan");
22458 }
22459 if (SWIG_arg_fail(2)) SWIG_fail;
22460 }
22461 {
22462 PyThreadState* __tstate = wxPyBeginAllowThreads();
22463 {
22464 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22465 result = (wxDateTime *) &_result_ref;
22466 }
22467
22468 wxPyEndAllowThreads(__tstate);
22469 if (PyErr_Occurred()) SWIG_fail;
22470 }
22471 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22472 return resultobj;
22473 fail:
22474 return NULL;
22475 }
22476
22477
22478 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22479 PyObject *resultobj;
22480 wxDateTime *arg1 = (wxDateTime *) 0 ;
22481 wxTimeSpan *arg2 = 0 ;
22482 wxDateTime *result;
22483 PyObject * obj0 = 0 ;
22484 PyObject * obj1 = 0 ;
22485 char *kwnames[] = {
22486 (char *) "self",(char *) "diff", NULL
22487 };
22488
22489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22491 if (SWIG_arg_fail(1)) SWIG_fail;
22492 {
22493 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22494 if (SWIG_arg_fail(2)) SWIG_fail;
22495 if (arg2 == NULL) {
22496 SWIG_null_ref("wxTimeSpan");
22497 }
22498 if (SWIG_arg_fail(2)) SWIG_fail;
22499 }
22500 {
22501 PyThreadState* __tstate = wxPyBeginAllowThreads();
22502 {
22503 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22504 result = (wxDateTime *) &_result_ref;
22505 }
22506
22507 wxPyEndAllowThreads(__tstate);
22508 if (PyErr_Occurred()) SWIG_fail;
22509 }
22510 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22511 return resultobj;
22512 fail:
22513 return NULL;
22514 }
22515
22516
22517 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22518 PyObject *resultobj;
22519 wxDateTime *arg1 = (wxDateTime *) 0 ;
22520 wxDateSpan *arg2 = 0 ;
22521 wxDateTime *result;
22522 PyObject * obj0 = 0 ;
22523 PyObject * obj1 = 0 ;
22524 char *kwnames[] = {
22525 (char *) "self",(char *) "diff", NULL
22526 };
22527
22528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22530 if (SWIG_arg_fail(1)) SWIG_fail;
22531 {
22532 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22533 if (SWIG_arg_fail(2)) SWIG_fail;
22534 if (arg2 == NULL) {
22535 SWIG_null_ref("wxDateSpan");
22536 }
22537 if (SWIG_arg_fail(2)) SWIG_fail;
22538 }
22539 {
22540 PyThreadState* __tstate = wxPyBeginAllowThreads();
22541 {
22542 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22543 result = (wxDateTime *) &_result_ref;
22544 }
22545
22546 wxPyEndAllowThreads(__tstate);
22547 if (PyErr_Occurred()) SWIG_fail;
22548 }
22549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22550 return resultobj;
22551 fail:
22552 return NULL;
22553 }
22554
22555
22556 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22557 PyObject *resultobj;
22558 wxDateTime *arg1 = (wxDateTime *) 0 ;
22559 wxDateTime *arg2 = 0 ;
22560 wxTimeSpan result;
22561 PyObject * obj0 = 0 ;
22562 PyObject * obj1 = 0 ;
22563 char *kwnames[] = {
22564 (char *) "self",(char *) "dt", NULL
22565 };
22566
22567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22569 if (SWIG_arg_fail(1)) SWIG_fail;
22570 {
22571 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22572 if (SWIG_arg_fail(2)) SWIG_fail;
22573 if (arg2 == NULL) {
22574 SWIG_null_ref("wxDateTime");
22575 }
22576 if (SWIG_arg_fail(2)) SWIG_fail;
22577 }
22578 {
22579 PyThreadState* __tstate = wxPyBeginAllowThreads();
22580 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22581
22582 wxPyEndAllowThreads(__tstate);
22583 if (PyErr_Occurred()) SWIG_fail;
22584 }
22585 {
22586 wxTimeSpan * resultptr;
22587 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22588 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22589 }
22590 return resultobj;
22591 fail:
22592 return NULL;
22593 }
22594
22595
22596 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22597 PyObject *resultobj;
22598 wxDateTime *arg1 = (wxDateTime *) 0 ;
22599 wxTimeSpan *arg2 = 0 ;
22600 wxDateTime *result;
22601 PyObject * obj0 = 0 ;
22602 PyObject * obj1 = 0 ;
22603
22604 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22606 if (SWIG_arg_fail(1)) SWIG_fail;
22607 {
22608 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22609 if (SWIG_arg_fail(2)) SWIG_fail;
22610 if (arg2 == NULL) {
22611 SWIG_null_ref("wxTimeSpan");
22612 }
22613 if (SWIG_arg_fail(2)) SWIG_fail;
22614 }
22615 {
22616 PyThreadState* __tstate = wxPyBeginAllowThreads();
22617 {
22618 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22619 result = (wxDateTime *) &_result_ref;
22620 }
22621
22622 wxPyEndAllowThreads(__tstate);
22623 if (PyErr_Occurred()) SWIG_fail;
22624 }
22625 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22626 return resultobj;
22627 fail:
22628 return NULL;
22629 }
22630
22631
22632 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22633 PyObject *resultobj;
22634 wxDateTime *arg1 = (wxDateTime *) 0 ;
22635 wxDateSpan *arg2 = 0 ;
22636 wxDateTime *result;
22637 PyObject * obj0 = 0 ;
22638 PyObject * obj1 = 0 ;
22639
22640 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22642 if (SWIG_arg_fail(1)) SWIG_fail;
22643 {
22644 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22645 if (SWIG_arg_fail(2)) SWIG_fail;
22646 if (arg2 == NULL) {
22647 SWIG_null_ref("wxDateSpan");
22648 }
22649 if (SWIG_arg_fail(2)) SWIG_fail;
22650 }
22651 {
22652 PyThreadState* __tstate = wxPyBeginAllowThreads();
22653 {
22654 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22655 result = (wxDateTime *) &_result_ref;
22656 }
22657
22658 wxPyEndAllowThreads(__tstate);
22659 if (PyErr_Occurred()) SWIG_fail;
22660 }
22661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22662 return resultobj;
22663 fail:
22664 return NULL;
22665 }
22666
22667
22668 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22669 int argc;
22670 PyObject *argv[3];
22671 int ii;
22672
22673 argc = PyObject_Length(args);
22674 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22675 argv[ii] = PyTuple_GetItem(args,ii);
22676 }
22677 if (argc == 2) {
22678 int _v;
22679 {
22680 void *ptr;
22681 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22682 _v = 0;
22683 PyErr_Clear();
22684 } else {
22685 _v = 1;
22686 }
22687 }
22688 if (_v) {
22689 {
22690 void *ptr = 0;
22691 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22692 _v = 0;
22693 PyErr_Clear();
22694 } else {
22695 _v = (ptr != 0);
22696 }
22697 }
22698 if (_v) {
22699 return _wrap_DateTime___iadd____SWIG_0(self,args);
22700 }
22701 }
22702 }
22703 if (argc == 2) {
22704 int _v;
22705 {
22706 void *ptr;
22707 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22708 _v = 0;
22709 PyErr_Clear();
22710 } else {
22711 _v = 1;
22712 }
22713 }
22714 if (_v) {
22715 {
22716 void *ptr = 0;
22717 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22718 _v = 0;
22719 PyErr_Clear();
22720 } else {
22721 _v = (ptr != 0);
22722 }
22723 }
22724 if (_v) {
22725 return _wrap_DateTime___iadd____SWIG_1(self,args);
22726 }
22727 }
22728 }
22729
22730 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22731 return NULL;
22732 }
22733
22734
22735 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22736 PyObject *resultobj;
22737 wxDateTime *arg1 = (wxDateTime *) 0 ;
22738 wxTimeSpan *arg2 = 0 ;
22739 wxDateTime *result;
22740 PyObject * obj0 = 0 ;
22741 PyObject * obj1 = 0 ;
22742
22743 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22745 if (SWIG_arg_fail(1)) SWIG_fail;
22746 {
22747 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22748 if (SWIG_arg_fail(2)) SWIG_fail;
22749 if (arg2 == NULL) {
22750 SWIG_null_ref("wxTimeSpan");
22751 }
22752 if (SWIG_arg_fail(2)) SWIG_fail;
22753 }
22754 {
22755 PyThreadState* __tstate = wxPyBeginAllowThreads();
22756 {
22757 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22758 result = (wxDateTime *) &_result_ref;
22759 }
22760
22761 wxPyEndAllowThreads(__tstate);
22762 if (PyErr_Occurred()) SWIG_fail;
22763 }
22764 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22765 return resultobj;
22766 fail:
22767 return NULL;
22768 }
22769
22770
22771 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22772 PyObject *resultobj;
22773 wxDateTime *arg1 = (wxDateTime *) 0 ;
22774 wxDateSpan *arg2 = 0 ;
22775 wxDateTime *result;
22776 PyObject * obj0 = 0 ;
22777 PyObject * obj1 = 0 ;
22778
22779 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22781 if (SWIG_arg_fail(1)) SWIG_fail;
22782 {
22783 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22784 if (SWIG_arg_fail(2)) SWIG_fail;
22785 if (arg2 == NULL) {
22786 SWIG_null_ref("wxDateSpan");
22787 }
22788 if (SWIG_arg_fail(2)) SWIG_fail;
22789 }
22790 {
22791 PyThreadState* __tstate = wxPyBeginAllowThreads();
22792 {
22793 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22794 result = (wxDateTime *) &_result_ref;
22795 }
22796
22797 wxPyEndAllowThreads(__tstate);
22798 if (PyErr_Occurred()) SWIG_fail;
22799 }
22800 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22801 return resultobj;
22802 fail:
22803 return NULL;
22804 }
22805
22806
22807 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22808 int argc;
22809 PyObject *argv[3];
22810 int ii;
22811
22812 argc = PyObject_Length(args);
22813 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22814 argv[ii] = PyTuple_GetItem(args,ii);
22815 }
22816 if (argc == 2) {
22817 int _v;
22818 {
22819 void *ptr;
22820 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22821 _v = 0;
22822 PyErr_Clear();
22823 } else {
22824 _v = 1;
22825 }
22826 }
22827 if (_v) {
22828 {
22829 void *ptr = 0;
22830 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22831 _v = 0;
22832 PyErr_Clear();
22833 } else {
22834 _v = (ptr != 0);
22835 }
22836 }
22837 if (_v) {
22838 return _wrap_DateTime___isub____SWIG_0(self,args);
22839 }
22840 }
22841 }
22842 if (argc == 2) {
22843 int _v;
22844 {
22845 void *ptr;
22846 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22847 _v = 0;
22848 PyErr_Clear();
22849 } else {
22850 _v = 1;
22851 }
22852 }
22853 if (_v) {
22854 {
22855 void *ptr = 0;
22856 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22857 _v = 0;
22858 PyErr_Clear();
22859 } else {
22860 _v = (ptr != 0);
22861 }
22862 }
22863 if (_v) {
22864 return _wrap_DateTime___isub____SWIG_1(self,args);
22865 }
22866 }
22867 }
22868
22869 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22870 return NULL;
22871 }
22872
22873
22874 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22875 PyObject *resultobj;
22876 wxDateTime *arg1 = (wxDateTime *) 0 ;
22877 wxTimeSpan *arg2 = 0 ;
22878 wxDateTime result;
22879 PyObject * obj0 = 0 ;
22880 PyObject * obj1 = 0 ;
22881
22882 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22884 if (SWIG_arg_fail(1)) SWIG_fail;
22885 {
22886 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22887 if (SWIG_arg_fail(2)) SWIG_fail;
22888 if (arg2 == NULL) {
22889 SWIG_null_ref("wxTimeSpan");
22890 }
22891 if (SWIG_arg_fail(2)) SWIG_fail;
22892 }
22893 {
22894 PyThreadState* __tstate = wxPyBeginAllowThreads();
22895 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22896
22897 wxPyEndAllowThreads(__tstate);
22898 if (PyErr_Occurred()) SWIG_fail;
22899 }
22900 {
22901 wxDateTime * resultptr;
22902 resultptr = new wxDateTime((wxDateTime &)(result));
22903 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22904 }
22905 return resultobj;
22906 fail:
22907 return NULL;
22908 }
22909
22910
22911 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22912 PyObject *resultobj;
22913 wxDateTime *arg1 = (wxDateTime *) 0 ;
22914 wxDateSpan *arg2 = 0 ;
22915 wxDateTime result;
22916 PyObject * obj0 = 0 ;
22917 PyObject * obj1 = 0 ;
22918
22919 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22921 if (SWIG_arg_fail(1)) SWIG_fail;
22922 {
22923 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22924 if (SWIG_arg_fail(2)) SWIG_fail;
22925 if (arg2 == NULL) {
22926 SWIG_null_ref("wxDateSpan");
22927 }
22928 if (SWIG_arg_fail(2)) SWIG_fail;
22929 }
22930 {
22931 PyThreadState* __tstate = wxPyBeginAllowThreads();
22932 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22933
22934 wxPyEndAllowThreads(__tstate);
22935 if (PyErr_Occurred()) SWIG_fail;
22936 }
22937 {
22938 wxDateTime * resultptr;
22939 resultptr = new wxDateTime((wxDateTime &)(result));
22940 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22941 }
22942 return resultobj;
22943 fail:
22944 return NULL;
22945 }
22946
22947
22948 static PyObject *_wrap_DateTime___add__(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___add____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___add____SWIG_1(self,args);
23006 }
23007 }
23008 }
23009
23010 Py_INCREF(Py_NotImplemented);
23011 return Py_NotImplemented;
23012 }
23013
23014
23015 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
23016 PyObject *resultobj;
23017 wxDateTime *arg1 = (wxDateTime *) 0 ;
23018 wxDateTime *arg2 = 0 ;
23019 wxTimeSpan result;
23020 PyObject * obj0 = 0 ;
23021 PyObject * obj1 = 0 ;
23022
23023 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&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_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23028 if (SWIG_arg_fail(2)) SWIG_fail;
23029 if (arg2 == NULL) {
23030 SWIG_null_ref("wxDateTime");
23031 }
23032 if (SWIG_arg_fail(2)) SWIG_fail;
23033 }
23034 {
23035 PyThreadState* __tstate = wxPyBeginAllowThreads();
23036 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
23037
23038 wxPyEndAllowThreads(__tstate);
23039 if (PyErr_Occurred()) SWIG_fail;
23040 }
23041 {
23042 wxTimeSpan * resultptr;
23043 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23044 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23045 }
23046 return resultobj;
23047 fail:
23048 return NULL;
23049 }
23050
23051
23052 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23053 PyObject *resultobj;
23054 wxDateTime *arg1 = (wxDateTime *) 0 ;
23055 wxTimeSpan *arg2 = 0 ;
23056 wxDateTime result;
23057 PyObject * obj0 = 0 ;
23058 PyObject * obj1 = 0 ;
23059
23060 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&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_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23065 if (SWIG_arg_fail(2)) SWIG_fail;
23066 if (arg2 == NULL) {
23067 SWIG_null_ref("wxTimeSpan");
23068 }
23069 if (SWIG_arg_fail(2)) SWIG_fail;
23070 }
23071 {
23072 PyThreadState* __tstate = wxPyBeginAllowThreads();
23073 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan 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___sub____SWIG_2(PyObject *, PyObject *args) {
23090 PyObject *resultobj;
23091 wxDateTime *arg1 = (wxDateTime *) 0 ;
23092 wxDateSpan *arg2 = 0 ;
23093 wxDateTime result;
23094 PyObject * obj0 = 0 ;
23095 PyObject * obj1 = 0 ;
23096
23097 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23099 if (SWIG_arg_fail(1)) SWIG_fail;
23100 {
23101 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23102 if (SWIG_arg_fail(2)) SWIG_fail;
23103 if (arg2 == NULL) {
23104 SWIG_null_ref("wxDateSpan");
23105 }
23106 if (SWIG_arg_fail(2)) SWIG_fail;
23107 }
23108 {
23109 PyThreadState* __tstate = wxPyBeginAllowThreads();
23110 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23111
23112 wxPyEndAllowThreads(__tstate);
23113 if (PyErr_Occurred()) SWIG_fail;
23114 }
23115 {
23116 wxDateTime * resultptr;
23117 resultptr = new wxDateTime((wxDateTime &)(result));
23118 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23119 }
23120 return resultobj;
23121 fail:
23122 return NULL;
23123 }
23124
23125
23126 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23127 int argc;
23128 PyObject *argv[3];
23129 int ii;
23130
23131 argc = PyObject_Length(args);
23132 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23133 argv[ii] = PyTuple_GetItem(args,ii);
23134 }
23135 if (argc == 2) {
23136 int _v;
23137 {
23138 void *ptr;
23139 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23140 _v = 0;
23141 PyErr_Clear();
23142 } else {
23143 _v = 1;
23144 }
23145 }
23146 if (_v) {
23147 {
23148 void *ptr = 0;
23149 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23150 _v = 0;
23151 PyErr_Clear();
23152 } else {
23153 _v = (ptr != 0);
23154 }
23155 }
23156 if (_v) {
23157 return _wrap_DateTime___sub____SWIG_0(self,args);
23158 }
23159 }
23160 }
23161 if (argc == 2) {
23162 int _v;
23163 {
23164 void *ptr;
23165 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23166 _v = 0;
23167 PyErr_Clear();
23168 } else {
23169 _v = 1;
23170 }
23171 }
23172 if (_v) {
23173 {
23174 void *ptr = 0;
23175 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23176 _v = 0;
23177 PyErr_Clear();
23178 } else {
23179 _v = (ptr != 0);
23180 }
23181 }
23182 if (_v) {
23183 return _wrap_DateTime___sub____SWIG_1(self,args);
23184 }
23185 }
23186 }
23187 if (argc == 2) {
23188 int _v;
23189 {
23190 void *ptr;
23191 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23192 _v = 0;
23193 PyErr_Clear();
23194 } else {
23195 _v = 1;
23196 }
23197 }
23198 if (_v) {
23199 {
23200 void *ptr = 0;
23201 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23202 _v = 0;
23203 PyErr_Clear();
23204 } else {
23205 _v = (ptr != 0);
23206 }
23207 }
23208 if (_v) {
23209 return _wrap_DateTime___sub____SWIG_2(self,args);
23210 }
23211 }
23212 }
23213
23214 Py_INCREF(Py_NotImplemented);
23215 return Py_NotImplemented;
23216 }
23217
23218
23219 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23220 PyObject *resultobj;
23221 wxDateTime *arg1 = (wxDateTime *) 0 ;
23222 wxDateTime *arg2 = (wxDateTime *) 0 ;
23223 bool result;
23224 PyObject * obj0 = 0 ;
23225 PyObject * obj1 = 0 ;
23226 char *kwnames[] = {
23227 (char *) "self",(char *) "other", NULL
23228 };
23229
23230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23232 if (SWIG_arg_fail(1)) SWIG_fail;
23233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23234 if (SWIG_arg_fail(2)) SWIG_fail;
23235 {
23236 PyThreadState* __tstate = wxPyBeginAllowThreads();
23237 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23238
23239 wxPyEndAllowThreads(__tstate);
23240 if (PyErr_Occurred()) SWIG_fail;
23241 }
23242 {
23243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23244 }
23245 return resultobj;
23246 fail:
23247 return NULL;
23248 }
23249
23250
23251 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23252 PyObject *resultobj;
23253 wxDateTime *arg1 = (wxDateTime *) 0 ;
23254 wxDateTime *arg2 = (wxDateTime *) 0 ;
23255 bool result;
23256 PyObject * obj0 = 0 ;
23257 PyObject * obj1 = 0 ;
23258 char *kwnames[] = {
23259 (char *) "self",(char *) "other", NULL
23260 };
23261
23262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23264 if (SWIG_arg_fail(1)) SWIG_fail;
23265 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23266 if (SWIG_arg_fail(2)) SWIG_fail;
23267 {
23268 PyThreadState* __tstate = wxPyBeginAllowThreads();
23269 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23270
23271 wxPyEndAllowThreads(__tstate);
23272 if (PyErr_Occurred()) SWIG_fail;
23273 }
23274 {
23275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23276 }
23277 return resultobj;
23278 fail:
23279 return NULL;
23280 }
23281
23282
23283 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23284 PyObject *resultobj;
23285 wxDateTime *arg1 = (wxDateTime *) 0 ;
23286 wxDateTime *arg2 = (wxDateTime *) 0 ;
23287 bool result;
23288 PyObject * obj0 = 0 ;
23289 PyObject * obj1 = 0 ;
23290 char *kwnames[] = {
23291 (char *) "self",(char *) "other", NULL
23292 };
23293
23294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23296 if (SWIG_arg_fail(1)) SWIG_fail;
23297 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23298 if (SWIG_arg_fail(2)) SWIG_fail;
23299 {
23300 PyThreadState* __tstate = wxPyBeginAllowThreads();
23301 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23302
23303 wxPyEndAllowThreads(__tstate);
23304 if (PyErr_Occurred()) SWIG_fail;
23305 }
23306 {
23307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23308 }
23309 return resultobj;
23310 fail:
23311 return NULL;
23312 }
23313
23314
23315 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23316 PyObject *resultobj;
23317 wxDateTime *arg1 = (wxDateTime *) 0 ;
23318 wxDateTime *arg2 = (wxDateTime *) 0 ;
23319 bool result;
23320 PyObject * obj0 = 0 ;
23321 PyObject * obj1 = 0 ;
23322 char *kwnames[] = {
23323 (char *) "self",(char *) "other", NULL
23324 };
23325
23326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23328 if (SWIG_arg_fail(1)) SWIG_fail;
23329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23330 if (SWIG_arg_fail(2)) SWIG_fail;
23331 {
23332 PyThreadState* __tstate = wxPyBeginAllowThreads();
23333 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23334
23335 wxPyEndAllowThreads(__tstate);
23336 if (PyErr_Occurred()) SWIG_fail;
23337 }
23338 {
23339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23340 }
23341 return resultobj;
23342 fail:
23343 return NULL;
23344 }
23345
23346
23347 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23348 PyObject *resultobj;
23349 wxDateTime *arg1 = (wxDateTime *) 0 ;
23350 wxDateTime *arg2 = (wxDateTime *) 0 ;
23351 bool result;
23352 PyObject * obj0 = 0 ;
23353 PyObject * obj1 = 0 ;
23354 char *kwnames[] = {
23355 (char *) "self",(char *) "other", NULL
23356 };
23357
23358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23360 if (SWIG_arg_fail(1)) SWIG_fail;
23361 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23362 if (SWIG_arg_fail(2)) SWIG_fail;
23363 {
23364 PyThreadState* __tstate = wxPyBeginAllowThreads();
23365 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23366
23367 wxPyEndAllowThreads(__tstate);
23368 if (PyErr_Occurred()) SWIG_fail;
23369 }
23370 {
23371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23372 }
23373 return resultobj;
23374 fail:
23375 return NULL;
23376 }
23377
23378
23379 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23380 PyObject *resultobj;
23381 wxDateTime *arg1 = (wxDateTime *) 0 ;
23382 wxDateTime *arg2 = (wxDateTime *) 0 ;
23383 bool result;
23384 PyObject * obj0 = 0 ;
23385 PyObject * obj1 = 0 ;
23386 char *kwnames[] = {
23387 (char *) "self",(char *) "other", NULL
23388 };
23389
23390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23392 if (SWIG_arg_fail(1)) SWIG_fail;
23393 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23394 if (SWIG_arg_fail(2)) SWIG_fail;
23395 {
23396 PyThreadState* __tstate = wxPyBeginAllowThreads();
23397 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23398
23399 wxPyEndAllowThreads(__tstate);
23400 if (PyErr_Occurred()) SWIG_fail;
23401 }
23402 {
23403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23404 }
23405 return resultobj;
23406 fail:
23407 return NULL;
23408 }
23409
23410
23411 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23412 PyObject *resultobj;
23413 wxDateTime *arg1 = (wxDateTime *) 0 ;
23414 wxString *arg2 = 0 ;
23415 int result;
23416 bool temp2 = false ;
23417 PyObject * obj0 = 0 ;
23418 PyObject * obj1 = 0 ;
23419 char *kwnames[] = {
23420 (char *) "self",(char *) "date", NULL
23421 };
23422
23423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23425 if (SWIG_arg_fail(1)) SWIG_fail;
23426 {
23427 arg2 = wxString_in_helper(obj1);
23428 if (arg2 == NULL) SWIG_fail;
23429 temp2 = true;
23430 }
23431 {
23432 PyThreadState* __tstate = wxPyBeginAllowThreads();
23433 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23434
23435 wxPyEndAllowThreads(__tstate);
23436 if (PyErr_Occurred()) SWIG_fail;
23437 }
23438 {
23439 resultobj = SWIG_From_int((int)(result));
23440 }
23441 {
23442 if (temp2)
23443 delete arg2;
23444 }
23445 return resultobj;
23446 fail:
23447 {
23448 if (temp2)
23449 delete arg2;
23450 }
23451 return NULL;
23452 }
23453
23454
23455 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23456 PyObject *resultobj;
23457 wxDateTime *arg1 = (wxDateTime *) 0 ;
23458 wxString *arg2 = 0 ;
23459 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23460 wxString *arg3 = (wxString *) &arg3_defvalue ;
23461 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23462 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23463 int result;
23464 bool temp2 = false ;
23465 bool temp3 = false ;
23466 PyObject * obj0 = 0 ;
23467 PyObject * obj1 = 0 ;
23468 PyObject * obj2 = 0 ;
23469 PyObject * obj3 = 0 ;
23470 char *kwnames[] = {
23471 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23472 };
23473
23474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23476 if (SWIG_arg_fail(1)) SWIG_fail;
23477 {
23478 arg2 = wxString_in_helper(obj1);
23479 if (arg2 == NULL) SWIG_fail;
23480 temp2 = true;
23481 }
23482 if (obj2) {
23483 {
23484 arg3 = wxString_in_helper(obj2);
23485 if (arg3 == NULL) SWIG_fail;
23486 temp3 = true;
23487 }
23488 }
23489 if (obj3) {
23490 {
23491 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23492 if (SWIG_arg_fail(4)) SWIG_fail;
23493 if (arg4 == NULL) {
23494 SWIG_null_ref("wxDateTime");
23495 }
23496 if (SWIG_arg_fail(4)) SWIG_fail;
23497 }
23498 }
23499 {
23500 PyThreadState* __tstate = wxPyBeginAllowThreads();
23501 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23502
23503 wxPyEndAllowThreads(__tstate);
23504 if (PyErr_Occurred()) SWIG_fail;
23505 }
23506 {
23507 resultobj = SWIG_From_int((int)(result));
23508 }
23509 {
23510 if (temp2)
23511 delete arg2;
23512 }
23513 {
23514 if (temp3)
23515 delete arg3;
23516 }
23517 return resultobj;
23518 fail:
23519 {
23520 if (temp2)
23521 delete arg2;
23522 }
23523 {
23524 if (temp3)
23525 delete arg3;
23526 }
23527 return NULL;
23528 }
23529
23530
23531 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23532 PyObject *resultobj;
23533 wxDateTime *arg1 = (wxDateTime *) 0 ;
23534 wxString *arg2 = 0 ;
23535 int result;
23536 bool temp2 = false ;
23537 PyObject * obj0 = 0 ;
23538 PyObject * obj1 = 0 ;
23539 char *kwnames[] = {
23540 (char *) "self",(char *) "datetime", NULL
23541 };
23542
23543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23545 if (SWIG_arg_fail(1)) SWIG_fail;
23546 {
23547 arg2 = wxString_in_helper(obj1);
23548 if (arg2 == NULL) SWIG_fail;
23549 temp2 = true;
23550 }
23551 {
23552 PyThreadState* __tstate = wxPyBeginAllowThreads();
23553 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23554
23555 wxPyEndAllowThreads(__tstate);
23556 if (PyErr_Occurred()) SWIG_fail;
23557 }
23558 {
23559 resultobj = SWIG_From_int((int)(result));
23560 }
23561 {
23562 if (temp2)
23563 delete arg2;
23564 }
23565 return resultobj;
23566 fail:
23567 {
23568 if (temp2)
23569 delete arg2;
23570 }
23571 return NULL;
23572 }
23573
23574
23575 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23576 PyObject *resultobj;
23577 wxDateTime *arg1 = (wxDateTime *) 0 ;
23578 wxString *arg2 = 0 ;
23579 int result;
23580 bool temp2 = false ;
23581 PyObject * obj0 = 0 ;
23582 PyObject * obj1 = 0 ;
23583 char *kwnames[] = {
23584 (char *) "self",(char *) "date", NULL
23585 };
23586
23587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23589 if (SWIG_arg_fail(1)) SWIG_fail;
23590 {
23591 arg2 = wxString_in_helper(obj1);
23592 if (arg2 == NULL) SWIG_fail;
23593 temp2 = true;
23594 }
23595 {
23596 PyThreadState* __tstate = wxPyBeginAllowThreads();
23597 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23598
23599 wxPyEndAllowThreads(__tstate);
23600 if (PyErr_Occurred()) SWIG_fail;
23601 }
23602 {
23603 resultobj = SWIG_From_int((int)(result));
23604 }
23605 {
23606 if (temp2)
23607 delete arg2;
23608 }
23609 return resultobj;
23610 fail:
23611 {
23612 if (temp2)
23613 delete arg2;
23614 }
23615 return NULL;
23616 }
23617
23618
23619 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23620 PyObject *resultobj;
23621 wxDateTime *arg1 = (wxDateTime *) 0 ;
23622 wxString *arg2 = 0 ;
23623 int result;
23624 bool temp2 = false ;
23625 PyObject * obj0 = 0 ;
23626 PyObject * obj1 = 0 ;
23627 char *kwnames[] = {
23628 (char *) "self",(char *) "time", NULL
23629 };
23630
23631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23633 if (SWIG_arg_fail(1)) SWIG_fail;
23634 {
23635 arg2 = wxString_in_helper(obj1);
23636 if (arg2 == NULL) SWIG_fail;
23637 temp2 = true;
23638 }
23639 {
23640 PyThreadState* __tstate = wxPyBeginAllowThreads();
23641 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23642
23643 wxPyEndAllowThreads(__tstate);
23644 if (PyErr_Occurred()) SWIG_fail;
23645 }
23646 {
23647 resultobj = SWIG_From_int((int)(result));
23648 }
23649 {
23650 if (temp2)
23651 delete arg2;
23652 }
23653 return resultobj;
23654 fail:
23655 {
23656 if (temp2)
23657 delete arg2;
23658 }
23659 return NULL;
23660 }
23661
23662
23663 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23664 PyObject *resultobj;
23665 wxDateTime *arg1 = (wxDateTime *) 0 ;
23666 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23667 wxString *arg2 = (wxString *) &arg2_defvalue ;
23668 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23669 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23670 wxString result;
23671 bool temp2 = false ;
23672 bool temp3 = false ;
23673 PyObject * obj0 = 0 ;
23674 PyObject * obj1 = 0 ;
23675 PyObject * obj2 = 0 ;
23676 char *kwnames[] = {
23677 (char *) "self",(char *) "format",(char *) "tz", NULL
23678 };
23679
23680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23682 if (SWIG_arg_fail(1)) SWIG_fail;
23683 if (obj1) {
23684 {
23685 arg2 = wxString_in_helper(obj1);
23686 if (arg2 == NULL) SWIG_fail;
23687 temp2 = true;
23688 }
23689 }
23690 if (obj2) {
23691 {
23692 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23693 temp3 = true;
23694 }
23695 }
23696 {
23697 PyThreadState* __tstate = wxPyBeginAllowThreads();
23698 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23699
23700 wxPyEndAllowThreads(__tstate);
23701 if (PyErr_Occurred()) SWIG_fail;
23702 }
23703 {
23704 #if wxUSE_UNICODE
23705 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23706 #else
23707 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23708 #endif
23709 }
23710 {
23711 if (temp2)
23712 delete arg2;
23713 }
23714 {
23715 if (temp3) delete arg3;
23716 }
23717 return resultobj;
23718 fail:
23719 {
23720 if (temp2)
23721 delete arg2;
23722 }
23723 {
23724 if (temp3) delete arg3;
23725 }
23726 return NULL;
23727 }
23728
23729
23730 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23731 PyObject *resultobj;
23732 wxDateTime *arg1 = (wxDateTime *) 0 ;
23733 wxString result;
23734 PyObject * obj0 = 0 ;
23735 char *kwnames[] = {
23736 (char *) "self", NULL
23737 };
23738
23739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23741 if (SWIG_arg_fail(1)) SWIG_fail;
23742 {
23743 PyThreadState* __tstate = wxPyBeginAllowThreads();
23744 result = ((wxDateTime const *)arg1)->FormatDate();
23745
23746 wxPyEndAllowThreads(__tstate);
23747 if (PyErr_Occurred()) SWIG_fail;
23748 }
23749 {
23750 #if wxUSE_UNICODE
23751 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23752 #else
23753 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23754 #endif
23755 }
23756 return resultobj;
23757 fail:
23758 return NULL;
23759 }
23760
23761
23762 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23763 PyObject *resultobj;
23764 wxDateTime *arg1 = (wxDateTime *) 0 ;
23765 wxString result;
23766 PyObject * obj0 = 0 ;
23767 char *kwnames[] = {
23768 (char *) "self", NULL
23769 };
23770
23771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23773 if (SWIG_arg_fail(1)) SWIG_fail;
23774 {
23775 PyThreadState* __tstate = wxPyBeginAllowThreads();
23776 result = ((wxDateTime const *)arg1)->FormatTime();
23777
23778 wxPyEndAllowThreads(__tstate);
23779 if (PyErr_Occurred()) SWIG_fail;
23780 }
23781 {
23782 #if wxUSE_UNICODE
23783 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23784 #else
23785 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23786 #endif
23787 }
23788 return resultobj;
23789 fail:
23790 return NULL;
23791 }
23792
23793
23794 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23795 PyObject *resultobj;
23796 wxDateTime *arg1 = (wxDateTime *) 0 ;
23797 wxString result;
23798 PyObject * obj0 = 0 ;
23799 char *kwnames[] = {
23800 (char *) "self", NULL
23801 };
23802
23803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23805 if (SWIG_arg_fail(1)) SWIG_fail;
23806 {
23807 PyThreadState* __tstate = wxPyBeginAllowThreads();
23808 result = ((wxDateTime const *)arg1)->FormatISODate();
23809
23810 wxPyEndAllowThreads(__tstate);
23811 if (PyErr_Occurred()) SWIG_fail;
23812 }
23813 {
23814 #if wxUSE_UNICODE
23815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23816 #else
23817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23818 #endif
23819 }
23820 return resultobj;
23821 fail:
23822 return NULL;
23823 }
23824
23825
23826 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23827 PyObject *resultobj;
23828 wxDateTime *arg1 = (wxDateTime *) 0 ;
23829 wxString result;
23830 PyObject * obj0 = 0 ;
23831 char *kwnames[] = {
23832 (char *) "self", NULL
23833 };
23834
23835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23837 if (SWIG_arg_fail(1)) SWIG_fail;
23838 {
23839 PyThreadState* __tstate = wxPyBeginAllowThreads();
23840 result = ((wxDateTime const *)arg1)->FormatISOTime();
23841
23842 wxPyEndAllowThreads(__tstate);
23843 if (PyErr_Occurred()) SWIG_fail;
23844 }
23845 {
23846 #if wxUSE_UNICODE
23847 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23848 #else
23849 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23850 #endif
23851 }
23852 return resultobj;
23853 fail:
23854 return NULL;
23855 }
23856
23857
23858 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23859 PyObject *obj;
23860 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23861 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23862 Py_INCREF(obj);
23863 return Py_BuildValue((char *)"");
23864 }
23865 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23866 PyObject *resultobj;
23867 long arg1 ;
23868 wxTimeSpan result;
23869 PyObject * obj0 = 0 ;
23870 char *kwnames[] = {
23871 (char *) "sec", NULL
23872 };
23873
23874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23875 {
23876 arg1 = (long)(SWIG_As_long(obj0));
23877 if (SWIG_arg_fail(1)) SWIG_fail;
23878 }
23879 {
23880 PyThreadState* __tstate = wxPyBeginAllowThreads();
23881 result = wxTimeSpan::Seconds(arg1);
23882
23883 wxPyEndAllowThreads(__tstate);
23884 if (PyErr_Occurred()) SWIG_fail;
23885 }
23886 {
23887 wxTimeSpan * resultptr;
23888 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23889 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23890 }
23891 return resultobj;
23892 fail:
23893 return NULL;
23894 }
23895
23896
23897 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23898 PyObject *resultobj;
23899 wxTimeSpan result;
23900 char *kwnames[] = {
23901 NULL
23902 };
23903
23904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23905 {
23906 PyThreadState* __tstate = wxPyBeginAllowThreads();
23907 result = wxTimeSpan::Second();
23908
23909 wxPyEndAllowThreads(__tstate);
23910 if (PyErr_Occurred()) SWIG_fail;
23911 }
23912 {
23913 wxTimeSpan * resultptr;
23914 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23915 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23916 }
23917 return resultobj;
23918 fail:
23919 return NULL;
23920 }
23921
23922
23923 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23924 PyObject *resultobj;
23925 long arg1 ;
23926 wxTimeSpan result;
23927 PyObject * obj0 = 0 ;
23928 char *kwnames[] = {
23929 (char *) "min", NULL
23930 };
23931
23932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23933 {
23934 arg1 = (long)(SWIG_As_long(obj0));
23935 if (SWIG_arg_fail(1)) SWIG_fail;
23936 }
23937 {
23938 PyThreadState* __tstate = wxPyBeginAllowThreads();
23939 result = wxTimeSpan::Minutes(arg1);
23940
23941 wxPyEndAllowThreads(__tstate);
23942 if (PyErr_Occurred()) SWIG_fail;
23943 }
23944 {
23945 wxTimeSpan * resultptr;
23946 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23947 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23948 }
23949 return resultobj;
23950 fail:
23951 return NULL;
23952 }
23953
23954
23955 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23956 PyObject *resultobj;
23957 wxTimeSpan result;
23958 char *kwnames[] = {
23959 NULL
23960 };
23961
23962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23963 {
23964 PyThreadState* __tstate = wxPyBeginAllowThreads();
23965 result = wxTimeSpan::Minute();
23966
23967 wxPyEndAllowThreads(__tstate);
23968 if (PyErr_Occurred()) SWIG_fail;
23969 }
23970 {
23971 wxTimeSpan * resultptr;
23972 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23973 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23974 }
23975 return resultobj;
23976 fail:
23977 return NULL;
23978 }
23979
23980
23981 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23982 PyObject *resultobj;
23983 long arg1 ;
23984 wxTimeSpan result;
23985 PyObject * obj0 = 0 ;
23986 char *kwnames[] = {
23987 (char *) "hours", NULL
23988 };
23989
23990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23991 {
23992 arg1 = (long)(SWIG_As_long(obj0));
23993 if (SWIG_arg_fail(1)) SWIG_fail;
23994 }
23995 {
23996 PyThreadState* __tstate = wxPyBeginAllowThreads();
23997 result = wxTimeSpan::Hours(arg1);
23998
23999 wxPyEndAllowThreads(__tstate);
24000 if (PyErr_Occurred()) SWIG_fail;
24001 }
24002 {
24003 wxTimeSpan * resultptr;
24004 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24005 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24006 }
24007 return resultobj;
24008 fail:
24009 return NULL;
24010 }
24011
24012
24013 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
24014 PyObject *resultobj;
24015 wxTimeSpan result;
24016 char *kwnames[] = {
24017 NULL
24018 };
24019
24020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
24021 {
24022 PyThreadState* __tstate = wxPyBeginAllowThreads();
24023 result = wxTimeSpan::Hour();
24024
24025 wxPyEndAllowThreads(__tstate);
24026 if (PyErr_Occurred()) SWIG_fail;
24027 }
24028 {
24029 wxTimeSpan * resultptr;
24030 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24031 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24032 }
24033 return resultobj;
24034 fail:
24035 return NULL;
24036 }
24037
24038
24039 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24040 PyObject *resultobj;
24041 long arg1 ;
24042 wxTimeSpan result;
24043 PyObject * obj0 = 0 ;
24044 char *kwnames[] = {
24045 (char *) "days", NULL
24046 };
24047
24048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24049 {
24050 arg1 = (long)(SWIG_As_long(obj0));
24051 if (SWIG_arg_fail(1)) SWIG_fail;
24052 }
24053 {
24054 PyThreadState* __tstate = wxPyBeginAllowThreads();
24055 result = wxTimeSpan::Days(arg1);
24056
24057 wxPyEndAllowThreads(__tstate);
24058 if (PyErr_Occurred()) SWIG_fail;
24059 }
24060 {
24061 wxTimeSpan * resultptr;
24062 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24063 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24064 }
24065 return resultobj;
24066 fail:
24067 return NULL;
24068 }
24069
24070
24071 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24072 PyObject *resultobj;
24073 wxTimeSpan result;
24074 char *kwnames[] = {
24075 NULL
24076 };
24077
24078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24079 {
24080 PyThreadState* __tstate = wxPyBeginAllowThreads();
24081 result = wxTimeSpan::Day();
24082
24083 wxPyEndAllowThreads(__tstate);
24084 if (PyErr_Occurred()) SWIG_fail;
24085 }
24086 {
24087 wxTimeSpan * resultptr;
24088 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24089 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24090 }
24091 return resultobj;
24092 fail:
24093 return NULL;
24094 }
24095
24096
24097 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24098 PyObject *resultobj;
24099 long arg1 ;
24100 wxTimeSpan result;
24101 PyObject * obj0 = 0 ;
24102 char *kwnames[] = {
24103 (char *) "days", NULL
24104 };
24105
24106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24107 {
24108 arg1 = (long)(SWIG_As_long(obj0));
24109 if (SWIG_arg_fail(1)) SWIG_fail;
24110 }
24111 {
24112 PyThreadState* __tstate = wxPyBeginAllowThreads();
24113 result = wxTimeSpan::Weeks(arg1);
24114
24115 wxPyEndAllowThreads(__tstate);
24116 if (PyErr_Occurred()) SWIG_fail;
24117 }
24118 {
24119 wxTimeSpan * resultptr;
24120 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24121 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24122 }
24123 return resultobj;
24124 fail:
24125 return NULL;
24126 }
24127
24128
24129 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24130 PyObject *resultobj;
24131 wxTimeSpan result;
24132 char *kwnames[] = {
24133 NULL
24134 };
24135
24136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24137 {
24138 PyThreadState* __tstate = wxPyBeginAllowThreads();
24139 result = wxTimeSpan::Week();
24140
24141 wxPyEndAllowThreads(__tstate);
24142 if (PyErr_Occurred()) SWIG_fail;
24143 }
24144 {
24145 wxTimeSpan * resultptr;
24146 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24147 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24148 }
24149 return resultobj;
24150 fail:
24151 return NULL;
24152 }
24153
24154
24155 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24156 PyObject *resultobj;
24157 long arg1 = (long) 0 ;
24158 long arg2 = (long) 0 ;
24159 long arg3 = (long) 0 ;
24160 long arg4 = (long) 0 ;
24161 wxTimeSpan *result;
24162 PyObject * obj0 = 0 ;
24163 PyObject * obj1 = 0 ;
24164 PyObject * obj2 = 0 ;
24165 PyObject * obj3 = 0 ;
24166 char *kwnames[] = {
24167 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24168 };
24169
24170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24171 if (obj0) {
24172 {
24173 arg1 = (long)(SWIG_As_long(obj0));
24174 if (SWIG_arg_fail(1)) SWIG_fail;
24175 }
24176 }
24177 if (obj1) {
24178 {
24179 arg2 = (long)(SWIG_As_long(obj1));
24180 if (SWIG_arg_fail(2)) SWIG_fail;
24181 }
24182 }
24183 if (obj2) {
24184 {
24185 arg3 = (long)(SWIG_As_long(obj2));
24186 if (SWIG_arg_fail(3)) SWIG_fail;
24187 }
24188 }
24189 if (obj3) {
24190 {
24191 arg4 = (long)(SWIG_As_long(obj3));
24192 if (SWIG_arg_fail(4)) SWIG_fail;
24193 }
24194 }
24195 {
24196 PyThreadState* __tstate = wxPyBeginAllowThreads();
24197 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24198
24199 wxPyEndAllowThreads(__tstate);
24200 if (PyErr_Occurred()) SWIG_fail;
24201 }
24202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24203 return resultobj;
24204 fail:
24205 return NULL;
24206 }
24207
24208
24209 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24210 PyObject *resultobj;
24211 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24212 PyObject * obj0 = 0 ;
24213 char *kwnames[] = {
24214 (char *) "self", NULL
24215 };
24216
24217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24219 if (SWIG_arg_fail(1)) SWIG_fail;
24220 {
24221 PyThreadState* __tstate = wxPyBeginAllowThreads();
24222 delete arg1;
24223
24224 wxPyEndAllowThreads(__tstate);
24225 if (PyErr_Occurred()) SWIG_fail;
24226 }
24227 Py_INCREF(Py_None); resultobj = Py_None;
24228 return resultobj;
24229 fail:
24230 return NULL;
24231 }
24232
24233
24234 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24235 PyObject *resultobj;
24236 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24237 wxTimeSpan *arg2 = 0 ;
24238 wxTimeSpan *result;
24239 PyObject * obj0 = 0 ;
24240 PyObject * obj1 = 0 ;
24241 char *kwnames[] = {
24242 (char *) "self",(char *) "diff", NULL
24243 };
24244
24245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24247 if (SWIG_arg_fail(1)) SWIG_fail;
24248 {
24249 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24250 if (SWIG_arg_fail(2)) SWIG_fail;
24251 if (arg2 == NULL) {
24252 SWIG_null_ref("wxTimeSpan");
24253 }
24254 if (SWIG_arg_fail(2)) SWIG_fail;
24255 }
24256 {
24257 PyThreadState* __tstate = wxPyBeginAllowThreads();
24258 {
24259 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24260 result = (wxTimeSpan *) &_result_ref;
24261 }
24262
24263 wxPyEndAllowThreads(__tstate);
24264 if (PyErr_Occurred()) SWIG_fail;
24265 }
24266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24267 return resultobj;
24268 fail:
24269 return NULL;
24270 }
24271
24272
24273 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24274 PyObject *resultobj;
24275 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24276 wxTimeSpan *arg2 = 0 ;
24277 wxTimeSpan *result;
24278 PyObject * obj0 = 0 ;
24279 PyObject * obj1 = 0 ;
24280 char *kwnames[] = {
24281 (char *) "self",(char *) "diff", NULL
24282 };
24283
24284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24286 if (SWIG_arg_fail(1)) SWIG_fail;
24287 {
24288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24289 if (SWIG_arg_fail(2)) SWIG_fail;
24290 if (arg2 == NULL) {
24291 SWIG_null_ref("wxTimeSpan");
24292 }
24293 if (SWIG_arg_fail(2)) SWIG_fail;
24294 }
24295 {
24296 PyThreadState* __tstate = wxPyBeginAllowThreads();
24297 {
24298 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24299 result = (wxTimeSpan *) &_result_ref;
24300 }
24301
24302 wxPyEndAllowThreads(__tstate);
24303 if (PyErr_Occurred()) SWIG_fail;
24304 }
24305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24306 return resultobj;
24307 fail:
24308 return NULL;
24309 }
24310
24311
24312 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24313 PyObject *resultobj;
24314 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24315 int arg2 ;
24316 wxTimeSpan *result;
24317 PyObject * obj0 = 0 ;
24318 PyObject * obj1 = 0 ;
24319 char *kwnames[] = {
24320 (char *) "self",(char *) "n", NULL
24321 };
24322
24323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24325 if (SWIG_arg_fail(1)) SWIG_fail;
24326 {
24327 arg2 = (int)(SWIG_As_int(obj1));
24328 if (SWIG_arg_fail(2)) SWIG_fail;
24329 }
24330 {
24331 PyThreadState* __tstate = wxPyBeginAllowThreads();
24332 {
24333 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24334 result = (wxTimeSpan *) &_result_ref;
24335 }
24336
24337 wxPyEndAllowThreads(__tstate);
24338 if (PyErr_Occurred()) SWIG_fail;
24339 }
24340 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24341 return resultobj;
24342 fail:
24343 return NULL;
24344 }
24345
24346
24347 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24348 PyObject *resultobj;
24349 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24350 wxTimeSpan *result;
24351 PyObject * obj0 = 0 ;
24352 char *kwnames[] = {
24353 (char *) "self", NULL
24354 };
24355
24356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24358 if (SWIG_arg_fail(1)) SWIG_fail;
24359 {
24360 PyThreadState* __tstate = wxPyBeginAllowThreads();
24361 {
24362 wxTimeSpan &_result_ref = (arg1)->Neg();
24363 result = (wxTimeSpan *) &_result_ref;
24364 }
24365
24366 wxPyEndAllowThreads(__tstate);
24367 if (PyErr_Occurred()) SWIG_fail;
24368 }
24369 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24370 return resultobj;
24371 fail:
24372 return NULL;
24373 }
24374
24375
24376 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24377 PyObject *resultobj;
24378 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24379 wxTimeSpan result;
24380 PyObject * obj0 = 0 ;
24381 char *kwnames[] = {
24382 (char *) "self", NULL
24383 };
24384
24385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24387 if (SWIG_arg_fail(1)) SWIG_fail;
24388 {
24389 PyThreadState* __tstate = wxPyBeginAllowThreads();
24390 result = ((wxTimeSpan const *)arg1)->Abs();
24391
24392 wxPyEndAllowThreads(__tstate);
24393 if (PyErr_Occurred()) SWIG_fail;
24394 }
24395 {
24396 wxTimeSpan * resultptr;
24397 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24398 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24399 }
24400 return resultobj;
24401 fail:
24402 return NULL;
24403 }
24404
24405
24406 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24407 PyObject *resultobj;
24408 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24409 wxTimeSpan *arg2 = 0 ;
24410 wxTimeSpan *result;
24411 PyObject * obj0 = 0 ;
24412 PyObject * obj1 = 0 ;
24413 char *kwnames[] = {
24414 (char *) "self",(char *) "diff", NULL
24415 };
24416
24417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24419 if (SWIG_arg_fail(1)) SWIG_fail;
24420 {
24421 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24422 if (SWIG_arg_fail(2)) SWIG_fail;
24423 if (arg2 == NULL) {
24424 SWIG_null_ref("wxTimeSpan");
24425 }
24426 if (SWIG_arg_fail(2)) SWIG_fail;
24427 }
24428 {
24429 PyThreadState* __tstate = wxPyBeginAllowThreads();
24430 {
24431 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24432 result = (wxTimeSpan *) &_result_ref;
24433 }
24434
24435 wxPyEndAllowThreads(__tstate);
24436 if (PyErr_Occurred()) SWIG_fail;
24437 }
24438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24439 return resultobj;
24440 fail:
24441 return NULL;
24442 }
24443
24444
24445 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24446 PyObject *resultobj;
24447 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24448 wxTimeSpan *arg2 = 0 ;
24449 wxTimeSpan *result;
24450 PyObject * obj0 = 0 ;
24451 PyObject * obj1 = 0 ;
24452 char *kwnames[] = {
24453 (char *) "self",(char *) "diff", NULL
24454 };
24455
24456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24458 if (SWIG_arg_fail(1)) SWIG_fail;
24459 {
24460 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24461 if (SWIG_arg_fail(2)) SWIG_fail;
24462 if (arg2 == NULL) {
24463 SWIG_null_ref("wxTimeSpan");
24464 }
24465 if (SWIG_arg_fail(2)) SWIG_fail;
24466 }
24467 {
24468 PyThreadState* __tstate = wxPyBeginAllowThreads();
24469 {
24470 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24471 result = (wxTimeSpan *) &_result_ref;
24472 }
24473
24474 wxPyEndAllowThreads(__tstate);
24475 if (PyErr_Occurred()) SWIG_fail;
24476 }
24477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24478 return resultobj;
24479 fail:
24480 return NULL;
24481 }
24482
24483
24484 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24485 PyObject *resultobj;
24486 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24487 int arg2 ;
24488 wxTimeSpan *result;
24489 PyObject * obj0 = 0 ;
24490 PyObject * obj1 = 0 ;
24491 char *kwnames[] = {
24492 (char *) "self",(char *) "n", NULL
24493 };
24494
24495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24497 if (SWIG_arg_fail(1)) SWIG_fail;
24498 {
24499 arg2 = (int)(SWIG_As_int(obj1));
24500 if (SWIG_arg_fail(2)) SWIG_fail;
24501 }
24502 {
24503 PyThreadState* __tstate = wxPyBeginAllowThreads();
24504 {
24505 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24506 result = (wxTimeSpan *) &_result_ref;
24507 }
24508
24509 wxPyEndAllowThreads(__tstate);
24510 if (PyErr_Occurred()) SWIG_fail;
24511 }
24512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24513 return resultobj;
24514 fail:
24515 return NULL;
24516 }
24517
24518
24519 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24520 PyObject *resultobj;
24521 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24522 wxTimeSpan *result;
24523 PyObject * obj0 = 0 ;
24524 char *kwnames[] = {
24525 (char *) "self", NULL
24526 };
24527
24528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24530 if (SWIG_arg_fail(1)) SWIG_fail;
24531 {
24532 PyThreadState* __tstate = wxPyBeginAllowThreads();
24533 {
24534 wxTimeSpan &_result_ref = (arg1)->operator -();
24535 result = (wxTimeSpan *) &_result_ref;
24536 }
24537
24538 wxPyEndAllowThreads(__tstate);
24539 if (PyErr_Occurred()) SWIG_fail;
24540 }
24541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24542 return resultobj;
24543 fail:
24544 return NULL;
24545 }
24546
24547
24548 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24549 PyObject *resultobj;
24550 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24551 wxTimeSpan *arg2 = 0 ;
24552 wxTimeSpan result;
24553 PyObject * obj0 = 0 ;
24554 PyObject * obj1 = 0 ;
24555 char *kwnames[] = {
24556 (char *) "self",(char *) "other", NULL
24557 };
24558
24559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24561 if (SWIG_arg_fail(1)) SWIG_fail;
24562 {
24563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24564 if (SWIG_arg_fail(2)) SWIG_fail;
24565 if (arg2 == NULL) {
24566 SWIG_null_ref("wxTimeSpan");
24567 }
24568 if (SWIG_arg_fail(2)) SWIG_fail;
24569 }
24570 {
24571 PyThreadState* __tstate = wxPyBeginAllowThreads();
24572 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24573
24574 wxPyEndAllowThreads(__tstate);
24575 if (PyErr_Occurred()) SWIG_fail;
24576 }
24577 {
24578 wxTimeSpan * resultptr;
24579 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24581 }
24582 return resultobj;
24583 fail:
24584 return NULL;
24585 }
24586
24587
24588 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24589 PyObject *resultobj;
24590 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24591 wxTimeSpan *arg2 = 0 ;
24592 wxTimeSpan result;
24593 PyObject * obj0 = 0 ;
24594 PyObject * obj1 = 0 ;
24595 char *kwnames[] = {
24596 (char *) "self",(char *) "other", NULL
24597 };
24598
24599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24601 if (SWIG_arg_fail(1)) SWIG_fail;
24602 {
24603 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24604 if (SWIG_arg_fail(2)) SWIG_fail;
24605 if (arg2 == NULL) {
24606 SWIG_null_ref("wxTimeSpan");
24607 }
24608 if (SWIG_arg_fail(2)) SWIG_fail;
24609 }
24610 {
24611 PyThreadState* __tstate = wxPyBeginAllowThreads();
24612 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24613
24614 wxPyEndAllowThreads(__tstate);
24615 if (PyErr_Occurred()) SWIG_fail;
24616 }
24617 {
24618 wxTimeSpan * resultptr;
24619 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24620 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24621 }
24622 return resultobj;
24623 fail:
24624 return NULL;
24625 }
24626
24627
24628 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24629 PyObject *resultobj;
24630 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24631 int arg2 ;
24632 wxTimeSpan result;
24633 PyObject * obj0 = 0 ;
24634 PyObject * obj1 = 0 ;
24635 char *kwnames[] = {
24636 (char *) "self",(char *) "n", NULL
24637 };
24638
24639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24641 if (SWIG_arg_fail(1)) SWIG_fail;
24642 {
24643 arg2 = (int)(SWIG_As_int(obj1));
24644 if (SWIG_arg_fail(2)) SWIG_fail;
24645 }
24646 {
24647 PyThreadState* __tstate = wxPyBeginAllowThreads();
24648 result = wxTimeSpan___mul__(arg1,arg2);
24649
24650 wxPyEndAllowThreads(__tstate);
24651 if (PyErr_Occurred()) SWIG_fail;
24652 }
24653 {
24654 wxTimeSpan * resultptr;
24655 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24656 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24657 }
24658 return resultobj;
24659 fail:
24660 return NULL;
24661 }
24662
24663
24664 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24665 PyObject *resultobj;
24666 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24667 int arg2 ;
24668 wxTimeSpan result;
24669 PyObject * obj0 = 0 ;
24670 PyObject * obj1 = 0 ;
24671 char *kwnames[] = {
24672 (char *) "self",(char *) "n", NULL
24673 };
24674
24675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24677 if (SWIG_arg_fail(1)) SWIG_fail;
24678 {
24679 arg2 = (int)(SWIG_As_int(obj1));
24680 if (SWIG_arg_fail(2)) SWIG_fail;
24681 }
24682 {
24683 PyThreadState* __tstate = wxPyBeginAllowThreads();
24684 result = wxTimeSpan___rmul__(arg1,arg2);
24685
24686 wxPyEndAllowThreads(__tstate);
24687 if (PyErr_Occurred()) SWIG_fail;
24688 }
24689 {
24690 wxTimeSpan * resultptr;
24691 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24692 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24693 }
24694 return resultobj;
24695 fail:
24696 return NULL;
24697 }
24698
24699
24700 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24701 PyObject *resultobj;
24702 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24703 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24704 bool result;
24705 PyObject * obj0 = 0 ;
24706 PyObject * obj1 = 0 ;
24707 char *kwnames[] = {
24708 (char *) "self",(char *) "other", NULL
24709 };
24710
24711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24713 if (SWIG_arg_fail(1)) SWIG_fail;
24714 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24715 if (SWIG_arg_fail(2)) SWIG_fail;
24716 {
24717 PyThreadState* __tstate = wxPyBeginAllowThreads();
24718 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24719
24720 wxPyEndAllowThreads(__tstate);
24721 if (PyErr_Occurred()) SWIG_fail;
24722 }
24723 {
24724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24725 }
24726 return resultobj;
24727 fail:
24728 return NULL;
24729 }
24730
24731
24732 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24733 PyObject *resultobj;
24734 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24735 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24736 bool result;
24737 PyObject * obj0 = 0 ;
24738 PyObject * obj1 = 0 ;
24739 char *kwnames[] = {
24740 (char *) "self",(char *) "other", NULL
24741 };
24742
24743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24745 if (SWIG_arg_fail(1)) SWIG_fail;
24746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24747 if (SWIG_arg_fail(2)) SWIG_fail;
24748 {
24749 PyThreadState* __tstate = wxPyBeginAllowThreads();
24750 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24751
24752 wxPyEndAllowThreads(__tstate);
24753 if (PyErr_Occurred()) SWIG_fail;
24754 }
24755 {
24756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24757 }
24758 return resultobj;
24759 fail:
24760 return NULL;
24761 }
24762
24763
24764 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24765 PyObject *resultobj;
24766 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24767 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24768 bool result;
24769 PyObject * obj0 = 0 ;
24770 PyObject * obj1 = 0 ;
24771 char *kwnames[] = {
24772 (char *) "self",(char *) "other", NULL
24773 };
24774
24775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24777 if (SWIG_arg_fail(1)) SWIG_fail;
24778 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24779 if (SWIG_arg_fail(2)) SWIG_fail;
24780 {
24781 PyThreadState* __tstate = wxPyBeginAllowThreads();
24782 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24783
24784 wxPyEndAllowThreads(__tstate);
24785 if (PyErr_Occurred()) SWIG_fail;
24786 }
24787 {
24788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24789 }
24790 return resultobj;
24791 fail:
24792 return NULL;
24793 }
24794
24795
24796 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24797 PyObject *resultobj;
24798 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24799 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24800 bool result;
24801 PyObject * obj0 = 0 ;
24802 PyObject * obj1 = 0 ;
24803 char *kwnames[] = {
24804 (char *) "self",(char *) "other", NULL
24805 };
24806
24807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24809 if (SWIG_arg_fail(1)) SWIG_fail;
24810 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24811 if (SWIG_arg_fail(2)) SWIG_fail;
24812 {
24813 PyThreadState* __tstate = wxPyBeginAllowThreads();
24814 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24815
24816 wxPyEndAllowThreads(__tstate);
24817 if (PyErr_Occurred()) SWIG_fail;
24818 }
24819 {
24820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24821 }
24822 return resultobj;
24823 fail:
24824 return NULL;
24825 }
24826
24827
24828 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24829 PyObject *resultobj;
24830 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24831 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24832 bool result;
24833 PyObject * obj0 = 0 ;
24834 PyObject * obj1 = 0 ;
24835 char *kwnames[] = {
24836 (char *) "self",(char *) "other", NULL
24837 };
24838
24839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24841 if (SWIG_arg_fail(1)) SWIG_fail;
24842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24843 if (SWIG_arg_fail(2)) SWIG_fail;
24844 {
24845 PyThreadState* __tstate = wxPyBeginAllowThreads();
24846 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24847
24848 wxPyEndAllowThreads(__tstate);
24849 if (PyErr_Occurred()) SWIG_fail;
24850 }
24851 {
24852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24853 }
24854 return resultobj;
24855 fail:
24856 return NULL;
24857 }
24858
24859
24860 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24861 PyObject *resultobj;
24862 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24863 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24864 bool result;
24865 PyObject * obj0 = 0 ;
24866 PyObject * obj1 = 0 ;
24867 char *kwnames[] = {
24868 (char *) "self",(char *) "other", NULL
24869 };
24870
24871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24873 if (SWIG_arg_fail(1)) SWIG_fail;
24874 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24875 if (SWIG_arg_fail(2)) SWIG_fail;
24876 {
24877 PyThreadState* __tstate = wxPyBeginAllowThreads();
24878 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24879
24880 wxPyEndAllowThreads(__tstate);
24881 if (PyErr_Occurred()) SWIG_fail;
24882 }
24883 {
24884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24885 }
24886 return resultobj;
24887 fail:
24888 return NULL;
24889 }
24890
24891
24892 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24893 PyObject *resultobj;
24894 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24895 bool result;
24896 PyObject * obj0 = 0 ;
24897 char *kwnames[] = {
24898 (char *) "self", NULL
24899 };
24900
24901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24903 if (SWIG_arg_fail(1)) SWIG_fail;
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24907
24908 wxPyEndAllowThreads(__tstate);
24909 if (PyErr_Occurred()) SWIG_fail;
24910 }
24911 {
24912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24913 }
24914 return resultobj;
24915 fail:
24916 return NULL;
24917 }
24918
24919
24920 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24921 PyObject *resultobj;
24922 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24923 bool result;
24924 PyObject * obj0 = 0 ;
24925 char *kwnames[] = {
24926 (char *) "self", NULL
24927 };
24928
24929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24931 if (SWIG_arg_fail(1)) SWIG_fail;
24932 {
24933 PyThreadState* __tstate = wxPyBeginAllowThreads();
24934 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24935
24936 wxPyEndAllowThreads(__tstate);
24937 if (PyErr_Occurred()) SWIG_fail;
24938 }
24939 {
24940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24941 }
24942 return resultobj;
24943 fail:
24944 return NULL;
24945 }
24946
24947
24948 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24949 PyObject *resultobj;
24950 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24951 bool result;
24952 PyObject * obj0 = 0 ;
24953 char *kwnames[] = {
24954 (char *) "self", NULL
24955 };
24956
24957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24959 if (SWIG_arg_fail(1)) SWIG_fail;
24960 {
24961 PyThreadState* __tstate = wxPyBeginAllowThreads();
24962 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24963
24964 wxPyEndAllowThreads(__tstate);
24965 if (PyErr_Occurred()) SWIG_fail;
24966 }
24967 {
24968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24969 }
24970 return resultobj;
24971 fail:
24972 return NULL;
24973 }
24974
24975
24976 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24977 PyObject *resultobj;
24978 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24979 wxTimeSpan *arg2 = 0 ;
24980 bool result;
24981 PyObject * obj0 = 0 ;
24982 PyObject * obj1 = 0 ;
24983 char *kwnames[] = {
24984 (char *) "self",(char *) "ts", NULL
24985 };
24986
24987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24989 if (SWIG_arg_fail(1)) SWIG_fail;
24990 {
24991 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24992 if (SWIG_arg_fail(2)) SWIG_fail;
24993 if (arg2 == NULL) {
24994 SWIG_null_ref("wxTimeSpan");
24995 }
24996 if (SWIG_arg_fail(2)) SWIG_fail;
24997 }
24998 {
24999 PyThreadState* __tstate = wxPyBeginAllowThreads();
25000 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
25001
25002 wxPyEndAllowThreads(__tstate);
25003 if (PyErr_Occurred()) SWIG_fail;
25004 }
25005 {
25006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25007 }
25008 return resultobj;
25009 fail:
25010 return NULL;
25011 }
25012
25013
25014 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
25015 PyObject *resultobj;
25016 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25017 wxTimeSpan *arg2 = 0 ;
25018 bool result;
25019 PyObject * obj0 = 0 ;
25020 PyObject * obj1 = 0 ;
25021 char *kwnames[] = {
25022 (char *) "self",(char *) "ts", NULL
25023 };
25024
25025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
25026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25027 if (SWIG_arg_fail(1)) SWIG_fail;
25028 {
25029 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25030 if (SWIG_arg_fail(2)) SWIG_fail;
25031 if (arg2 == NULL) {
25032 SWIG_null_ref("wxTimeSpan");
25033 }
25034 if (SWIG_arg_fail(2)) SWIG_fail;
25035 }
25036 {
25037 PyThreadState* __tstate = wxPyBeginAllowThreads();
25038 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
25039
25040 wxPyEndAllowThreads(__tstate);
25041 if (PyErr_Occurred()) SWIG_fail;
25042 }
25043 {
25044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25045 }
25046 return resultobj;
25047 fail:
25048 return NULL;
25049 }
25050
25051
25052 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25053 PyObject *resultobj;
25054 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25055 wxTimeSpan *arg2 = 0 ;
25056 bool result;
25057 PyObject * obj0 = 0 ;
25058 PyObject * obj1 = 0 ;
25059 char *kwnames[] = {
25060 (char *) "self",(char *) "t", NULL
25061 };
25062
25063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25065 if (SWIG_arg_fail(1)) SWIG_fail;
25066 {
25067 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25068 if (SWIG_arg_fail(2)) SWIG_fail;
25069 if (arg2 == NULL) {
25070 SWIG_null_ref("wxTimeSpan");
25071 }
25072 if (SWIG_arg_fail(2)) SWIG_fail;
25073 }
25074 {
25075 PyThreadState* __tstate = wxPyBeginAllowThreads();
25076 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25077
25078 wxPyEndAllowThreads(__tstate);
25079 if (PyErr_Occurred()) SWIG_fail;
25080 }
25081 {
25082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25083 }
25084 return resultobj;
25085 fail:
25086 return NULL;
25087 }
25088
25089
25090 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25091 PyObject *resultobj;
25092 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25093 int result;
25094 PyObject * obj0 = 0 ;
25095 char *kwnames[] = {
25096 (char *) "self", NULL
25097 };
25098
25099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25101 if (SWIG_arg_fail(1)) SWIG_fail;
25102 {
25103 PyThreadState* __tstate = wxPyBeginAllowThreads();
25104 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25105
25106 wxPyEndAllowThreads(__tstate);
25107 if (PyErr_Occurred()) SWIG_fail;
25108 }
25109 {
25110 resultobj = SWIG_From_int((int)(result));
25111 }
25112 return resultobj;
25113 fail:
25114 return NULL;
25115 }
25116
25117
25118 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25119 PyObject *resultobj;
25120 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25121 int result;
25122 PyObject * obj0 = 0 ;
25123 char *kwnames[] = {
25124 (char *) "self", NULL
25125 };
25126
25127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25129 if (SWIG_arg_fail(1)) SWIG_fail;
25130 {
25131 PyThreadState* __tstate = wxPyBeginAllowThreads();
25132 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25133
25134 wxPyEndAllowThreads(__tstate);
25135 if (PyErr_Occurred()) SWIG_fail;
25136 }
25137 {
25138 resultobj = SWIG_From_int((int)(result));
25139 }
25140 return resultobj;
25141 fail:
25142 return NULL;
25143 }
25144
25145
25146 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25147 PyObject *resultobj;
25148 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25149 int result;
25150 PyObject * obj0 = 0 ;
25151 char *kwnames[] = {
25152 (char *) "self", NULL
25153 };
25154
25155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25157 if (SWIG_arg_fail(1)) SWIG_fail;
25158 {
25159 PyThreadState* __tstate = wxPyBeginAllowThreads();
25160 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25161
25162 wxPyEndAllowThreads(__tstate);
25163 if (PyErr_Occurred()) SWIG_fail;
25164 }
25165 {
25166 resultobj = SWIG_From_int((int)(result));
25167 }
25168 return resultobj;
25169 fail:
25170 return NULL;
25171 }
25172
25173
25174 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25175 PyObject *resultobj;
25176 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25177 int result;
25178 PyObject * obj0 = 0 ;
25179 char *kwnames[] = {
25180 (char *) "self", NULL
25181 };
25182
25183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25185 if (SWIG_arg_fail(1)) SWIG_fail;
25186 {
25187 PyThreadState* __tstate = wxPyBeginAllowThreads();
25188 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25189
25190 wxPyEndAllowThreads(__tstate);
25191 if (PyErr_Occurred()) SWIG_fail;
25192 }
25193 {
25194 resultobj = SWIG_From_int((int)(result));
25195 }
25196 return resultobj;
25197 fail:
25198 return NULL;
25199 }
25200
25201
25202 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25203 PyObject *resultobj;
25204 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25205 wxLongLong result;
25206 PyObject * obj0 = 0 ;
25207 char *kwnames[] = {
25208 (char *) "self", NULL
25209 };
25210
25211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25213 if (SWIG_arg_fail(1)) SWIG_fail;
25214 {
25215 PyThreadState* __tstate = wxPyBeginAllowThreads();
25216 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25217
25218 wxPyEndAllowThreads(__tstate);
25219 if (PyErr_Occurred()) SWIG_fail;
25220 }
25221 {
25222 PyObject *hi, *lo, *shifter, *shifted;
25223 hi = PyLong_FromLong( (&result)->GetHi() );
25224 lo = PyLong_FromLong( (&result)->GetLo() );
25225 shifter = PyLong_FromLong(32);
25226 shifted = PyNumber_Lshift(hi, shifter);
25227 resultobj = PyNumber_Or(shifted, lo);
25228 Py_DECREF(hi);
25229 Py_DECREF(lo);
25230 Py_DECREF(shifter);
25231 Py_DECREF(shifted);
25232 }
25233 return resultobj;
25234 fail:
25235 return NULL;
25236 }
25237
25238
25239 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25240 PyObject *resultobj;
25241 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25242 wxLongLong result;
25243 PyObject * obj0 = 0 ;
25244 char *kwnames[] = {
25245 (char *) "self", NULL
25246 };
25247
25248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25250 if (SWIG_arg_fail(1)) SWIG_fail;
25251 {
25252 PyThreadState* __tstate = wxPyBeginAllowThreads();
25253 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25254
25255 wxPyEndAllowThreads(__tstate);
25256 if (PyErr_Occurred()) SWIG_fail;
25257 }
25258 {
25259 PyObject *hi, *lo, *shifter, *shifted;
25260 hi = PyLong_FromLong( (&result)->GetHi() );
25261 lo = PyLong_FromLong( (&result)->GetLo() );
25262 shifter = PyLong_FromLong(32);
25263 shifted = PyNumber_Lshift(hi, shifter);
25264 resultobj = PyNumber_Or(shifted, lo);
25265 Py_DECREF(hi);
25266 Py_DECREF(lo);
25267 Py_DECREF(shifter);
25268 Py_DECREF(shifted);
25269 }
25270 return resultobj;
25271 fail:
25272 return NULL;
25273 }
25274
25275
25276 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25277 PyObject *resultobj;
25278 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25279 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25280 wxString *arg2 = (wxString *) &arg2_defvalue ;
25281 wxString result;
25282 bool temp2 = false ;
25283 PyObject * obj0 = 0 ;
25284 PyObject * obj1 = 0 ;
25285 char *kwnames[] = {
25286 (char *) "self",(char *) "format", NULL
25287 };
25288
25289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25291 if (SWIG_arg_fail(1)) SWIG_fail;
25292 if (obj1) {
25293 {
25294 arg2 = wxString_in_helper(obj1);
25295 if (arg2 == NULL) SWIG_fail;
25296 temp2 = true;
25297 }
25298 }
25299 {
25300 PyThreadState* __tstate = wxPyBeginAllowThreads();
25301 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25302
25303 wxPyEndAllowThreads(__tstate);
25304 if (PyErr_Occurred()) SWIG_fail;
25305 }
25306 {
25307 #if wxUSE_UNICODE
25308 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25309 #else
25310 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25311 #endif
25312 }
25313 {
25314 if (temp2)
25315 delete arg2;
25316 }
25317 return resultobj;
25318 fail:
25319 {
25320 if (temp2)
25321 delete arg2;
25322 }
25323 return NULL;
25324 }
25325
25326
25327 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25328 PyObject *obj;
25329 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25330 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25331 Py_INCREF(obj);
25332 return Py_BuildValue((char *)"");
25333 }
25334 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25335 PyObject *resultobj;
25336 int arg1 = (int) 0 ;
25337 int arg2 = (int) 0 ;
25338 int arg3 = (int) 0 ;
25339 int arg4 = (int) 0 ;
25340 wxDateSpan *result;
25341 PyObject * obj0 = 0 ;
25342 PyObject * obj1 = 0 ;
25343 PyObject * obj2 = 0 ;
25344 PyObject * obj3 = 0 ;
25345 char *kwnames[] = {
25346 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25347 };
25348
25349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25350 if (obj0) {
25351 {
25352 arg1 = (int)(SWIG_As_int(obj0));
25353 if (SWIG_arg_fail(1)) SWIG_fail;
25354 }
25355 }
25356 if (obj1) {
25357 {
25358 arg2 = (int)(SWIG_As_int(obj1));
25359 if (SWIG_arg_fail(2)) SWIG_fail;
25360 }
25361 }
25362 if (obj2) {
25363 {
25364 arg3 = (int)(SWIG_As_int(obj2));
25365 if (SWIG_arg_fail(3)) SWIG_fail;
25366 }
25367 }
25368 if (obj3) {
25369 {
25370 arg4 = (int)(SWIG_As_int(obj3));
25371 if (SWIG_arg_fail(4)) SWIG_fail;
25372 }
25373 }
25374 {
25375 PyThreadState* __tstate = wxPyBeginAllowThreads();
25376 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25377
25378 wxPyEndAllowThreads(__tstate);
25379 if (PyErr_Occurred()) SWIG_fail;
25380 }
25381 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25382 return resultobj;
25383 fail:
25384 return NULL;
25385 }
25386
25387
25388 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25389 PyObject *resultobj;
25390 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25391 PyObject * obj0 = 0 ;
25392 char *kwnames[] = {
25393 (char *) "self", NULL
25394 };
25395
25396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25398 if (SWIG_arg_fail(1)) SWIG_fail;
25399 {
25400 PyThreadState* __tstate = wxPyBeginAllowThreads();
25401 delete arg1;
25402
25403 wxPyEndAllowThreads(__tstate);
25404 if (PyErr_Occurred()) SWIG_fail;
25405 }
25406 Py_INCREF(Py_None); resultobj = Py_None;
25407 return resultobj;
25408 fail:
25409 return NULL;
25410 }
25411
25412
25413 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25414 PyObject *resultobj;
25415 int arg1 ;
25416 wxDateSpan result;
25417 PyObject * obj0 = 0 ;
25418 char *kwnames[] = {
25419 (char *) "days", NULL
25420 };
25421
25422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25423 {
25424 arg1 = (int)(SWIG_As_int(obj0));
25425 if (SWIG_arg_fail(1)) SWIG_fail;
25426 }
25427 {
25428 PyThreadState* __tstate = wxPyBeginAllowThreads();
25429 result = wxDateSpan::Days(arg1);
25430
25431 wxPyEndAllowThreads(__tstate);
25432 if (PyErr_Occurred()) SWIG_fail;
25433 }
25434 {
25435 wxDateSpan * resultptr;
25436 resultptr = new wxDateSpan((wxDateSpan &)(result));
25437 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25438 }
25439 return resultobj;
25440 fail:
25441 return NULL;
25442 }
25443
25444
25445 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25446 PyObject *resultobj;
25447 wxDateSpan result;
25448 char *kwnames[] = {
25449 NULL
25450 };
25451
25452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25453 {
25454 PyThreadState* __tstate = wxPyBeginAllowThreads();
25455 result = wxDateSpan::Day();
25456
25457 wxPyEndAllowThreads(__tstate);
25458 if (PyErr_Occurred()) SWIG_fail;
25459 }
25460 {
25461 wxDateSpan * resultptr;
25462 resultptr = new wxDateSpan((wxDateSpan &)(result));
25463 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25464 }
25465 return resultobj;
25466 fail:
25467 return NULL;
25468 }
25469
25470
25471 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25472 PyObject *resultobj;
25473 int arg1 ;
25474 wxDateSpan result;
25475 PyObject * obj0 = 0 ;
25476 char *kwnames[] = {
25477 (char *) "weeks", NULL
25478 };
25479
25480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25481 {
25482 arg1 = (int)(SWIG_As_int(obj0));
25483 if (SWIG_arg_fail(1)) SWIG_fail;
25484 }
25485 {
25486 PyThreadState* __tstate = wxPyBeginAllowThreads();
25487 result = wxDateSpan::Weeks(arg1);
25488
25489 wxPyEndAllowThreads(__tstate);
25490 if (PyErr_Occurred()) SWIG_fail;
25491 }
25492 {
25493 wxDateSpan * resultptr;
25494 resultptr = new wxDateSpan((wxDateSpan &)(result));
25495 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25496 }
25497 return resultobj;
25498 fail:
25499 return NULL;
25500 }
25501
25502
25503 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25504 PyObject *resultobj;
25505 wxDateSpan result;
25506 char *kwnames[] = {
25507 NULL
25508 };
25509
25510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25511 {
25512 PyThreadState* __tstate = wxPyBeginAllowThreads();
25513 result = wxDateSpan::Week();
25514
25515 wxPyEndAllowThreads(__tstate);
25516 if (PyErr_Occurred()) SWIG_fail;
25517 }
25518 {
25519 wxDateSpan * resultptr;
25520 resultptr = new wxDateSpan((wxDateSpan &)(result));
25521 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25522 }
25523 return resultobj;
25524 fail:
25525 return NULL;
25526 }
25527
25528
25529 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25530 PyObject *resultobj;
25531 int arg1 ;
25532 wxDateSpan result;
25533 PyObject * obj0 = 0 ;
25534 char *kwnames[] = {
25535 (char *) "mon", NULL
25536 };
25537
25538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25539 {
25540 arg1 = (int)(SWIG_As_int(obj0));
25541 if (SWIG_arg_fail(1)) SWIG_fail;
25542 }
25543 {
25544 PyThreadState* __tstate = wxPyBeginAllowThreads();
25545 result = wxDateSpan::Months(arg1);
25546
25547 wxPyEndAllowThreads(__tstate);
25548 if (PyErr_Occurred()) SWIG_fail;
25549 }
25550 {
25551 wxDateSpan * resultptr;
25552 resultptr = new wxDateSpan((wxDateSpan &)(result));
25553 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25554 }
25555 return resultobj;
25556 fail:
25557 return NULL;
25558 }
25559
25560
25561 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25562 PyObject *resultobj;
25563 wxDateSpan result;
25564 char *kwnames[] = {
25565 NULL
25566 };
25567
25568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25569 {
25570 PyThreadState* __tstate = wxPyBeginAllowThreads();
25571 result = wxDateSpan::Month();
25572
25573 wxPyEndAllowThreads(__tstate);
25574 if (PyErr_Occurred()) SWIG_fail;
25575 }
25576 {
25577 wxDateSpan * resultptr;
25578 resultptr = new wxDateSpan((wxDateSpan &)(result));
25579 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25580 }
25581 return resultobj;
25582 fail:
25583 return NULL;
25584 }
25585
25586
25587 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25588 PyObject *resultobj;
25589 int arg1 ;
25590 wxDateSpan result;
25591 PyObject * obj0 = 0 ;
25592 char *kwnames[] = {
25593 (char *) "years", NULL
25594 };
25595
25596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25597 {
25598 arg1 = (int)(SWIG_As_int(obj0));
25599 if (SWIG_arg_fail(1)) SWIG_fail;
25600 }
25601 {
25602 PyThreadState* __tstate = wxPyBeginAllowThreads();
25603 result = wxDateSpan::Years(arg1);
25604
25605 wxPyEndAllowThreads(__tstate);
25606 if (PyErr_Occurred()) SWIG_fail;
25607 }
25608 {
25609 wxDateSpan * resultptr;
25610 resultptr = new wxDateSpan((wxDateSpan &)(result));
25611 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25612 }
25613 return resultobj;
25614 fail:
25615 return NULL;
25616 }
25617
25618
25619 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25620 PyObject *resultobj;
25621 wxDateSpan result;
25622 char *kwnames[] = {
25623 NULL
25624 };
25625
25626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25627 {
25628 PyThreadState* __tstate = wxPyBeginAllowThreads();
25629 result = wxDateSpan::Year();
25630
25631 wxPyEndAllowThreads(__tstate);
25632 if (PyErr_Occurred()) SWIG_fail;
25633 }
25634 {
25635 wxDateSpan * resultptr;
25636 resultptr = new wxDateSpan((wxDateSpan &)(result));
25637 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25638 }
25639 return resultobj;
25640 fail:
25641 return NULL;
25642 }
25643
25644
25645 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25646 PyObject *resultobj;
25647 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25648 int arg2 ;
25649 wxDateSpan *result;
25650 PyObject * obj0 = 0 ;
25651 PyObject * obj1 = 0 ;
25652 char *kwnames[] = {
25653 (char *) "self",(char *) "n", NULL
25654 };
25655
25656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25658 if (SWIG_arg_fail(1)) SWIG_fail;
25659 {
25660 arg2 = (int)(SWIG_As_int(obj1));
25661 if (SWIG_arg_fail(2)) SWIG_fail;
25662 }
25663 {
25664 PyThreadState* __tstate = wxPyBeginAllowThreads();
25665 {
25666 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25667 result = (wxDateSpan *) &_result_ref;
25668 }
25669
25670 wxPyEndAllowThreads(__tstate);
25671 if (PyErr_Occurred()) SWIG_fail;
25672 }
25673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25674 return resultobj;
25675 fail:
25676 return NULL;
25677 }
25678
25679
25680 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25681 PyObject *resultobj;
25682 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25683 int arg2 ;
25684 wxDateSpan *result;
25685 PyObject * obj0 = 0 ;
25686 PyObject * obj1 = 0 ;
25687 char *kwnames[] = {
25688 (char *) "self",(char *) "n", NULL
25689 };
25690
25691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25693 if (SWIG_arg_fail(1)) SWIG_fail;
25694 {
25695 arg2 = (int)(SWIG_As_int(obj1));
25696 if (SWIG_arg_fail(2)) SWIG_fail;
25697 }
25698 {
25699 PyThreadState* __tstate = wxPyBeginAllowThreads();
25700 {
25701 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25702 result = (wxDateSpan *) &_result_ref;
25703 }
25704
25705 wxPyEndAllowThreads(__tstate);
25706 if (PyErr_Occurred()) SWIG_fail;
25707 }
25708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25709 return resultobj;
25710 fail:
25711 return NULL;
25712 }
25713
25714
25715 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25716 PyObject *resultobj;
25717 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25718 int arg2 ;
25719 wxDateSpan *result;
25720 PyObject * obj0 = 0 ;
25721 PyObject * obj1 = 0 ;
25722 char *kwnames[] = {
25723 (char *) "self",(char *) "n", NULL
25724 };
25725
25726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25728 if (SWIG_arg_fail(1)) SWIG_fail;
25729 {
25730 arg2 = (int)(SWIG_As_int(obj1));
25731 if (SWIG_arg_fail(2)) SWIG_fail;
25732 }
25733 {
25734 PyThreadState* __tstate = wxPyBeginAllowThreads();
25735 {
25736 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25737 result = (wxDateSpan *) &_result_ref;
25738 }
25739
25740 wxPyEndAllowThreads(__tstate);
25741 if (PyErr_Occurred()) SWIG_fail;
25742 }
25743 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25744 return resultobj;
25745 fail:
25746 return NULL;
25747 }
25748
25749
25750 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25751 PyObject *resultobj;
25752 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25753 int arg2 ;
25754 wxDateSpan *result;
25755 PyObject * obj0 = 0 ;
25756 PyObject * obj1 = 0 ;
25757 char *kwnames[] = {
25758 (char *) "self",(char *) "n", NULL
25759 };
25760
25761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25763 if (SWIG_arg_fail(1)) SWIG_fail;
25764 {
25765 arg2 = (int)(SWIG_As_int(obj1));
25766 if (SWIG_arg_fail(2)) SWIG_fail;
25767 }
25768 {
25769 PyThreadState* __tstate = wxPyBeginAllowThreads();
25770 {
25771 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25772 result = (wxDateSpan *) &_result_ref;
25773 }
25774
25775 wxPyEndAllowThreads(__tstate);
25776 if (PyErr_Occurred()) SWIG_fail;
25777 }
25778 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25779 return resultobj;
25780 fail:
25781 return NULL;
25782 }
25783
25784
25785 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25786 PyObject *resultobj;
25787 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25788 int result;
25789 PyObject * obj0 = 0 ;
25790 char *kwnames[] = {
25791 (char *) "self", NULL
25792 };
25793
25794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25796 if (SWIG_arg_fail(1)) SWIG_fail;
25797 {
25798 PyThreadState* __tstate = wxPyBeginAllowThreads();
25799 result = (int)((wxDateSpan const *)arg1)->GetYears();
25800
25801 wxPyEndAllowThreads(__tstate);
25802 if (PyErr_Occurred()) SWIG_fail;
25803 }
25804 {
25805 resultobj = SWIG_From_int((int)(result));
25806 }
25807 return resultobj;
25808 fail:
25809 return NULL;
25810 }
25811
25812
25813 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25814 PyObject *resultobj;
25815 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25816 int result;
25817 PyObject * obj0 = 0 ;
25818 char *kwnames[] = {
25819 (char *) "self", NULL
25820 };
25821
25822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25824 if (SWIG_arg_fail(1)) SWIG_fail;
25825 {
25826 PyThreadState* __tstate = wxPyBeginAllowThreads();
25827 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25828
25829 wxPyEndAllowThreads(__tstate);
25830 if (PyErr_Occurred()) SWIG_fail;
25831 }
25832 {
25833 resultobj = SWIG_From_int((int)(result));
25834 }
25835 return resultobj;
25836 fail:
25837 return NULL;
25838 }
25839
25840
25841 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25842 PyObject *resultobj;
25843 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25844 int result;
25845 PyObject * obj0 = 0 ;
25846 char *kwnames[] = {
25847 (char *) "self", NULL
25848 };
25849
25850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25852 if (SWIG_arg_fail(1)) SWIG_fail;
25853 {
25854 PyThreadState* __tstate = wxPyBeginAllowThreads();
25855 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25856
25857 wxPyEndAllowThreads(__tstate);
25858 if (PyErr_Occurred()) SWIG_fail;
25859 }
25860 {
25861 resultobj = SWIG_From_int((int)(result));
25862 }
25863 return resultobj;
25864 fail:
25865 return NULL;
25866 }
25867
25868
25869 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25870 PyObject *resultobj;
25871 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25872 int result;
25873 PyObject * obj0 = 0 ;
25874 char *kwnames[] = {
25875 (char *) "self", NULL
25876 };
25877
25878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25880 if (SWIG_arg_fail(1)) SWIG_fail;
25881 {
25882 PyThreadState* __tstate = wxPyBeginAllowThreads();
25883 result = (int)((wxDateSpan const *)arg1)->GetDays();
25884
25885 wxPyEndAllowThreads(__tstate);
25886 if (PyErr_Occurred()) SWIG_fail;
25887 }
25888 {
25889 resultobj = SWIG_From_int((int)(result));
25890 }
25891 return resultobj;
25892 fail:
25893 return NULL;
25894 }
25895
25896
25897 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25898 PyObject *resultobj;
25899 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25900 int result;
25901 PyObject * obj0 = 0 ;
25902 char *kwnames[] = {
25903 (char *) "self", NULL
25904 };
25905
25906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25908 if (SWIG_arg_fail(1)) SWIG_fail;
25909 {
25910 PyThreadState* __tstate = wxPyBeginAllowThreads();
25911 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25912
25913 wxPyEndAllowThreads(__tstate);
25914 if (PyErr_Occurred()) SWIG_fail;
25915 }
25916 {
25917 resultobj = SWIG_From_int((int)(result));
25918 }
25919 return resultobj;
25920 fail:
25921 return NULL;
25922 }
25923
25924
25925 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25926 PyObject *resultobj;
25927 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25928 wxDateSpan *arg2 = 0 ;
25929 wxDateSpan *result;
25930 PyObject * obj0 = 0 ;
25931 PyObject * obj1 = 0 ;
25932 char *kwnames[] = {
25933 (char *) "self",(char *) "other", NULL
25934 };
25935
25936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25938 if (SWIG_arg_fail(1)) SWIG_fail;
25939 {
25940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25941 if (SWIG_arg_fail(2)) SWIG_fail;
25942 if (arg2 == NULL) {
25943 SWIG_null_ref("wxDateSpan");
25944 }
25945 if (SWIG_arg_fail(2)) SWIG_fail;
25946 }
25947 {
25948 PyThreadState* __tstate = wxPyBeginAllowThreads();
25949 {
25950 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25951 result = (wxDateSpan *) &_result_ref;
25952 }
25953
25954 wxPyEndAllowThreads(__tstate);
25955 if (PyErr_Occurred()) SWIG_fail;
25956 }
25957 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25958 return resultobj;
25959 fail:
25960 return NULL;
25961 }
25962
25963
25964 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25965 PyObject *resultobj;
25966 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25967 wxDateSpan *arg2 = 0 ;
25968 wxDateSpan *result;
25969 PyObject * obj0 = 0 ;
25970 PyObject * obj1 = 0 ;
25971 char *kwnames[] = {
25972 (char *) "self",(char *) "other", NULL
25973 };
25974
25975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25977 if (SWIG_arg_fail(1)) SWIG_fail;
25978 {
25979 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25980 if (SWIG_arg_fail(2)) SWIG_fail;
25981 if (arg2 == NULL) {
25982 SWIG_null_ref("wxDateSpan");
25983 }
25984 if (SWIG_arg_fail(2)) SWIG_fail;
25985 }
25986 {
25987 PyThreadState* __tstate = wxPyBeginAllowThreads();
25988 {
25989 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25990 result = (wxDateSpan *) &_result_ref;
25991 }
25992
25993 wxPyEndAllowThreads(__tstate);
25994 if (PyErr_Occurred()) SWIG_fail;
25995 }
25996 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25997 return resultobj;
25998 fail:
25999 return NULL;
26000 }
26001
26002
26003 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
26004 PyObject *resultobj;
26005 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26006 wxDateSpan *result;
26007 PyObject * obj0 = 0 ;
26008 char *kwnames[] = {
26009 (char *) "self", NULL
26010 };
26011
26012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
26013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26014 if (SWIG_arg_fail(1)) SWIG_fail;
26015 {
26016 PyThreadState* __tstate = wxPyBeginAllowThreads();
26017 {
26018 wxDateSpan &_result_ref = (arg1)->Neg();
26019 result = (wxDateSpan *) &_result_ref;
26020 }
26021
26022 wxPyEndAllowThreads(__tstate);
26023 if (PyErr_Occurred()) SWIG_fail;
26024 }
26025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26026 return resultobj;
26027 fail:
26028 return NULL;
26029 }
26030
26031
26032 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
26033 PyObject *resultobj;
26034 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26035 int arg2 ;
26036 wxDateSpan *result;
26037 PyObject * obj0 = 0 ;
26038 PyObject * obj1 = 0 ;
26039 char *kwnames[] = {
26040 (char *) "self",(char *) "factor", NULL
26041 };
26042
26043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
26044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26045 if (SWIG_arg_fail(1)) SWIG_fail;
26046 {
26047 arg2 = (int)(SWIG_As_int(obj1));
26048 if (SWIG_arg_fail(2)) SWIG_fail;
26049 }
26050 {
26051 PyThreadState* __tstate = wxPyBeginAllowThreads();
26052 {
26053 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26054 result = (wxDateSpan *) &_result_ref;
26055 }
26056
26057 wxPyEndAllowThreads(__tstate);
26058 if (PyErr_Occurred()) SWIG_fail;
26059 }
26060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26061 return resultobj;
26062 fail:
26063 return NULL;
26064 }
26065
26066
26067 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26068 PyObject *resultobj;
26069 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26070 wxDateSpan *arg2 = 0 ;
26071 wxDateSpan *result;
26072 PyObject * obj0 = 0 ;
26073 PyObject * obj1 = 0 ;
26074 char *kwnames[] = {
26075 (char *) "self",(char *) "other", NULL
26076 };
26077
26078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26080 if (SWIG_arg_fail(1)) SWIG_fail;
26081 {
26082 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26083 if (SWIG_arg_fail(2)) SWIG_fail;
26084 if (arg2 == NULL) {
26085 SWIG_null_ref("wxDateSpan");
26086 }
26087 if (SWIG_arg_fail(2)) SWIG_fail;
26088 }
26089 {
26090 PyThreadState* __tstate = wxPyBeginAllowThreads();
26091 {
26092 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26093 result = (wxDateSpan *) &_result_ref;
26094 }
26095
26096 wxPyEndAllowThreads(__tstate);
26097 if (PyErr_Occurred()) SWIG_fail;
26098 }
26099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26100 return resultobj;
26101 fail:
26102 return NULL;
26103 }
26104
26105
26106 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26107 PyObject *resultobj;
26108 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26109 wxDateSpan *arg2 = 0 ;
26110 wxDateSpan *result;
26111 PyObject * obj0 = 0 ;
26112 PyObject * obj1 = 0 ;
26113 char *kwnames[] = {
26114 (char *) "self",(char *) "other", NULL
26115 };
26116
26117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26119 if (SWIG_arg_fail(1)) SWIG_fail;
26120 {
26121 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26122 if (SWIG_arg_fail(2)) SWIG_fail;
26123 if (arg2 == NULL) {
26124 SWIG_null_ref("wxDateSpan");
26125 }
26126 if (SWIG_arg_fail(2)) SWIG_fail;
26127 }
26128 {
26129 PyThreadState* __tstate = wxPyBeginAllowThreads();
26130 {
26131 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26132 result = (wxDateSpan *) &_result_ref;
26133 }
26134
26135 wxPyEndAllowThreads(__tstate);
26136 if (PyErr_Occurred()) SWIG_fail;
26137 }
26138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26146 PyObject *resultobj;
26147 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26148 wxDateSpan *result;
26149 PyObject * obj0 = 0 ;
26150 char *kwnames[] = {
26151 (char *) "self", NULL
26152 };
26153
26154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26156 if (SWIG_arg_fail(1)) SWIG_fail;
26157 {
26158 PyThreadState* __tstate = wxPyBeginAllowThreads();
26159 {
26160 wxDateSpan &_result_ref = (arg1)->operator -();
26161 result = (wxDateSpan *) &_result_ref;
26162 }
26163
26164 wxPyEndAllowThreads(__tstate);
26165 if (PyErr_Occurred()) SWIG_fail;
26166 }
26167 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26168 return resultobj;
26169 fail:
26170 return NULL;
26171 }
26172
26173
26174 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26175 PyObject *resultobj;
26176 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26177 int arg2 ;
26178 wxDateSpan *result;
26179 PyObject * obj0 = 0 ;
26180 PyObject * obj1 = 0 ;
26181 char *kwnames[] = {
26182 (char *) "self",(char *) "factor", NULL
26183 };
26184
26185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26187 if (SWIG_arg_fail(1)) SWIG_fail;
26188 {
26189 arg2 = (int)(SWIG_As_int(obj1));
26190 if (SWIG_arg_fail(2)) SWIG_fail;
26191 }
26192 {
26193 PyThreadState* __tstate = wxPyBeginAllowThreads();
26194 {
26195 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26196 result = (wxDateSpan *) &_result_ref;
26197 }
26198
26199 wxPyEndAllowThreads(__tstate);
26200 if (PyErr_Occurred()) SWIG_fail;
26201 }
26202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26203 return resultobj;
26204 fail:
26205 return NULL;
26206 }
26207
26208
26209 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26210 PyObject *resultobj;
26211 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26212 wxDateSpan *arg2 = 0 ;
26213 wxDateSpan result;
26214 PyObject * obj0 = 0 ;
26215 PyObject * obj1 = 0 ;
26216 char *kwnames[] = {
26217 (char *) "self",(char *) "other", NULL
26218 };
26219
26220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26222 if (SWIG_arg_fail(1)) SWIG_fail;
26223 {
26224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26225 if (SWIG_arg_fail(2)) SWIG_fail;
26226 if (arg2 == NULL) {
26227 SWIG_null_ref("wxDateSpan");
26228 }
26229 if (SWIG_arg_fail(2)) SWIG_fail;
26230 }
26231 {
26232 PyThreadState* __tstate = wxPyBeginAllowThreads();
26233 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26234
26235 wxPyEndAllowThreads(__tstate);
26236 if (PyErr_Occurred()) SWIG_fail;
26237 }
26238 {
26239 wxDateSpan * resultptr;
26240 resultptr = new wxDateSpan((wxDateSpan &)(result));
26241 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26242 }
26243 return resultobj;
26244 fail:
26245 return NULL;
26246 }
26247
26248
26249 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26250 PyObject *resultobj;
26251 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26252 wxDateSpan *arg2 = 0 ;
26253 wxDateSpan result;
26254 PyObject * obj0 = 0 ;
26255 PyObject * obj1 = 0 ;
26256 char *kwnames[] = {
26257 (char *) "self",(char *) "other", NULL
26258 };
26259
26260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26262 if (SWIG_arg_fail(1)) SWIG_fail;
26263 {
26264 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26265 if (SWIG_arg_fail(2)) SWIG_fail;
26266 if (arg2 == NULL) {
26267 SWIG_null_ref("wxDateSpan");
26268 }
26269 if (SWIG_arg_fail(2)) SWIG_fail;
26270 }
26271 {
26272 PyThreadState* __tstate = wxPyBeginAllowThreads();
26273 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26274
26275 wxPyEndAllowThreads(__tstate);
26276 if (PyErr_Occurred()) SWIG_fail;
26277 }
26278 {
26279 wxDateSpan * resultptr;
26280 resultptr = new wxDateSpan((wxDateSpan &)(result));
26281 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26282 }
26283 return resultobj;
26284 fail:
26285 return NULL;
26286 }
26287
26288
26289 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26290 PyObject *resultobj;
26291 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26292 int arg2 ;
26293 wxDateSpan result;
26294 PyObject * obj0 = 0 ;
26295 PyObject * obj1 = 0 ;
26296 char *kwnames[] = {
26297 (char *) "self",(char *) "n", NULL
26298 };
26299
26300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26302 if (SWIG_arg_fail(1)) SWIG_fail;
26303 {
26304 arg2 = (int)(SWIG_As_int(obj1));
26305 if (SWIG_arg_fail(2)) SWIG_fail;
26306 }
26307 {
26308 PyThreadState* __tstate = wxPyBeginAllowThreads();
26309 result = wxDateSpan___mul__(arg1,arg2);
26310
26311 wxPyEndAllowThreads(__tstate);
26312 if (PyErr_Occurred()) SWIG_fail;
26313 }
26314 {
26315 wxDateSpan * resultptr;
26316 resultptr = new wxDateSpan((wxDateSpan &)(result));
26317 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26318 }
26319 return resultobj;
26320 fail:
26321 return NULL;
26322 }
26323
26324
26325 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26326 PyObject *resultobj;
26327 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26328 int arg2 ;
26329 wxDateSpan result;
26330 PyObject * obj0 = 0 ;
26331 PyObject * obj1 = 0 ;
26332 char *kwnames[] = {
26333 (char *) "self",(char *) "n", NULL
26334 };
26335
26336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26338 if (SWIG_arg_fail(1)) SWIG_fail;
26339 {
26340 arg2 = (int)(SWIG_As_int(obj1));
26341 if (SWIG_arg_fail(2)) SWIG_fail;
26342 }
26343 {
26344 PyThreadState* __tstate = wxPyBeginAllowThreads();
26345 result = wxDateSpan___rmul__(arg1,arg2);
26346
26347 wxPyEndAllowThreads(__tstate);
26348 if (PyErr_Occurred()) SWIG_fail;
26349 }
26350 {
26351 wxDateSpan * resultptr;
26352 resultptr = new wxDateSpan((wxDateSpan &)(result));
26353 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26354 }
26355 return resultobj;
26356 fail:
26357 return NULL;
26358 }
26359
26360
26361 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26362 PyObject *resultobj;
26363 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26364 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26365 bool result;
26366 PyObject * obj0 = 0 ;
26367 PyObject * obj1 = 0 ;
26368 char *kwnames[] = {
26369 (char *) "self",(char *) "other", NULL
26370 };
26371
26372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26374 if (SWIG_arg_fail(1)) SWIG_fail;
26375 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26376 if (SWIG_arg_fail(2)) SWIG_fail;
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26380
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 {
26385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26386 }
26387 return resultobj;
26388 fail:
26389 return NULL;
26390 }
26391
26392
26393 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26394 PyObject *resultobj;
26395 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26396 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26397 bool result;
26398 PyObject * obj0 = 0 ;
26399 PyObject * obj1 = 0 ;
26400 char *kwnames[] = {
26401 (char *) "self",(char *) "other", NULL
26402 };
26403
26404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26406 if (SWIG_arg_fail(1)) SWIG_fail;
26407 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26408 if (SWIG_arg_fail(2)) SWIG_fail;
26409 {
26410 PyThreadState* __tstate = wxPyBeginAllowThreads();
26411 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26412
26413 wxPyEndAllowThreads(__tstate);
26414 if (PyErr_Occurred()) SWIG_fail;
26415 }
26416 {
26417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26418 }
26419 return resultobj;
26420 fail:
26421 return NULL;
26422 }
26423
26424
26425 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26426 PyObject *obj;
26427 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26428 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26429 Py_INCREF(obj);
26430 return Py_BuildValue((char *)"");
26431 }
26432 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26433 PyObject *resultobj;
26434 long result;
26435 char *kwnames[] = {
26436 NULL
26437 };
26438
26439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26440 {
26441 PyThreadState* __tstate = wxPyBeginAllowThreads();
26442 result = (long)wxGetLocalTime();
26443
26444 wxPyEndAllowThreads(__tstate);
26445 if (PyErr_Occurred()) SWIG_fail;
26446 }
26447 {
26448 resultobj = SWIG_From_long((long)(result));
26449 }
26450 return resultobj;
26451 fail:
26452 return NULL;
26453 }
26454
26455
26456 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26457 PyObject *resultobj;
26458 long result;
26459 char *kwnames[] = {
26460 NULL
26461 };
26462
26463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26464 {
26465 PyThreadState* __tstate = wxPyBeginAllowThreads();
26466 result = (long)wxGetUTCTime();
26467
26468 wxPyEndAllowThreads(__tstate);
26469 if (PyErr_Occurred()) SWIG_fail;
26470 }
26471 {
26472 resultobj = SWIG_From_long((long)(result));
26473 }
26474 return resultobj;
26475 fail:
26476 return NULL;
26477 }
26478
26479
26480 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26481 PyObject *resultobj;
26482 long result;
26483 char *kwnames[] = {
26484 NULL
26485 };
26486
26487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26488 {
26489 PyThreadState* __tstate = wxPyBeginAllowThreads();
26490 result = (long)wxGetCurrentTime();
26491
26492 wxPyEndAllowThreads(__tstate);
26493 if (PyErr_Occurred()) SWIG_fail;
26494 }
26495 {
26496 resultobj = SWIG_From_long((long)(result));
26497 }
26498 return resultobj;
26499 fail:
26500 return NULL;
26501 }
26502
26503
26504 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26505 PyObject *resultobj;
26506 wxLongLong result;
26507 char *kwnames[] = {
26508 NULL
26509 };
26510
26511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26512 {
26513 PyThreadState* __tstate = wxPyBeginAllowThreads();
26514 result = wxGetLocalTimeMillis();
26515
26516 wxPyEndAllowThreads(__tstate);
26517 if (PyErr_Occurred()) SWIG_fail;
26518 }
26519 {
26520 PyObject *hi, *lo, *shifter, *shifted;
26521 hi = PyLong_FromLong( (&result)->GetHi() );
26522 lo = PyLong_FromLong( (&result)->GetLo() );
26523 shifter = PyLong_FromLong(32);
26524 shifted = PyNumber_Lshift(hi, shifter);
26525 resultobj = PyNumber_Or(shifted, lo);
26526 Py_DECREF(hi);
26527 Py_DECREF(lo);
26528 Py_DECREF(shifter);
26529 Py_DECREF(shifted);
26530 }
26531 return resultobj;
26532 fail:
26533 return NULL;
26534 }
26535
26536
26537 static int _wrap_DefaultDateTime_set(PyObject *) {
26538 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26539 return 1;
26540 }
26541
26542
26543 static PyObject *_wrap_DefaultDateTime_get(void) {
26544 PyObject *pyobj;
26545
26546 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26547 return pyobj;
26548 }
26549
26550
26551 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26552 PyObject *resultobj;
26553 wxDataFormatId arg1 ;
26554 wxDataFormat *result;
26555 PyObject * obj0 = 0 ;
26556 char *kwnames[] = {
26557 (char *) "type", NULL
26558 };
26559
26560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26561 {
26562 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26563 if (SWIG_arg_fail(1)) SWIG_fail;
26564 }
26565 {
26566 PyThreadState* __tstate = wxPyBeginAllowThreads();
26567 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26568
26569 wxPyEndAllowThreads(__tstate);
26570 if (PyErr_Occurred()) SWIG_fail;
26571 }
26572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26573 return resultobj;
26574 fail:
26575 return NULL;
26576 }
26577
26578
26579 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26580 PyObject *resultobj;
26581 wxString *arg1 = 0 ;
26582 wxDataFormat *result;
26583 bool temp1 = false ;
26584 PyObject * obj0 = 0 ;
26585 char *kwnames[] = {
26586 (char *) "format", NULL
26587 };
26588
26589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26590 {
26591 arg1 = wxString_in_helper(obj0);
26592 if (arg1 == NULL) SWIG_fail;
26593 temp1 = true;
26594 }
26595 {
26596 PyThreadState* __tstate = wxPyBeginAllowThreads();
26597 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26598
26599 wxPyEndAllowThreads(__tstate);
26600 if (PyErr_Occurred()) SWIG_fail;
26601 }
26602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26603 {
26604 if (temp1)
26605 delete arg1;
26606 }
26607 return resultobj;
26608 fail:
26609 {
26610 if (temp1)
26611 delete arg1;
26612 }
26613 return NULL;
26614 }
26615
26616
26617 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26618 PyObject *resultobj;
26619 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26620 PyObject * obj0 = 0 ;
26621 char *kwnames[] = {
26622 (char *) "self", NULL
26623 };
26624
26625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26627 if (SWIG_arg_fail(1)) SWIG_fail;
26628 {
26629 PyThreadState* __tstate = wxPyBeginAllowThreads();
26630 delete arg1;
26631
26632 wxPyEndAllowThreads(__tstate);
26633 if (PyErr_Occurred()) SWIG_fail;
26634 }
26635 Py_INCREF(Py_None); resultobj = Py_None;
26636 return resultobj;
26637 fail:
26638 return NULL;
26639 }
26640
26641
26642 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26643 PyObject *resultobj;
26644 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26645 wxDataFormatId arg2 ;
26646 bool result;
26647 PyObject * obj0 = 0 ;
26648 PyObject * obj1 = 0 ;
26649
26650 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26652 if (SWIG_arg_fail(1)) SWIG_fail;
26653 {
26654 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26655 if (SWIG_arg_fail(2)) SWIG_fail;
26656 }
26657 {
26658 PyThreadState* __tstate = wxPyBeginAllowThreads();
26659 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26660
26661 wxPyEndAllowThreads(__tstate);
26662 if (PyErr_Occurred()) SWIG_fail;
26663 }
26664 {
26665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26666 }
26667 return resultobj;
26668 fail:
26669 return NULL;
26670 }
26671
26672
26673 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26674 PyObject *resultobj;
26675 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26676 wxDataFormatId arg2 ;
26677 bool result;
26678 PyObject * obj0 = 0 ;
26679 PyObject * obj1 = 0 ;
26680
26681 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26683 if (SWIG_arg_fail(1)) SWIG_fail;
26684 {
26685 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26686 if (SWIG_arg_fail(2)) SWIG_fail;
26687 }
26688 {
26689 PyThreadState* __tstate = wxPyBeginAllowThreads();
26690 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26691
26692 wxPyEndAllowThreads(__tstate);
26693 if (PyErr_Occurred()) SWIG_fail;
26694 }
26695 {
26696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26697 }
26698 return resultobj;
26699 fail:
26700 return NULL;
26701 }
26702
26703
26704 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26705 PyObject *resultobj;
26706 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26707 wxDataFormat *arg2 = 0 ;
26708 bool result;
26709 PyObject * obj0 = 0 ;
26710 PyObject * obj1 = 0 ;
26711
26712 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26714 if (SWIG_arg_fail(1)) SWIG_fail;
26715 {
26716 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26717 if (SWIG_arg_fail(2)) SWIG_fail;
26718 if (arg2 == NULL) {
26719 SWIG_null_ref("wxDataFormat");
26720 }
26721 if (SWIG_arg_fail(2)) SWIG_fail;
26722 }
26723 {
26724 PyThreadState* __tstate = wxPyBeginAllowThreads();
26725 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26726
26727 wxPyEndAllowThreads(__tstate);
26728 if (PyErr_Occurred()) SWIG_fail;
26729 }
26730 {
26731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26732 }
26733 return resultobj;
26734 fail:
26735 return NULL;
26736 }
26737
26738
26739 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26740 int argc;
26741 PyObject *argv[3];
26742 int ii;
26743
26744 argc = PyObject_Length(args);
26745 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26746 argv[ii] = PyTuple_GetItem(args,ii);
26747 }
26748 if (argc == 2) {
26749 int _v;
26750 {
26751 void *ptr;
26752 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26753 _v = 0;
26754 PyErr_Clear();
26755 } else {
26756 _v = 1;
26757 }
26758 }
26759 if (_v) {
26760 {
26761 void *ptr = 0;
26762 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26763 _v = 0;
26764 PyErr_Clear();
26765 } else {
26766 _v = (ptr != 0);
26767 }
26768 }
26769 if (_v) {
26770 return _wrap_DataFormat___eq____SWIG_1(self,args);
26771 }
26772 }
26773 }
26774 if (argc == 2) {
26775 int _v;
26776 {
26777 void *ptr;
26778 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26779 _v = 0;
26780 PyErr_Clear();
26781 } else {
26782 _v = 1;
26783 }
26784 }
26785 if (_v) {
26786 _v = SWIG_Check_int(argv[1]);
26787 if (_v) {
26788 return _wrap_DataFormat___eq____SWIG_0(self,args);
26789 }
26790 }
26791 }
26792
26793 Py_INCREF(Py_NotImplemented);
26794 return Py_NotImplemented;
26795 }
26796
26797
26798 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26799 PyObject *resultobj;
26800 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26801 wxDataFormat *arg2 = 0 ;
26802 bool result;
26803 PyObject * obj0 = 0 ;
26804 PyObject * obj1 = 0 ;
26805
26806 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26808 if (SWIG_arg_fail(1)) SWIG_fail;
26809 {
26810 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26811 if (SWIG_arg_fail(2)) SWIG_fail;
26812 if (arg2 == NULL) {
26813 SWIG_null_ref("wxDataFormat");
26814 }
26815 if (SWIG_arg_fail(2)) SWIG_fail;
26816 }
26817 {
26818 PyThreadState* __tstate = wxPyBeginAllowThreads();
26819 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26820
26821 wxPyEndAllowThreads(__tstate);
26822 if (PyErr_Occurred()) SWIG_fail;
26823 }
26824 {
26825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26826 }
26827 return resultobj;
26828 fail:
26829 return NULL;
26830 }
26831
26832
26833 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26834 int argc;
26835 PyObject *argv[3];
26836 int ii;
26837
26838 argc = PyObject_Length(args);
26839 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26840 argv[ii] = PyTuple_GetItem(args,ii);
26841 }
26842 if (argc == 2) {
26843 int _v;
26844 {
26845 void *ptr;
26846 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26847 _v = 0;
26848 PyErr_Clear();
26849 } else {
26850 _v = 1;
26851 }
26852 }
26853 if (_v) {
26854 {
26855 void *ptr = 0;
26856 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26857 _v = 0;
26858 PyErr_Clear();
26859 } else {
26860 _v = (ptr != 0);
26861 }
26862 }
26863 if (_v) {
26864 return _wrap_DataFormat___ne____SWIG_1(self,args);
26865 }
26866 }
26867 }
26868 if (argc == 2) {
26869 int _v;
26870 {
26871 void *ptr;
26872 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26873 _v = 0;
26874 PyErr_Clear();
26875 } else {
26876 _v = 1;
26877 }
26878 }
26879 if (_v) {
26880 _v = SWIG_Check_int(argv[1]);
26881 if (_v) {
26882 return _wrap_DataFormat___ne____SWIG_0(self,args);
26883 }
26884 }
26885 }
26886
26887 Py_INCREF(Py_NotImplemented);
26888 return Py_NotImplemented;
26889 }
26890
26891
26892 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26893 PyObject *resultobj;
26894 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26895 wxDataFormatId arg2 ;
26896 PyObject * obj0 = 0 ;
26897 PyObject * obj1 = 0 ;
26898 char *kwnames[] = {
26899 (char *) "self",(char *) "format", NULL
26900 };
26901
26902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26904 if (SWIG_arg_fail(1)) SWIG_fail;
26905 {
26906 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26907 if (SWIG_arg_fail(2)) SWIG_fail;
26908 }
26909 {
26910 PyThreadState* __tstate = wxPyBeginAllowThreads();
26911 (arg1)->SetType((wxDataFormatId )arg2);
26912
26913 wxPyEndAllowThreads(__tstate);
26914 if (PyErr_Occurred()) SWIG_fail;
26915 }
26916 Py_INCREF(Py_None); resultobj = Py_None;
26917 return resultobj;
26918 fail:
26919 return NULL;
26920 }
26921
26922
26923 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26924 PyObject *resultobj;
26925 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26926 wxDataFormatId result;
26927 PyObject * obj0 = 0 ;
26928 char *kwnames[] = {
26929 (char *) "self", NULL
26930 };
26931
26932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26934 if (SWIG_arg_fail(1)) SWIG_fail;
26935 {
26936 PyThreadState* __tstate = wxPyBeginAllowThreads();
26937 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26938
26939 wxPyEndAllowThreads(__tstate);
26940 if (PyErr_Occurred()) SWIG_fail;
26941 }
26942 resultobj = SWIG_From_int((result));
26943 return resultobj;
26944 fail:
26945 return NULL;
26946 }
26947
26948
26949 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26950 PyObject *resultobj;
26951 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26952 wxString result;
26953 PyObject * obj0 = 0 ;
26954 char *kwnames[] = {
26955 (char *) "self", NULL
26956 };
26957
26958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26960 if (SWIG_arg_fail(1)) SWIG_fail;
26961 {
26962 PyThreadState* __tstate = wxPyBeginAllowThreads();
26963 result = ((wxDataFormat const *)arg1)->GetId();
26964
26965 wxPyEndAllowThreads(__tstate);
26966 if (PyErr_Occurred()) SWIG_fail;
26967 }
26968 {
26969 #if wxUSE_UNICODE
26970 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26971 #else
26972 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26973 #endif
26974 }
26975 return resultobj;
26976 fail:
26977 return NULL;
26978 }
26979
26980
26981 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26982 PyObject *resultobj;
26983 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26984 wxString *arg2 = 0 ;
26985 bool temp2 = false ;
26986 PyObject * obj0 = 0 ;
26987 PyObject * obj1 = 0 ;
26988 char *kwnames[] = {
26989 (char *) "self",(char *) "format", NULL
26990 };
26991
26992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26994 if (SWIG_arg_fail(1)) SWIG_fail;
26995 {
26996 arg2 = wxString_in_helper(obj1);
26997 if (arg2 == NULL) SWIG_fail;
26998 temp2 = true;
26999 }
27000 {
27001 PyThreadState* __tstate = wxPyBeginAllowThreads();
27002 (arg1)->SetId((wxString const &)*arg2);
27003
27004 wxPyEndAllowThreads(__tstate);
27005 if (PyErr_Occurred()) SWIG_fail;
27006 }
27007 Py_INCREF(Py_None); resultobj = Py_None;
27008 {
27009 if (temp2)
27010 delete arg2;
27011 }
27012 return resultobj;
27013 fail:
27014 {
27015 if (temp2)
27016 delete arg2;
27017 }
27018 return NULL;
27019 }
27020
27021
27022 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
27023 PyObject *obj;
27024 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27025 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
27026 Py_INCREF(obj);
27027 return Py_BuildValue((char *)"");
27028 }
27029 static int _wrap_FormatInvalid_set(PyObject *) {
27030 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
27031 return 1;
27032 }
27033
27034
27035 static PyObject *_wrap_FormatInvalid_get(void) {
27036 PyObject *pyobj;
27037
27038 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
27039 return pyobj;
27040 }
27041
27042
27043 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27044 PyObject *resultobj;
27045 wxDataObject *arg1 = (wxDataObject *) 0 ;
27046 PyObject * obj0 = 0 ;
27047 char *kwnames[] = {
27048 (char *) "self", NULL
27049 };
27050
27051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27053 if (SWIG_arg_fail(1)) SWIG_fail;
27054 {
27055 PyThreadState* __tstate = wxPyBeginAllowThreads();
27056 delete arg1;
27057
27058 wxPyEndAllowThreads(__tstate);
27059 if (PyErr_Occurred()) SWIG_fail;
27060 }
27061 Py_INCREF(Py_None); resultobj = Py_None;
27062 return resultobj;
27063 fail:
27064 return NULL;
27065 }
27066
27067
27068 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27069 PyObject *resultobj;
27070 wxDataObject *arg1 = (wxDataObject *) 0 ;
27071 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27072 SwigValueWrapper<wxDataFormat > result;
27073 PyObject * obj0 = 0 ;
27074 PyObject * obj1 = 0 ;
27075 char *kwnames[] = {
27076 (char *) "self",(char *) "dir", NULL
27077 };
27078
27079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27081 if (SWIG_arg_fail(1)) SWIG_fail;
27082 if (obj1) {
27083 {
27084 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27085 if (SWIG_arg_fail(2)) SWIG_fail;
27086 }
27087 }
27088 {
27089 PyThreadState* __tstate = wxPyBeginAllowThreads();
27090 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27091
27092 wxPyEndAllowThreads(__tstate);
27093 if (PyErr_Occurred()) SWIG_fail;
27094 }
27095 {
27096 wxDataFormat * resultptr;
27097 resultptr = new wxDataFormat((wxDataFormat &)(result));
27098 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27099 }
27100 return resultobj;
27101 fail:
27102 return NULL;
27103 }
27104
27105
27106 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27107 PyObject *resultobj;
27108 wxDataObject *arg1 = (wxDataObject *) 0 ;
27109 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27110 size_t result;
27111 PyObject * obj0 = 0 ;
27112 PyObject * obj1 = 0 ;
27113 char *kwnames[] = {
27114 (char *) "self",(char *) "dir", NULL
27115 };
27116
27117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27119 if (SWIG_arg_fail(1)) SWIG_fail;
27120 if (obj1) {
27121 {
27122 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27123 if (SWIG_arg_fail(2)) SWIG_fail;
27124 }
27125 }
27126 {
27127 PyThreadState* __tstate = wxPyBeginAllowThreads();
27128 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27129
27130 wxPyEndAllowThreads(__tstate);
27131 if (PyErr_Occurred()) SWIG_fail;
27132 }
27133 {
27134 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27135 }
27136 return resultobj;
27137 fail:
27138 return NULL;
27139 }
27140
27141
27142 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27143 PyObject *resultobj;
27144 wxDataObject *arg1 = (wxDataObject *) 0 ;
27145 wxDataFormat *arg2 = 0 ;
27146 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27147 bool result;
27148 PyObject * obj0 = 0 ;
27149 PyObject * obj1 = 0 ;
27150 PyObject * obj2 = 0 ;
27151 char *kwnames[] = {
27152 (char *) "self",(char *) "format",(char *) "dir", NULL
27153 };
27154
27155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27157 if (SWIG_arg_fail(1)) SWIG_fail;
27158 {
27159 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27160 if (SWIG_arg_fail(2)) SWIG_fail;
27161 if (arg2 == NULL) {
27162 SWIG_null_ref("wxDataFormat");
27163 }
27164 if (SWIG_arg_fail(2)) SWIG_fail;
27165 }
27166 if (obj2) {
27167 {
27168 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27169 if (SWIG_arg_fail(3)) SWIG_fail;
27170 }
27171 }
27172 {
27173 PyThreadState* __tstate = wxPyBeginAllowThreads();
27174 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27175
27176 wxPyEndAllowThreads(__tstate);
27177 if (PyErr_Occurred()) SWIG_fail;
27178 }
27179 {
27180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27181 }
27182 return resultobj;
27183 fail:
27184 return NULL;
27185 }
27186
27187
27188 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27189 PyObject *resultobj;
27190 wxDataObject *arg1 = (wxDataObject *) 0 ;
27191 wxDataFormat *arg2 = 0 ;
27192 size_t result;
27193 PyObject * obj0 = 0 ;
27194 PyObject * obj1 = 0 ;
27195 char *kwnames[] = {
27196 (char *) "self",(char *) "format", NULL
27197 };
27198
27199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27201 if (SWIG_arg_fail(1)) SWIG_fail;
27202 {
27203 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27204 if (SWIG_arg_fail(2)) SWIG_fail;
27205 if (arg2 == NULL) {
27206 SWIG_null_ref("wxDataFormat");
27207 }
27208 if (SWIG_arg_fail(2)) SWIG_fail;
27209 }
27210 {
27211 PyThreadState* __tstate = wxPyBeginAllowThreads();
27212 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27213
27214 wxPyEndAllowThreads(__tstate);
27215 if (PyErr_Occurred()) SWIG_fail;
27216 }
27217 {
27218 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27219 }
27220 return resultobj;
27221 fail:
27222 return NULL;
27223 }
27224
27225
27226 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27227 PyObject *resultobj;
27228 wxDataObject *arg1 = (wxDataObject *) 0 ;
27229 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27230 PyObject *result;
27231 PyObject * obj0 = 0 ;
27232 PyObject * obj1 = 0 ;
27233 char *kwnames[] = {
27234 (char *) "self",(char *) "dir", NULL
27235 };
27236
27237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27239 if (SWIG_arg_fail(1)) SWIG_fail;
27240 if (obj1) {
27241 {
27242 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27243 if (SWIG_arg_fail(2)) SWIG_fail;
27244 }
27245 }
27246 {
27247 PyThreadState* __tstate = wxPyBeginAllowThreads();
27248 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27249
27250 wxPyEndAllowThreads(__tstate);
27251 if (PyErr_Occurred()) SWIG_fail;
27252 }
27253 resultobj = result;
27254 return resultobj;
27255 fail:
27256 return NULL;
27257 }
27258
27259
27260 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27261 PyObject *resultobj;
27262 wxDataObject *arg1 = (wxDataObject *) 0 ;
27263 wxDataFormat *arg2 = 0 ;
27264 PyObject *result;
27265 PyObject * obj0 = 0 ;
27266 PyObject * obj1 = 0 ;
27267 char *kwnames[] = {
27268 (char *) "self",(char *) "format", NULL
27269 };
27270
27271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27273 if (SWIG_arg_fail(1)) SWIG_fail;
27274 {
27275 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27276 if (SWIG_arg_fail(2)) SWIG_fail;
27277 if (arg2 == NULL) {
27278 SWIG_null_ref("wxDataFormat");
27279 }
27280 if (SWIG_arg_fail(2)) SWIG_fail;
27281 }
27282 {
27283 PyThreadState* __tstate = wxPyBeginAllowThreads();
27284 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27285
27286 wxPyEndAllowThreads(__tstate);
27287 if (PyErr_Occurred()) SWIG_fail;
27288 }
27289 resultobj = result;
27290 return resultobj;
27291 fail:
27292 return NULL;
27293 }
27294
27295
27296 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27297 PyObject *resultobj;
27298 wxDataObject *arg1 = (wxDataObject *) 0 ;
27299 wxDataFormat *arg2 = 0 ;
27300 PyObject *arg3 = (PyObject *) 0 ;
27301 bool result;
27302 PyObject * obj0 = 0 ;
27303 PyObject * obj1 = 0 ;
27304 PyObject * obj2 = 0 ;
27305 char *kwnames[] = {
27306 (char *) "self",(char *) "format",(char *) "data", NULL
27307 };
27308
27309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27311 if (SWIG_arg_fail(1)) SWIG_fail;
27312 {
27313 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27314 if (SWIG_arg_fail(2)) SWIG_fail;
27315 if (arg2 == NULL) {
27316 SWIG_null_ref("wxDataFormat");
27317 }
27318 if (SWIG_arg_fail(2)) SWIG_fail;
27319 }
27320 arg3 = obj2;
27321 {
27322 PyThreadState* __tstate = wxPyBeginAllowThreads();
27323 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27324
27325 wxPyEndAllowThreads(__tstate);
27326 if (PyErr_Occurred()) SWIG_fail;
27327 }
27328 {
27329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27330 }
27331 return resultobj;
27332 fail:
27333 return NULL;
27334 }
27335
27336
27337 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27338 PyObject *obj;
27339 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27340 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27341 Py_INCREF(obj);
27342 return Py_BuildValue((char *)"");
27343 }
27344 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27345 PyObject *resultobj;
27346 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27347 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27348 wxDataObjectSimple *result;
27349 PyObject * obj0 = 0 ;
27350 char *kwnames[] = {
27351 (char *) "format", NULL
27352 };
27353
27354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27355 if (obj0) {
27356 {
27357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27358 if (SWIG_arg_fail(1)) SWIG_fail;
27359 if (arg1 == NULL) {
27360 SWIG_null_ref("wxDataFormat");
27361 }
27362 if (SWIG_arg_fail(1)) SWIG_fail;
27363 }
27364 }
27365 {
27366 PyThreadState* __tstate = wxPyBeginAllowThreads();
27367 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27368
27369 wxPyEndAllowThreads(__tstate);
27370 if (PyErr_Occurred()) SWIG_fail;
27371 }
27372 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27373 return resultobj;
27374 fail:
27375 return NULL;
27376 }
27377
27378
27379 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27380 PyObject *resultobj;
27381 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27382 wxDataFormat *result;
27383 PyObject * obj0 = 0 ;
27384 char *kwnames[] = {
27385 (char *) "self", NULL
27386 };
27387
27388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27390 if (SWIG_arg_fail(1)) SWIG_fail;
27391 {
27392 PyThreadState* __tstate = wxPyBeginAllowThreads();
27393 {
27394 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27395 result = (wxDataFormat *) &_result_ref;
27396 }
27397
27398 wxPyEndAllowThreads(__tstate);
27399 if (PyErr_Occurred()) SWIG_fail;
27400 }
27401 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27402 return resultobj;
27403 fail:
27404 return NULL;
27405 }
27406
27407
27408 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27409 PyObject *resultobj;
27410 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27411 wxDataFormat *arg2 = 0 ;
27412 PyObject * obj0 = 0 ;
27413 PyObject * obj1 = 0 ;
27414 char *kwnames[] = {
27415 (char *) "self",(char *) "format", NULL
27416 };
27417
27418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27420 if (SWIG_arg_fail(1)) SWIG_fail;
27421 {
27422 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27423 if (SWIG_arg_fail(2)) SWIG_fail;
27424 if (arg2 == NULL) {
27425 SWIG_null_ref("wxDataFormat");
27426 }
27427 if (SWIG_arg_fail(2)) SWIG_fail;
27428 }
27429 {
27430 PyThreadState* __tstate = wxPyBeginAllowThreads();
27431 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27432
27433 wxPyEndAllowThreads(__tstate);
27434 if (PyErr_Occurred()) SWIG_fail;
27435 }
27436 Py_INCREF(Py_None); resultobj = Py_None;
27437 return resultobj;
27438 fail:
27439 return NULL;
27440 }
27441
27442
27443 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27444 PyObject *resultobj;
27445 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27446 size_t result;
27447 PyObject * obj0 = 0 ;
27448 char *kwnames[] = {
27449 (char *) "self", NULL
27450 };
27451
27452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27454 if (SWIG_arg_fail(1)) SWIG_fail;
27455 {
27456 PyThreadState* __tstate = wxPyBeginAllowThreads();
27457 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27458
27459 wxPyEndAllowThreads(__tstate);
27460 if (PyErr_Occurred()) SWIG_fail;
27461 }
27462 {
27463 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27464 }
27465 return resultobj;
27466 fail:
27467 return NULL;
27468 }
27469
27470
27471 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27472 PyObject *resultobj;
27473 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27474 PyObject *result;
27475 PyObject * obj0 = 0 ;
27476 char *kwnames[] = {
27477 (char *) "self", NULL
27478 };
27479
27480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27482 if (SWIG_arg_fail(1)) SWIG_fail;
27483 {
27484 PyThreadState* __tstate = wxPyBeginAllowThreads();
27485 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27486
27487 wxPyEndAllowThreads(__tstate);
27488 if (PyErr_Occurred()) SWIG_fail;
27489 }
27490 resultobj = result;
27491 return resultobj;
27492 fail:
27493 return NULL;
27494 }
27495
27496
27497 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27498 PyObject *resultobj;
27499 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27500 PyObject *arg2 = (PyObject *) 0 ;
27501 bool result;
27502 PyObject * obj0 = 0 ;
27503 PyObject * obj1 = 0 ;
27504 char *kwnames[] = {
27505 (char *) "self",(char *) "data", NULL
27506 };
27507
27508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27510 if (SWIG_arg_fail(1)) SWIG_fail;
27511 arg2 = obj1;
27512 {
27513 PyThreadState* __tstate = wxPyBeginAllowThreads();
27514 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27515
27516 wxPyEndAllowThreads(__tstate);
27517 if (PyErr_Occurred()) SWIG_fail;
27518 }
27519 {
27520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27521 }
27522 return resultobj;
27523 fail:
27524 return NULL;
27525 }
27526
27527
27528 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27529 PyObject *obj;
27530 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27531 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27532 Py_INCREF(obj);
27533 return Py_BuildValue((char *)"");
27534 }
27535 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27536 PyObject *resultobj;
27537 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27538 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27539 wxPyDataObjectSimple *result;
27540 PyObject * obj0 = 0 ;
27541 char *kwnames[] = {
27542 (char *) "format", NULL
27543 };
27544
27545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27546 if (obj0) {
27547 {
27548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27549 if (SWIG_arg_fail(1)) SWIG_fail;
27550 if (arg1 == NULL) {
27551 SWIG_null_ref("wxDataFormat");
27552 }
27553 if (SWIG_arg_fail(1)) SWIG_fail;
27554 }
27555 }
27556 {
27557 PyThreadState* __tstate = wxPyBeginAllowThreads();
27558 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27559
27560 wxPyEndAllowThreads(__tstate);
27561 if (PyErr_Occurred()) SWIG_fail;
27562 }
27563 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27564 return resultobj;
27565 fail:
27566 return NULL;
27567 }
27568
27569
27570 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27571 PyObject *resultobj;
27572 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27573 PyObject *arg2 = (PyObject *) 0 ;
27574 PyObject *arg3 = (PyObject *) 0 ;
27575 PyObject * obj0 = 0 ;
27576 PyObject * obj1 = 0 ;
27577 PyObject * obj2 = 0 ;
27578 char *kwnames[] = {
27579 (char *) "self",(char *) "self",(char *) "_class", NULL
27580 };
27581
27582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27584 if (SWIG_arg_fail(1)) SWIG_fail;
27585 arg2 = obj1;
27586 arg3 = obj2;
27587 {
27588 PyThreadState* __tstate = wxPyBeginAllowThreads();
27589 (arg1)->_setCallbackInfo(arg2,arg3);
27590
27591 wxPyEndAllowThreads(__tstate);
27592 if (PyErr_Occurred()) SWIG_fail;
27593 }
27594 Py_INCREF(Py_None); resultobj = Py_None;
27595 return resultobj;
27596 fail:
27597 return NULL;
27598 }
27599
27600
27601 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27602 PyObject *obj;
27603 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27604 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27605 Py_INCREF(obj);
27606 return Py_BuildValue((char *)"");
27607 }
27608 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27609 PyObject *resultobj;
27610 wxDataObjectComposite *result;
27611 char *kwnames[] = {
27612 NULL
27613 };
27614
27615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27616 {
27617 PyThreadState* __tstate = wxPyBeginAllowThreads();
27618 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27619
27620 wxPyEndAllowThreads(__tstate);
27621 if (PyErr_Occurred()) SWIG_fail;
27622 }
27623 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27624 return resultobj;
27625 fail:
27626 return NULL;
27627 }
27628
27629
27630 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27631 PyObject *resultobj;
27632 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27633 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27634 bool arg3 = (bool) false ;
27635 PyObject * obj0 = 0 ;
27636 PyObject * obj1 = 0 ;
27637 PyObject * obj2 = 0 ;
27638 char *kwnames[] = {
27639 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27640 };
27641
27642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27644 if (SWIG_arg_fail(1)) SWIG_fail;
27645 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27646 if (SWIG_arg_fail(2)) SWIG_fail;
27647 if (obj2) {
27648 {
27649 arg3 = (bool)(SWIG_As_bool(obj2));
27650 if (SWIG_arg_fail(3)) SWIG_fail;
27651 }
27652 }
27653 {
27654 PyThreadState* __tstate = wxPyBeginAllowThreads();
27655 (arg1)->Add(arg2,arg3);
27656
27657 wxPyEndAllowThreads(__tstate);
27658 if (PyErr_Occurred()) SWIG_fail;
27659 }
27660 Py_INCREF(Py_None); resultobj = Py_None;
27661 return resultobj;
27662 fail:
27663 return NULL;
27664 }
27665
27666
27667 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27668 PyObject *obj;
27669 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27670 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27671 Py_INCREF(obj);
27672 return Py_BuildValue((char *)"");
27673 }
27674 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27675 PyObject *resultobj;
27676 wxString const &arg1_defvalue = wxPyEmptyString ;
27677 wxString *arg1 = (wxString *) &arg1_defvalue ;
27678 wxTextDataObject *result;
27679 bool temp1 = false ;
27680 PyObject * obj0 = 0 ;
27681 char *kwnames[] = {
27682 (char *) "text", NULL
27683 };
27684
27685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27686 if (obj0) {
27687 {
27688 arg1 = wxString_in_helper(obj0);
27689 if (arg1 == NULL) SWIG_fail;
27690 temp1 = true;
27691 }
27692 }
27693 {
27694 PyThreadState* __tstate = wxPyBeginAllowThreads();
27695 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27696
27697 wxPyEndAllowThreads(__tstate);
27698 if (PyErr_Occurred()) SWIG_fail;
27699 }
27700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27701 {
27702 if (temp1)
27703 delete arg1;
27704 }
27705 return resultobj;
27706 fail:
27707 {
27708 if (temp1)
27709 delete arg1;
27710 }
27711 return NULL;
27712 }
27713
27714
27715 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27716 PyObject *resultobj;
27717 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27718 size_t result;
27719 PyObject * obj0 = 0 ;
27720 char *kwnames[] = {
27721 (char *) "self", NULL
27722 };
27723
27724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27726 if (SWIG_arg_fail(1)) SWIG_fail;
27727 {
27728 PyThreadState* __tstate = wxPyBeginAllowThreads();
27729 result = (size_t)(arg1)->GetTextLength();
27730
27731 wxPyEndAllowThreads(__tstate);
27732 if (PyErr_Occurred()) SWIG_fail;
27733 }
27734 {
27735 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27736 }
27737 return resultobj;
27738 fail:
27739 return NULL;
27740 }
27741
27742
27743 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27744 PyObject *resultobj;
27745 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27746 wxString result;
27747 PyObject * obj0 = 0 ;
27748 char *kwnames[] = {
27749 (char *) "self", NULL
27750 };
27751
27752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27754 if (SWIG_arg_fail(1)) SWIG_fail;
27755 {
27756 PyThreadState* __tstate = wxPyBeginAllowThreads();
27757 result = (arg1)->GetText();
27758
27759 wxPyEndAllowThreads(__tstate);
27760 if (PyErr_Occurred()) SWIG_fail;
27761 }
27762 {
27763 #if wxUSE_UNICODE
27764 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27765 #else
27766 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27767 #endif
27768 }
27769 return resultobj;
27770 fail:
27771 return NULL;
27772 }
27773
27774
27775 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27776 PyObject *resultobj;
27777 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27778 wxString *arg2 = 0 ;
27779 bool temp2 = false ;
27780 PyObject * obj0 = 0 ;
27781 PyObject * obj1 = 0 ;
27782 char *kwnames[] = {
27783 (char *) "self",(char *) "text", NULL
27784 };
27785
27786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27788 if (SWIG_arg_fail(1)) SWIG_fail;
27789 {
27790 arg2 = wxString_in_helper(obj1);
27791 if (arg2 == NULL) SWIG_fail;
27792 temp2 = true;
27793 }
27794 {
27795 PyThreadState* __tstate = wxPyBeginAllowThreads();
27796 (arg1)->SetText((wxString const &)*arg2);
27797
27798 wxPyEndAllowThreads(__tstate);
27799 if (PyErr_Occurred()) SWIG_fail;
27800 }
27801 Py_INCREF(Py_None); resultobj = Py_None;
27802 {
27803 if (temp2)
27804 delete arg2;
27805 }
27806 return resultobj;
27807 fail:
27808 {
27809 if (temp2)
27810 delete arg2;
27811 }
27812 return NULL;
27813 }
27814
27815
27816 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27817 PyObject *obj;
27818 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27819 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27820 Py_INCREF(obj);
27821 return Py_BuildValue((char *)"");
27822 }
27823 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27824 PyObject *resultobj;
27825 wxString const &arg1_defvalue = wxPyEmptyString ;
27826 wxString *arg1 = (wxString *) &arg1_defvalue ;
27827 wxPyTextDataObject *result;
27828 bool temp1 = false ;
27829 PyObject * obj0 = 0 ;
27830 char *kwnames[] = {
27831 (char *) "text", NULL
27832 };
27833
27834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27835 if (obj0) {
27836 {
27837 arg1 = wxString_in_helper(obj0);
27838 if (arg1 == NULL) SWIG_fail;
27839 temp1 = true;
27840 }
27841 }
27842 {
27843 PyThreadState* __tstate = wxPyBeginAllowThreads();
27844 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27845
27846 wxPyEndAllowThreads(__tstate);
27847 if (PyErr_Occurred()) SWIG_fail;
27848 }
27849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27850 {
27851 if (temp1)
27852 delete arg1;
27853 }
27854 return resultobj;
27855 fail:
27856 {
27857 if (temp1)
27858 delete arg1;
27859 }
27860 return NULL;
27861 }
27862
27863
27864 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27865 PyObject *resultobj;
27866 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27867 PyObject *arg2 = (PyObject *) 0 ;
27868 PyObject *arg3 = (PyObject *) 0 ;
27869 PyObject * obj0 = 0 ;
27870 PyObject * obj1 = 0 ;
27871 PyObject * obj2 = 0 ;
27872 char *kwnames[] = {
27873 (char *) "self",(char *) "self",(char *) "_class", NULL
27874 };
27875
27876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27878 if (SWIG_arg_fail(1)) SWIG_fail;
27879 arg2 = obj1;
27880 arg3 = obj2;
27881 {
27882 PyThreadState* __tstate = wxPyBeginAllowThreads();
27883 (arg1)->_setCallbackInfo(arg2,arg3);
27884
27885 wxPyEndAllowThreads(__tstate);
27886 if (PyErr_Occurred()) SWIG_fail;
27887 }
27888 Py_INCREF(Py_None); resultobj = Py_None;
27889 return resultobj;
27890 fail:
27891 return NULL;
27892 }
27893
27894
27895 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27896 PyObject *obj;
27897 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27898 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27899 Py_INCREF(obj);
27900 return Py_BuildValue((char *)"");
27901 }
27902 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27903 PyObject *resultobj;
27904 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27905 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27906 wxBitmapDataObject *result;
27907 PyObject * obj0 = 0 ;
27908 char *kwnames[] = {
27909 (char *) "bitmap", NULL
27910 };
27911
27912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27913 if (obj0) {
27914 {
27915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27916 if (SWIG_arg_fail(1)) SWIG_fail;
27917 if (arg1 == NULL) {
27918 SWIG_null_ref("wxBitmap");
27919 }
27920 if (SWIG_arg_fail(1)) SWIG_fail;
27921 }
27922 }
27923 {
27924 PyThreadState* __tstate = wxPyBeginAllowThreads();
27925 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27926
27927 wxPyEndAllowThreads(__tstate);
27928 if (PyErr_Occurred()) SWIG_fail;
27929 }
27930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27931 return resultobj;
27932 fail:
27933 return NULL;
27934 }
27935
27936
27937 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27938 PyObject *resultobj;
27939 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27940 wxBitmap result;
27941 PyObject * obj0 = 0 ;
27942 char *kwnames[] = {
27943 (char *) "self", NULL
27944 };
27945
27946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27948 if (SWIG_arg_fail(1)) SWIG_fail;
27949 {
27950 PyThreadState* __tstate = wxPyBeginAllowThreads();
27951 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27952
27953 wxPyEndAllowThreads(__tstate);
27954 if (PyErr_Occurred()) SWIG_fail;
27955 }
27956 {
27957 wxBitmap * resultptr;
27958 resultptr = new wxBitmap((wxBitmap &)(result));
27959 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27960 }
27961 return resultobj;
27962 fail:
27963 return NULL;
27964 }
27965
27966
27967 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27968 PyObject *resultobj;
27969 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27970 wxBitmap *arg2 = 0 ;
27971 PyObject * obj0 = 0 ;
27972 PyObject * obj1 = 0 ;
27973 char *kwnames[] = {
27974 (char *) "self",(char *) "bitmap", NULL
27975 };
27976
27977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27979 if (SWIG_arg_fail(1)) SWIG_fail;
27980 {
27981 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27982 if (SWIG_arg_fail(2)) SWIG_fail;
27983 if (arg2 == NULL) {
27984 SWIG_null_ref("wxBitmap");
27985 }
27986 if (SWIG_arg_fail(2)) SWIG_fail;
27987 }
27988 {
27989 PyThreadState* __tstate = wxPyBeginAllowThreads();
27990 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27991
27992 wxPyEndAllowThreads(__tstate);
27993 if (PyErr_Occurred()) SWIG_fail;
27994 }
27995 Py_INCREF(Py_None); resultobj = Py_None;
27996 return resultobj;
27997 fail:
27998 return NULL;
27999 }
28000
28001
28002 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
28003 PyObject *obj;
28004 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28005 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
28006 Py_INCREF(obj);
28007 return Py_BuildValue((char *)"");
28008 }
28009 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28010 PyObject *resultobj;
28011 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28012 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28013 wxPyBitmapDataObject *result;
28014 PyObject * obj0 = 0 ;
28015 char *kwnames[] = {
28016 (char *) "bitmap", NULL
28017 };
28018
28019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
28020 if (obj0) {
28021 {
28022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28023 if (SWIG_arg_fail(1)) SWIG_fail;
28024 if (arg1 == NULL) {
28025 SWIG_null_ref("wxBitmap");
28026 }
28027 if (SWIG_arg_fail(1)) SWIG_fail;
28028 }
28029 }
28030 {
28031 PyThreadState* __tstate = wxPyBeginAllowThreads();
28032 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
28033
28034 wxPyEndAllowThreads(__tstate);
28035 if (PyErr_Occurred()) SWIG_fail;
28036 }
28037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
28038 return resultobj;
28039 fail:
28040 return NULL;
28041 }
28042
28043
28044 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28045 PyObject *resultobj;
28046 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28047 PyObject *arg2 = (PyObject *) 0 ;
28048 PyObject *arg3 = (PyObject *) 0 ;
28049 PyObject * obj0 = 0 ;
28050 PyObject * obj1 = 0 ;
28051 PyObject * obj2 = 0 ;
28052 char *kwnames[] = {
28053 (char *) "self",(char *) "self",(char *) "_class", NULL
28054 };
28055
28056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28058 if (SWIG_arg_fail(1)) SWIG_fail;
28059 arg2 = obj1;
28060 arg3 = obj2;
28061 {
28062 PyThreadState* __tstate = wxPyBeginAllowThreads();
28063 (arg1)->_setCallbackInfo(arg2,arg3);
28064
28065 wxPyEndAllowThreads(__tstate);
28066 if (PyErr_Occurred()) SWIG_fail;
28067 }
28068 Py_INCREF(Py_None); resultobj = Py_None;
28069 return resultobj;
28070 fail:
28071 return NULL;
28072 }
28073
28074
28075 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28076 PyObject *obj;
28077 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28078 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28079 Py_INCREF(obj);
28080 return Py_BuildValue((char *)"");
28081 }
28082 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28083 PyObject *resultobj;
28084 wxFileDataObject *result;
28085 char *kwnames[] = {
28086 NULL
28087 };
28088
28089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28090 {
28091 PyThreadState* __tstate = wxPyBeginAllowThreads();
28092 result = (wxFileDataObject *)new wxFileDataObject();
28093
28094 wxPyEndAllowThreads(__tstate);
28095 if (PyErr_Occurred()) SWIG_fail;
28096 }
28097 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28098 return resultobj;
28099 fail:
28100 return NULL;
28101 }
28102
28103
28104 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28105 PyObject *resultobj;
28106 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28107 wxArrayString *result;
28108 PyObject * obj0 = 0 ;
28109 char *kwnames[] = {
28110 (char *) "self", NULL
28111 };
28112
28113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28115 if (SWIG_arg_fail(1)) SWIG_fail;
28116 {
28117 PyThreadState* __tstate = wxPyBeginAllowThreads();
28118 {
28119 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28120 result = (wxArrayString *) &_result_ref;
28121 }
28122
28123 wxPyEndAllowThreads(__tstate);
28124 if (PyErr_Occurred()) SWIG_fail;
28125 }
28126 {
28127 resultobj = wxArrayString2PyList_helper(*result);
28128 }
28129 return resultobj;
28130 fail:
28131 return NULL;
28132 }
28133
28134
28135 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28136 PyObject *resultobj;
28137 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28138 wxString *arg2 = 0 ;
28139 bool temp2 = false ;
28140 PyObject * obj0 = 0 ;
28141 PyObject * obj1 = 0 ;
28142 char *kwnames[] = {
28143 (char *) "self",(char *) "filename", NULL
28144 };
28145
28146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28148 if (SWIG_arg_fail(1)) SWIG_fail;
28149 {
28150 arg2 = wxString_in_helper(obj1);
28151 if (arg2 == NULL) SWIG_fail;
28152 temp2 = true;
28153 }
28154 {
28155 PyThreadState* __tstate = wxPyBeginAllowThreads();
28156 (arg1)->AddFile((wxString const &)*arg2);
28157
28158 wxPyEndAllowThreads(__tstate);
28159 if (PyErr_Occurred()) SWIG_fail;
28160 }
28161 Py_INCREF(Py_None); resultobj = Py_None;
28162 {
28163 if (temp2)
28164 delete arg2;
28165 }
28166 return resultobj;
28167 fail:
28168 {
28169 if (temp2)
28170 delete arg2;
28171 }
28172 return NULL;
28173 }
28174
28175
28176 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28177 PyObject *obj;
28178 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28179 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28180 Py_INCREF(obj);
28181 return Py_BuildValue((char *)"");
28182 }
28183 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28184 PyObject *resultobj;
28185 wxDataFormat *arg1 = 0 ;
28186 wxCustomDataObject *result;
28187 PyObject * obj0 = 0 ;
28188
28189 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28190 {
28191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28192 if (SWIG_arg_fail(1)) SWIG_fail;
28193 if (arg1 == NULL) {
28194 SWIG_null_ref("wxDataFormat");
28195 }
28196 if (SWIG_arg_fail(1)) SWIG_fail;
28197 }
28198 {
28199 PyThreadState* __tstate = wxPyBeginAllowThreads();
28200 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28201
28202 wxPyEndAllowThreads(__tstate);
28203 if (PyErr_Occurred()) SWIG_fail;
28204 }
28205 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28206 return resultobj;
28207 fail:
28208 return NULL;
28209 }
28210
28211
28212 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28213 PyObject *resultobj;
28214 wxString *arg1 = 0 ;
28215 wxCustomDataObject *result;
28216 bool temp1 = false ;
28217 PyObject * obj0 = 0 ;
28218
28219 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28220 {
28221 arg1 = wxString_in_helper(obj0);
28222 if (arg1 == NULL) SWIG_fail;
28223 temp1 = true;
28224 }
28225 {
28226 PyThreadState* __tstate = wxPyBeginAllowThreads();
28227 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28228
28229 wxPyEndAllowThreads(__tstate);
28230 if (PyErr_Occurred()) SWIG_fail;
28231 }
28232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28233 {
28234 if (temp1)
28235 delete arg1;
28236 }
28237 return resultobj;
28238 fail:
28239 {
28240 if (temp1)
28241 delete arg1;
28242 }
28243 return NULL;
28244 }
28245
28246
28247 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28248 PyObject *resultobj;
28249 wxCustomDataObject *result;
28250
28251 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28252 {
28253 PyThreadState* __tstate = wxPyBeginAllowThreads();
28254 result = (wxCustomDataObject *)new wxCustomDataObject();
28255
28256 wxPyEndAllowThreads(__tstate);
28257 if (PyErr_Occurred()) SWIG_fail;
28258 }
28259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28260 return resultobj;
28261 fail:
28262 return NULL;
28263 }
28264
28265
28266 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28267 int argc;
28268 PyObject *argv[2];
28269 int ii;
28270
28271 argc = PyObject_Length(args);
28272 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28273 argv[ii] = PyTuple_GetItem(args,ii);
28274 }
28275 if (argc == 0) {
28276 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28277 }
28278 if (argc == 1) {
28279 int _v;
28280 {
28281 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28282 }
28283 if (_v) {
28284 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28285 }
28286 }
28287 if (argc == 1) {
28288 int _v;
28289 {
28290 void *ptr = 0;
28291 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28292 _v = 0;
28293 PyErr_Clear();
28294 } else {
28295 _v = (ptr != 0);
28296 }
28297 }
28298 if (_v) {
28299 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28300 }
28301 }
28302
28303 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28304 return NULL;
28305 }
28306
28307
28308 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28309 PyObject *resultobj;
28310 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28311 PyObject *arg2 = (PyObject *) 0 ;
28312 bool result;
28313 PyObject * obj0 = 0 ;
28314 PyObject * obj1 = 0 ;
28315 char *kwnames[] = {
28316 (char *) "self",(char *) "data", NULL
28317 };
28318
28319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28321 if (SWIG_arg_fail(1)) SWIG_fail;
28322 arg2 = obj1;
28323 {
28324 PyThreadState* __tstate = wxPyBeginAllowThreads();
28325 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28326
28327 wxPyEndAllowThreads(__tstate);
28328 if (PyErr_Occurred()) SWIG_fail;
28329 }
28330 {
28331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28332 }
28333 return resultobj;
28334 fail:
28335 return NULL;
28336 }
28337
28338
28339 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28340 PyObject *resultobj;
28341 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28342 size_t result;
28343 PyObject * obj0 = 0 ;
28344 char *kwnames[] = {
28345 (char *) "self", NULL
28346 };
28347
28348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28350 if (SWIG_arg_fail(1)) SWIG_fail;
28351 {
28352 PyThreadState* __tstate = wxPyBeginAllowThreads();
28353 result = (size_t)(arg1)->GetSize();
28354
28355 wxPyEndAllowThreads(__tstate);
28356 if (PyErr_Occurred()) SWIG_fail;
28357 }
28358 {
28359 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28360 }
28361 return resultobj;
28362 fail:
28363 return NULL;
28364 }
28365
28366
28367 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28368 PyObject *resultobj;
28369 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28370 PyObject *result;
28371 PyObject * obj0 = 0 ;
28372 char *kwnames[] = {
28373 (char *) "self", NULL
28374 };
28375
28376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28378 if (SWIG_arg_fail(1)) SWIG_fail;
28379 {
28380 PyThreadState* __tstate = wxPyBeginAllowThreads();
28381 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28382
28383 wxPyEndAllowThreads(__tstate);
28384 if (PyErr_Occurred()) SWIG_fail;
28385 }
28386 resultobj = result;
28387 return resultobj;
28388 fail:
28389 return NULL;
28390 }
28391
28392
28393 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28394 PyObject *obj;
28395 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28396 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28397 Py_INCREF(obj);
28398 return Py_BuildValue((char *)"");
28399 }
28400 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28401 PyObject *resultobj;
28402 wxURLDataObject *result;
28403 char *kwnames[] = {
28404 NULL
28405 };
28406
28407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28408 {
28409 PyThreadState* __tstate = wxPyBeginAllowThreads();
28410 result = (wxURLDataObject *)new wxURLDataObject();
28411
28412 wxPyEndAllowThreads(__tstate);
28413 if (PyErr_Occurred()) SWIG_fail;
28414 }
28415 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28416 return resultobj;
28417 fail:
28418 return NULL;
28419 }
28420
28421
28422 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28423 PyObject *resultobj;
28424 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28425 wxString result;
28426 PyObject * obj0 = 0 ;
28427 char *kwnames[] = {
28428 (char *) "self", NULL
28429 };
28430
28431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28433 if (SWIG_arg_fail(1)) SWIG_fail;
28434 {
28435 PyThreadState* __tstate = wxPyBeginAllowThreads();
28436 result = (arg1)->GetURL();
28437
28438 wxPyEndAllowThreads(__tstate);
28439 if (PyErr_Occurred()) SWIG_fail;
28440 }
28441 {
28442 #if wxUSE_UNICODE
28443 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28444 #else
28445 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28446 #endif
28447 }
28448 return resultobj;
28449 fail:
28450 return NULL;
28451 }
28452
28453
28454 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28455 PyObject *resultobj;
28456 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28457 wxString *arg2 = 0 ;
28458 bool temp2 = false ;
28459 PyObject * obj0 = 0 ;
28460 PyObject * obj1 = 0 ;
28461 char *kwnames[] = {
28462 (char *) "self",(char *) "url", NULL
28463 };
28464
28465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28467 if (SWIG_arg_fail(1)) SWIG_fail;
28468 {
28469 arg2 = wxString_in_helper(obj1);
28470 if (arg2 == NULL) SWIG_fail;
28471 temp2 = true;
28472 }
28473 {
28474 PyThreadState* __tstate = wxPyBeginAllowThreads();
28475 (arg1)->SetURL((wxString const &)*arg2);
28476
28477 wxPyEndAllowThreads(__tstate);
28478 if (PyErr_Occurred()) SWIG_fail;
28479 }
28480 Py_INCREF(Py_None); resultobj = Py_None;
28481 {
28482 if (temp2)
28483 delete arg2;
28484 }
28485 return resultobj;
28486 fail:
28487 {
28488 if (temp2)
28489 delete arg2;
28490 }
28491 return NULL;
28492 }
28493
28494
28495 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28496 PyObject *obj;
28497 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28498 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28499 Py_INCREF(obj);
28500 return Py_BuildValue((char *)"");
28501 }
28502 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28503 PyObject *resultobj;
28504 wxMetafileDataObject *result;
28505 char *kwnames[] = {
28506 NULL
28507 };
28508
28509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28510 {
28511 PyThreadState* __tstate = wxPyBeginAllowThreads();
28512 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28513
28514 wxPyEndAllowThreads(__tstate);
28515 if (PyErr_Occurred()) SWIG_fail;
28516 }
28517 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28518 return resultobj;
28519 fail:
28520 return NULL;
28521 }
28522
28523
28524 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28525 PyObject *obj;
28526 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28527 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28528 Py_INCREF(obj);
28529 return Py_BuildValue((char *)"");
28530 }
28531 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28532 PyObject *resultobj;
28533 wxDragResult arg1 ;
28534 bool result;
28535 PyObject * obj0 = 0 ;
28536 char *kwnames[] = {
28537 (char *) "res", NULL
28538 };
28539
28540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28541 {
28542 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28543 if (SWIG_arg_fail(1)) SWIG_fail;
28544 }
28545 {
28546 PyThreadState* __tstate = wxPyBeginAllowThreads();
28547 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28548
28549 wxPyEndAllowThreads(__tstate);
28550 if (PyErr_Occurred()) SWIG_fail;
28551 }
28552 {
28553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28554 }
28555 return resultobj;
28556 fail:
28557 return NULL;
28558 }
28559
28560
28561 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28562 PyObject *resultobj;
28563 wxWindow *arg1 = (wxWindow *) 0 ;
28564 wxIcon const &arg2_defvalue = wxNullIcon ;
28565 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
28566 wxIcon const &arg3_defvalue = wxNullIcon ;
28567 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
28568 wxIcon const &arg4_defvalue = wxNullIcon ;
28569 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
28570 wxPyDropSource *result;
28571 PyObject * obj0 = 0 ;
28572 PyObject * obj1 = 0 ;
28573 PyObject * obj2 = 0 ;
28574 PyObject * obj3 = 0 ;
28575 char *kwnames[] = {
28576 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28577 };
28578
28579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28581 if (SWIG_arg_fail(1)) SWIG_fail;
28582 if (obj1) {
28583 {
28584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28585 if (SWIG_arg_fail(2)) SWIG_fail;
28586 if (arg2 == NULL) {
28587 SWIG_null_ref("wxIcon");
28588 }
28589 if (SWIG_arg_fail(2)) SWIG_fail;
28590 }
28591 }
28592 if (obj2) {
28593 {
28594 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28595 if (SWIG_arg_fail(3)) SWIG_fail;
28596 if (arg3 == NULL) {
28597 SWIG_null_ref("wxIcon");
28598 }
28599 if (SWIG_arg_fail(3)) SWIG_fail;
28600 }
28601 }
28602 if (obj3) {
28603 {
28604 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28605 if (SWIG_arg_fail(4)) SWIG_fail;
28606 if (arg4 == NULL) {
28607 SWIG_null_ref("wxIcon");
28608 }
28609 if (SWIG_arg_fail(4)) SWIG_fail;
28610 }
28611 }
28612 {
28613 PyThreadState* __tstate = wxPyBeginAllowThreads();
28614 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
28615
28616 wxPyEndAllowThreads(__tstate);
28617 if (PyErr_Occurred()) SWIG_fail;
28618 }
28619 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28620 return resultobj;
28621 fail:
28622 return NULL;
28623 }
28624
28625
28626 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28627 PyObject *resultobj;
28628 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28629 PyObject *arg2 = (PyObject *) 0 ;
28630 PyObject *arg3 = (PyObject *) 0 ;
28631 int arg4 ;
28632 PyObject * obj0 = 0 ;
28633 PyObject * obj1 = 0 ;
28634 PyObject * obj2 = 0 ;
28635 PyObject * obj3 = 0 ;
28636 char *kwnames[] = {
28637 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28638 };
28639
28640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28642 if (SWIG_arg_fail(1)) SWIG_fail;
28643 arg2 = obj1;
28644 arg3 = obj2;
28645 {
28646 arg4 = (int)(SWIG_As_int(obj3));
28647 if (SWIG_arg_fail(4)) SWIG_fail;
28648 }
28649 {
28650 PyThreadState* __tstate = wxPyBeginAllowThreads();
28651 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28652
28653 wxPyEndAllowThreads(__tstate);
28654 if (PyErr_Occurred()) SWIG_fail;
28655 }
28656 Py_INCREF(Py_None); resultobj = Py_None;
28657 return resultobj;
28658 fail:
28659 return NULL;
28660 }
28661
28662
28663 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28664 PyObject *resultobj;
28665 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28666 PyObject * obj0 = 0 ;
28667 char *kwnames[] = {
28668 (char *) "self", NULL
28669 };
28670
28671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28673 if (SWIG_arg_fail(1)) SWIG_fail;
28674 {
28675 PyThreadState* __tstate = wxPyBeginAllowThreads();
28676 delete arg1;
28677
28678 wxPyEndAllowThreads(__tstate);
28679 if (PyErr_Occurred()) SWIG_fail;
28680 }
28681 Py_INCREF(Py_None); resultobj = Py_None;
28682 return resultobj;
28683 fail:
28684 return NULL;
28685 }
28686
28687
28688 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28689 PyObject *resultobj;
28690 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28691 wxDataObject *arg2 = 0 ;
28692 PyObject * obj0 = 0 ;
28693 PyObject * obj1 = 0 ;
28694 char *kwnames[] = {
28695 (char *) "self",(char *) "data", NULL
28696 };
28697
28698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28700 if (SWIG_arg_fail(1)) SWIG_fail;
28701 {
28702 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28703 if (SWIG_arg_fail(2)) SWIG_fail;
28704 if (arg2 == NULL) {
28705 SWIG_null_ref("wxDataObject");
28706 }
28707 if (SWIG_arg_fail(2)) SWIG_fail;
28708 }
28709 {
28710 PyThreadState* __tstate = wxPyBeginAllowThreads();
28711 (arg1)->SetData(*arg2);
28712
28713 wxPyEndAllowThreads(__tstate);
28714 if (PyErr_Occurred()) SWIG_fail;
28715 }
28716 Py_INCREF(Py_None); resultobj = Py_None;
28717 return resultobj;
28718 fail:
28719 return NULL;
28720 }
28721
28722
28723 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28724 PyObject *resultobj;
28725 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28726 wxDataObject *result;
28727 PyObject * obj0 = 0 ;
28728 char *kwnames[] = {
28729 (char *) "self", NULL
28730 };
28731
28732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28734 if (SWIG_arg_fail(1)) SWIG_fail;
28735 {
28736 PyThreadState* __tstate = wxPyBeginAllowThreads();
28737 result = (wxDataObject *)(arg1)->GetDataObject();
28738
28739 wxPyEndAllowThreads(__tstate);
28740 if (PyErr_Occurred()) SWIG_fail;
28741 }
28742 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28743 return resultobj;
28744 fail:
28745 return NULL;
28746 }
28747
28748
28749 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28750 PyObject *resultobj;
28751 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28752 wxDragResult arg2 ;
28753 wxCursor *arg3 = 0 ;
28754 PyObject * obj0 = 0 ;
28755 PyObject * obj1 = 0 ;
28756 PyObject * obj2 = 0 ;
28757 char *kwnames[] = {
28758 (char *) "self",(char *) "res",(char *) "cursor", NULL
28759 };
28760
28761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28763 if (SWIG_arg_fail(1)) SWIG_fail;
28764 {
28765 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28766 if (SWIG_arg_fail(2)) SWIG_fail;
28767 }
28768 {
28769 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28770 if (SWIG_arg_fail(3)) SWIG_fail;
28771 if (arg3 == NULL) {
28772 SWIG_null_ref("wxCursor");
28773 }
28774 if (SWIG_arg_fail(3)) SWIG_fail;
28775 }
28776 {
28777 PyThreadState* __tstate = wxPyBeginAllowThreads();
28778 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28779
28780 wxPyEndAllowThreads(__tstate);
28781 if (PyErr_Occurred()) SWIG_fail;
28782 }
28783 Py_INCREF(Py_None); resultobj = Py_None;
28784 return resultobj;
28785 fail:
28786 return NULL;
28787 }
28788
28789
28790 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28791 PyObject *resultobj;
28792 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28793 int arg2 = (int) wxDrag_CopyOnly ;
28794 wxDragResult result;
28795 PyObject * obj0 = 0 ;
28796 PyObject * obj1 = 0 ;
28797 char *kwnames[] = {
28798 (char *) "self",(char *) "flags", NULL
28799 };
28800
28801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28803 if (SWIG_arg_fail(1)) SWIG_fail;
28804 if (obj1) {
28805 {
28806 arg2 = (int)(SWIG_As_int(obj1));
28807 if (SWIG_arg_fail(2)) SWIG_fail;
28808 }
28809 }
28810 {
28811 PyThreadState* __tstate = wxPyBeginAllowThreads();
28812 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28813
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 resultobj = SWIG_From_int((result));
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28825 PyObject *resultobj;
28826 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28827 wxDragResult arg2 ;
28828 bool result;
28829 PyObject * obj0 = 0 ;
28830 PyObject * obj1 = 0 ;
28831 char *kwnames[] = {
28832 (char *) "self",(char *) "effect", NULL
28833 };
28834
28835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28837 if (SWIG_arg_fail(1)) SWIG_fail;
28838 {
28839 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28840 if (SWIG_arg_fail(2)) SWIG_fail;
28841 }
28842 {
28843 PyThreadState* __tstate = wxPyBeginAllowThreads();
28844 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28845
28846 wxPyEndAllowThreads(__tstate);
28847 if (PyErr_Occurred()) SWIG_fail;
28848 }
28849 {
28850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28851 }
28852 return resultobj;
28853 fail:
28854 return NULL;
28855 }
28856
28857
28858 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28859 PyObject *obj;
28860 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28861 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28862 Py_INCREF(obj);
28863 return Py_BuildValue((char *)"");
28864 }
28865 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28866 PyObject *resultobj;
28867 wxDataObject *arg1 = (wxDataObject *) NULL ;
28868 wxPyDropTarget *result;
28869 PyObject * obj0 = 0 ;
28870 char *kwnames[] = {
28871 (char *) "dataObject", NULL
28872 };
28873
28874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28875 if (obj0) {
28876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28877 if (SWIG_arg_fail(1)) SWIG_fail;
28878 }
28879 {
28880 PyThreadState* __tstate = wxPyBeginAllowThreads();
28881 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28882
28883 wxPyEndAllowThreads(__tstate);
28884 if (PyErr_Occurred()) SWIG_fail;
28885 }
28886 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28887 return resultobj;
28888 fail:
28889 return NULL;
28890 }
28891
28892
28893 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28894 PyObject *resultobj;
28895 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28896 PyObject *arg2 = (PyObject *) 0 ;
28897 PyObject *arg3 = (PyObject *) 0 ;
28898 PyObject * obj0 = 0 ;
28899 PyObject * obj1 = 0 ;
28900 PyObject * obj2 = 0 ;
28901 char *kwnames[] = {
28902 (char *) "self",(char *) "self",(char *) "_class", NULL
28903 };
28904
28905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28907 if (SWIG_arg_fail(1)) SWIG_fail;
28908 arg2 = obj1;
28909 arg3 = obj2;
28910 {
28911 PyThreadState* __tstate = wxPyBeginAllowThreads();
28912 (arg1)->_setCallbackInfo(arg2,arg3);
28913
28914 wxPyEndAllowThreads(__tstate);
28915 if (PyErr_Occurred()) SWIG_fail;
28916 }
28917 Py_INCREF(Py_None); resultobj = Py_None;
28918 return resultobj;
28919 fail:
28920 return NULL;
28921 }
28922
28923
28924 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28925 PyObject *resultobj;
28926 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28927 PyObject * obj0 = 0 ;
28928 char *kwnames[] = {
28929 (char *) "self", NULL
28930 };
28931
28932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28934 if (SWIG_arg_fail(1)) SWIG_fail;
28935 {
28936 PyThreadState* __tstate = wxPyBeginAllowThreads();
28937 delete arg1;
28938
28939 wxPyEndAllowThreads(__tstate);
28940 if (PyErr_Occurred()) SWIG_fail;
28941 }
28942 Py_INCREF(Py_None); resultobj = Py_None;
28943 return resultobj;
28944 fail:
28945 return NULL;
28946 }
28947
28948
28949 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28950 PyObject *resultobj;
28951 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28952 wxDataObject *result;
28953 PyObject * obj0 = 0 ;
28954 char *kwnames[] = {
28955 (char *) "self", NULL
28956 };
28957
28958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28960 if (SWIG_arg_fail(1)) SWIG_fail;
28961 {
28962 PyThreadState* __tstate = wxPyBeginAllowThreads();
28963 result = (wxDataObject *)(arg1)->GetDataObject();
28964
28965 wxPyEndAllowThreads(__tstate);
28966 if (PyErr_Occurred()) SWIG_fail;
28967 }
28968 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28969 return resultobj;
28970 fail:
28971 return NULL;
28972 }
28973
28974
28975 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28976 PyObject *resultobj;
28977 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28978 wxDataObject *arg2 = (wxDataObject *) 0 ;
28979 PyObject * obj0 = 0 ;
28980 PyObject * obj1 = 0 ;
28981 char *kwnames[] = {
28982 (char *) "self",(char *) "dataObject", NULL
28983 };
28984
28985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28987 if (SWIG_arg_fail(1)) SWIG_fail;
28988 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28989 if (SWIG_arg_fail(2)) SWIG_fail;
28990 {
28991 PyThreadState* __tstate = wxPyBeginAllowThreads();
28992 (arg1)->SetDataObject(arg2);
28993
28994 wxPyEndAllowThreads(__tstate);
28995 if (PyErr_Occurred()) SWIG_fail;
28996 }
28997 Py_INCREF(Py_None); resultobj = Py_None;
28998 return resultobj;
28999 fail:
29000 return NULL;
29001 }
29002
29003
29004 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29005 PyObject *resultobj;
29006 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29007 int arg2 ;
29008 int arg3 ;
29009 wxDragResult arg4 ;
29010 wxDragResult result;
29011 PyObject * obj0 = 0 ;
29012 PyObject * obj1 = 0 ;
29013 PyObject * obj2 = 0 ;
29014 PyObject * obj3 = 0 ;
29015 char *kwnames[] = {
29016 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29017 };
29018
29019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29021 if (SWIG_arg_fail(1)) SWIG_fail;
29022 {
29023 arg2 = (int)(SWIG_As_int(obj1));
29024 if (SWIG_arg_fail(2)) SWIG_fail;
29025 }
29026 {
29027 arg3 = (int)(SWIG_As_int(obj2));
29028 if (SWIG_arg_fail(3)) SWIG_fail;
29029 }
29030 {
29031 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29032 if (SWIG_arg_fail(4)) SWIG_fail;
29033 }
29034 {
29035 PyThreadState* __tstate = wxPyBeginAllowThreads();
29036 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29037
29038 wxPyEndAllowThreads(__tstate);
29039 if (PyErr_Occurred()) SWIG_fail;
29040 }
29041 resultobj = SWIG_From_int((result));
29042 return resultobj;
29043 fail:
29044 return NULL;
29045 }
29046
29047
29048 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29049 PyObject *resultobj;
29050 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29051 int arg2 ;
29052 int arg3 ;
29053 wxDragResult arg4 ;
29054 wxDragResult result;
29055 PyObject * obj0 = 0 ;
29056 PyObject * obj1 = 0 ;
29057 PyObject * obj2 = 0 ;
29058 PyObject * obj3 = 0 ;
29059 char *kwnames[] = {
29060 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29061 };
29062
29063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29065 if (SWIG_arg_fail(1)) SWIG_fail;
29066 {
29067 arg2 = (int)(SWIG_As_int(obj1));
29068 if (SWIG_arg_fail(2)) SWIG_fail;
29069 }
29070 {
29071 arg3 = (int)(SWIG_As_int(obj2));
29072 if (SWIG_arg_fail(3)) SWIG_fail;
29073 }
29074 {
29075 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29076 if (SWIG_arg_fail(4)) SWIG_fail;
29077 }
29078 {
29079 PyThreadState* __tstate = wxPyBeginAllowThreads();
29080 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29081
29082 wxPyEndAllowThreads(__tstate);
29083 if (PyErr_Occurred()) SWIG_fail;
29084 }
29085 resultobj = SWIG_From_int((result));
29086 return resultobj;
29087 fail:
29088 return NULL;
29089 }
29090
29091
29092 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29093 PyObject *resultobj;
29094 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29095 PyObject * obj0 = 0 ;
29096 char *kwnames[] = {
29097 (char *) "self", NULL
29098 };
29099
29100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29102 if (SWIG_arg_fail(1)) SWIG_fail;
29103 {
29104 PyThreadState* __tstate = wxPyBeginAllowThreads();
29105 (arg1)->base_OnLeave();
29106
29107 wxPyEndAllowThreads(__tstate);
29108 if (PyErr_Occurred()) SWIG_fail;
29109 }
29110 Py_INCREF(Py_None); resultobj = Py_None;
29111 return resultobj;
29112 fail:
29113 return NULL;
29114 }
29115
29116
29117 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29118 PyObject *resultobj;
29119 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29120 int arg2 ;
29121 int arg3 ;
29122 bool result;
29123 PyObject * obj0 = 0 ;
29124 PyObject * obj1 = 0 ;
29125 PyObject * obj2 = 0 ;
29126 char *kwnames[] = {
29127 (char *) "self",(char *) "x",(char *) "y", NULL
29128 };
29129
29130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29132 if (SWIG_arg_fail(1)) SWIG_fail;
29133 {
29134 arg2 = (int)(SWIG_As_int(obj1));
29135 if (SWIG_arg_fail(2)) SWIG_fail;
29136 }
29137 {
29138 arg3 = (int)(SWIG_As_int(obj2));
29139 if (SWIG_arg_fail(3)) SWIG_fail;
29140 }
29141 {
29142 PyThreadState* __tstate = wxPyBeginAllowThreads();
29143 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29144
29145 wxPyEndAllowThreads(__tstate);
29146 if (PyErr_Occurred()) SWIG_fail;
29147 }
29148 {
29149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29150 }
29151 return resultobj;
29152 fail:
29153 return NULL;
29154 }
29155
29156
29157 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29158 PyObject *resultobj;
29159 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29160 bool result;
29161 PyObject * obj0 = 0 ;
29162 char *kwnames[] = {
29163 (char *) "self", NULL
29164 };
29165
29166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29168 if (SWIG_arg_fail(1)) SWIG_fail;
29169 {
29170 PyThreadState* __tstate = wxPyBeginAllowThreads();
29171 result = (bool)(arg1)->GetData();
29172
29173 wxPyEndAllowThreads(__tstate);
29174 if (PyErr_Occurred()) SWIG_fail;
29175 }
29176 {
29177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29178 }
29179 return resultobj;
29180 fail:
29181 return NULL;
29182 }
29183
29184
29185 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29186 PyObject *resultobj;
29187 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29188 wxDragResult arg2 ;
29189 PyObject * obj0 = 0 ;
29190 PyObject * obj1 = 0 ;
29191 char *kwnames[] = {
29192 (char *) "self",(char *) "action", NULL
29193 };
29194
29195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29197 if (SWIG_arg_fail(1)) SWIG_fail;
29198 {
29199 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29200 if (SWIG_arg_fail(2)) SWIG_fail;
29201 }
29202 {
29203 PyThreadState* __tstate = wxPyBeginAllowThreads();
29204 (arg1)->SetDefaultAction((wxDragResult )arg2);
29205
29206 wxPyEndAllowThreads(__tstate);
29207 if (PyErr_Occurred()) SWIG_fail;
29208 }
29209 Py_INCREF(Py_None); resultobj = Py_None;
29210 return resultobj;
29211 fail:
29212 return NULL;
29213 }
29214
29215
29216 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29217 PyObject *resultobj;
29218 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29219 wxDragResult result;
29220 PyObject * obj0 = 0 ;
29221 char *kwnames[] = {
29222 (char *) "self", NULL
29223 };
29224
29225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29227 if (SWIG_arg_fail(1)) SWIG_fail;
29228 {
29229 PyThreadState* __tstate = wxPyBeginAllowThreads();
29230 result = (wxDragResult)(arg1)->GetDefaultAction();
29231
29232 wxPyEndAllowThreads(__tstate);
29233 if (PyErr_Occurred()) SWIG_fail;
29234 }
29235 resultobj = SWIG_From_int((result));
29236 return resultobj;
29237 fail:
29238 return NULL;
29239 }
29240
29241
29242 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29243 PyObject *obj;
29244 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29245 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29246 Py_INCREF(obj);
29247 return Py_BuildValue((char *)"");
29248 }
29249 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29250 PyObject *resultobj;
29251 wxPyTextDropTarget *result;
29252 char *kwnames[] = {
29253 NULL
29254 };
29255
29256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29257 {
29258 PyThreadState* __tstate = wxPyBeginAllowThreads();
29259 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29260
29261 wxPyEndAllowThreads(__tstate);
29262 if (PyErr_Occurred()) SWIG_fail;
29263 }
29264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29265 return resultobj;
29266 fail:
29267 return NULL;
29268 }
29269
29270
29271 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29272 PyObject *resultobj;
29273 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29274 PyObject *arg2 = (PyObject *) 0 ;
29275 PyObject *arg3 = (PyObject *) 0 ;
29276 PyObject * obj0 = 0 ;
29277 PyObject * obj1 = 0 ;
29278 PyObject * obj2 = 0 ;
29279 char *kwnames[] = {
29280 (char *) "self",(char *) "self",(char *) "_class", NULL
29281 };
29282
29283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29285 if (SWIG_arg_fail(1)) SWIG_fail;
29286 arg2 = obj1;
29287 arg3 = obj2;
29288 {
29289 PyThreadState* __tstate = wxPyBeginAllowThreads();
29290 (arg1)->_setCallbackInfo(arg2,arg3);
29291
29292 wxPyEndAllowThreads(__tstate);
29293 if (PyErr_Occurred()) SWIG_fail;
29294 }
29295 Py_INCREF(Py_None); resultobj = Py_None;
29296 return resultobj;
29297 fail:
29298 return NULL;
29299 }
29300
29301
29302 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29303 PyObject *resultobj;
29304 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29305 int arg2 ;
29306 int arg3 ;
29307 wxDragResult arg4 ;
29308 wxDragResult result;
29309 PyObject * obj0 = 0 ;
29310 PyObject * obj1 = 0 ;
29311 PyObject * obj2 = 0 ;
29312 PyObject * obj3 = 0 ;
29313 char *kwnames[] = {
29314 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29315 };
29316
29317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29319 if (SWIG_arg_fail(1)) SWIG_fail;
29320 {
29321 arg2 = (int)(SWIG_As_int(obj1));
29322 if (SWIG_arg_fail(2)) SWIG_fail;
29323 }
29324 {
29325 arg3 = (int)(SWIG_As_int(obj2));
29326 if (SWIG_arg_fail(3)) SWIG_fail;
29327 }
29328 {
29329 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29330 if (SWIG_arg_fail(4)) SWIG_fail;
29331 }
29332 {
29333 PyThreadState* __tstate = wxPyBeginAllowThreads();
29334 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29335
29336 wxPyEndAllowThreads(__tstate);
29337 if (PyErr_Occurred()) SWIG_fail;
29338 }
29339 resultobj = SWIG_From_int((result));
29340 return resultobj;
29341 fail:
29342 return NULL;
29343 }
29344
29345
29346 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29347 PyObject *resultobj;
29348 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29349 int arg2 ;
29350 int arg3 ;
29351 wxDragResult arg4 ;
29352 wxDragResult result;
29353 PyObject * obj0 = 0 ;
29354 PyObject * obj1 = 0 ;
29355 PyObject * obj2 = 0 ;
29356 PyObject * obj3 = 0 ;
29357 char *kwnames[] = {
29358 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29359 };
29360
29361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29363 if (SWIG_arg_fail(1)) SWIG_fail;
29364 {
29365 arg2 = (int)(SWIG_As_int(obj1));
29366 if (SWIG_arg_fail(2)) SWIG_fail;
29367 }
29368 {
29369 arg3 = (int)(SWIG_As_int(obj2));
29370 if (SWIG_arg_fail(3)) SWIG_fail;
29371 }
29372 {
29373 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29374 if (SWIG_arg_fail(4)) SWIG_fail;
29375 }
29376 {
29377 PyThreadState* __tstate = wxPyBeginAllowThreads();
29378 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29379
29380 wxPyEndAllowThreads(__tstate);
29381 if (PyErr_Occurred()) SWIG_fail;
29382 }
29383 resultobj = SWIG_From_int((result));
29384 return resultobj;
29385 fail:
29386 return NULL;
29387 }
29388
29389
29390 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29391 PyObject *resultobj;
29392 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29393 PyObject * obj0 = 0 ;
29394 char *kwnames[] = {
29395 (char *) "self", NULL
29396 };
29397
29398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29400 if (SWIG_arg_fail(1)) SWIG_fail;
29401 {
29402 PyThreadState* __tstate = wxPyBeginAllowThreads();
29403 (arg1)->base_OnLeave();
29404
29405 wxPyEndAllowThreads(__tstate);
29406 if (PyErr_Occurred()) SWIG_fail;
29407 }
29408 Py_INCREF(Py_None); resultobj = Py_None;
29409 return resultobj;
29410 fail:
29411 return NULL;
29412 }
29413
29414
29415 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29416 PyObject *resultobj;
29417 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29418 int arg2 ;
29419 int arg3 ;
29420 bool result;
29421 PyObject * obj0 = 0 ;
29422 PyObject * obj1 = 0 ;
29423 PyObject * obj2 = 0 ;
29424 char *kwnames[] = {
29425 (char *) "self",(char *) "x",(char *) "y", NULL
29426 };
29427
29428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29430 if (SWIG_arg_fail(1)) SWIG_fail;
29431 {
29432 arg2 = (int)(SWIG_As_int(obj1));
29433 if (SWIG_arg_fail(2)) SWIG_fail;
29434 }
29435 {
29436 arg3 = (int)(SWIG_As_int(obj2));
29437 if (SWIG_arg_fail(3)) SWIG_fail;
29438 }
29439 {
29440 PyThreadState* __tstate = wxPyBeginAllowThreads();
29441 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29442
29443 wxPyEndAllowThreads(__tstate);
29444 if (PyErr_Occurred()) SWIG_fail;
29445 }
29446 {
29447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29448 }
29449 return resultobj;
29450 fail:
29451 return NULL;
29452 }
29453
29454
29455 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29456 PyObject *resultobj;
29457 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29458 int arg2 ;
29459 int arg3 ;
29460 wxDragResult arg4 ;
29461 wxDragResult result;
29462 PyObject * obj0 = 0 ;
29463 PyObject * obj1 = 0 ;
29464 PyObject * obj2 = 0 ;
29465 PyObject * obj3 = 0 ;
29466 char *kwnames[] = {
29467 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29468 };
29469
29470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29472 if (SWIG_arg_fail(1)) SWIG_fail;
29473 {
29474 arg2 = (int)(SWIG_As_int(obj1));
29475 if (SWIG_arg_fail(2)) SWIG_fail;
29476 }
29477 {
29478 arg3 = (int)(SWIG_As_int(obj2));
29479 if (SWIG_arg_fail(3)) SWIG_fail;
29480 }
29481 {
29482 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29483 if (SWIG_arg_fail(4)) SWIG_fail;
29484 }
29485 {
29486 PyThreadState* __tstate = wxPyBeginAllowThreads();
29487 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29488
29489 wxPyEndAllowThreads(__tstate);
29490 if (PyErr_Occurred()) SWIG_fail;
29491 }
29492 resultobj = SWIG_From_int((result));
29493 return resultobj;
29494 fail:
29495 return NULL;
29496 }
29497
29498
29499 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29500 PyObject *obj;
29501 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29502 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29503 Py_INCREF(obj);
29504 return Py_BuildValue((char *)"");
29505 }
29506 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29507 PyObject *resultobj;
29508 wxPyFileDropTarget *result;
29509 char *kwnames[] = {
29510 NULL
29511 };
29512
29513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29514 {
29515 PyThreadState* __tstate = wxPyBeginAllowThreads();
29516 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29517
29518 wxPyEndAllowThreads(__tstate);
29519 if (PyErr_Occurred()) SWIG_fail;
29520 }
29521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29522 return resultobj;
29523 fail:
29524 return NULL;
29525 }
29526
29527
29528 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29529 PyObject *resultobj;
29530 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29531 PyObject *arg2 = (PyObject *) 0 ;
29532 PyObject *arg3 = (PyObject *) 0 ;
29533 PyObject * obj0 = 0 ;
29534 PyObject * obj1 = 0 ;
29535 PyObject * obj2 = 0 ;
29536 char *kwnames[] = {
29537 (char *) "self",(char *) "self",(char *) "_class", NULL
29538 };
29539
29540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29542 if (SWIG_arg_fail(1)) SWIG_fail;
29543 arg2 = obj1;
29544 arg3 = obj2;
29545 {
29546 PyThreadState* __tstate = wxPyBeginAllowThreads();
29547 (arg1)->_setCallbackInfo(arg2,arg3);
29548
29549 wxPyEndAllowThreads(__tstate);
29550 if (PyErr_Occurred()) SWIG_fail;
29551 }
29552 Py_INCREF(Py_None); resultobj = Py_None;
29553 return resultobj;
29554 fail:
29555 return NULL;
29556 }
29557
29558
29559 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29560 PyObject *resultobj;
29561 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29562 int arg2 ;
29563 int arg3 ;
29564 wxDragResult arg4 ;
29565 wxDragResult result;
29566 PyObject * obj0 = 0 ;
29567 PyObject * obj1 = 0 ;
29568 PyObject * obj2 = 0 ;
29569 PyObject * obj3 = 0 ;
29570 char *kwnames[] = {
29571 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29572 };
29573
29574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29576 if (SWIG_arg_fail(1)) SWIG_fail;
29577 {
29578 arg2 = (int)(SWIG_As_int(obj1));
29579 if (SWIG_arg_fail(2)) SWIG_fail;
29580 }
29581 {
29582 arg3 = (int)(SWIG_As_int(obj2));
29583 if (SWIG_arg_fail(3)) SWIG_fail;
29584 }
29585 {
29586 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29587 if (SWIG_arg_fail(4)) SWIG_fail;
29588 }
29589 {
29590 PyThreadState* __tstate = wxPyBeginAllowThreads();
29591 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29592
29593 wxPyEndAllowThreads(__tstate);
29594 if (PyErr_Occurred()) SWIG_fail;
29595 }
29596 resultobj = SWIG_From_int((result));
29597 return resultobj;
29598 fail:
29599 return NULL;
29600 }
29601
29602
29603 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29604 PyObject *resultobj;
29605 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29606 int arg2 ;
29607 int arg3 ;
29608 wxDragResult arg4 ;
29609 wxDragResult result;
29610 PyObject * obj0 = 0 ;
29611 PyObject * obj1 = 0 ;
29612 PyObject * obj2 = 0 ;
29613 PyObject * obj3 = 0 ;
29614 char *kwnames[] = {
29615 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29616 };
29617
29618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29620 if (SWIG_arg_fail(1)) SWIG_fail;
29621 {
29622 arg2 = (int)(SWIG_As_int(obj1));
29623 if (SWIG_arg_fail(2)) SWIG_fail;
29624 }
29625 {
29626 arg3 = (int)(SWIG_As_int(obj2));
29627 if (SWIG_arg_fail(3)) SWIG_fail;
29628 }
29629 {
29630 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29631 if (SWIG_arg_fail(4)) SWIG_fail;
29632 }
29633 {
29634 PyThreadState* __tstate = wxPyBeginAllowThreads();
29635 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29636
29637 wxPyEndAllowThreads(__tstate);
29638 if (PyErr_Occurred()) SWIG_fail;
29639 }
29640 resultobj = SWIG_From_int((result));
29641 return resultobj;
29642 fail:
29643 return NULL;
29644 }
29645
29646
29647 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29648 PyObject *resultobj;
29649 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29650 PyObject * obj0 = 0 ;
29651 char *kwnames[] = {
29652 (char *) "self", NULL
29653 };
29654
29655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29657 if (SWIG_arg_fail(1)) SWIG_fail;
29658 {
29659 PyThreadState* __tstate = wxPyBeginAllowThreads();
29660 (arg1)->base_OnLeave();
29661
29662 wxPyEndAllowThreads(__tstate);
29663 if (PyErr_Occurred()) SWIG_fail;
29664 }
29665 Py_INCREF(Py_None); resultobj = Py_None;
29666 return resultobj;
29667 fail:
29668 return NULL;
29669 }
29670
29671
29672 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29673 PyObject *resultobj;
29674 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29675 int arg2 ;
29676 int arg3 ;
29677 bool result;
29678 PyObject * obj0 = 0 ;
29679 PyObject * obj1 = 0 ;
29680 PyObject * obj2 = 0 ;
29681 char *kwnames[] = {
29682 (char *) "self",(char *) "x",(char *) "y", NULL
29683 };
29684
29685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29687 if (SWIG_arg_fail(1)) SWIG_fail;
29688 {
29689 arg2 = (int)(SWIG_As_int(obj1));
29690 if (SWIG_arg_fail(2)) SWIG_fail;
29691 }
29692 {
29693 arg3 = (int)(SWIG_As_int(obj2));
29694 if (SWIG_arg_fail(3)) SWIG_fail;
29695 }
29696 {
29697 PyThreadState* __tstate = wxPyBeginAllowThreads();
29698 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29699
29700 wxPyEndAllowThreads(__tstate);
29701 if (PyErr_Occurred()) SWIG_fail;
29702 }
29703 {
29704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29705 }
29706 return resultobj;
29707 fail:
29708 return NULL;
29709 }
29710
29711
29712 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29713 PyObject *resultobj;
29714 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29715 int arg2 ;
29716 int arg3 ;
29717 wxDragResult arg4 ;
29718 wxDragResult result;
29719 PyObject * obj0 = 0 ;
29720 PyObject * obj1 = 0 ;
29721 PyObject * obj2 = 0 ;
29722 PyObject * obj3 = 0 ;
29723 char *kwnames[] = {
29724 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29725 };
29726
29727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29729 if (SWIG_arg_fail(1)) SWIG_fail;
29730 {
29731 arg2 = (int)(SWIG_As_int(obj1));
29732 if (SWIG_arg_fail(2)) SWIG_fail;
29733 }
29734 {
29735 arg3 = (int)(SWIG_As_int(obj2));
29736 if (SWIG_arg_fail(3)) SWIG_fail;
29737 }
29738 {
29739 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29740 if (SWIG_arg_fail(4)) SWIG_fail;
29741 }
29742 {
29743 PyThreadState* __tstate = wxPyBeginAllowThreads();
29744 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29745
29746 wxPyEndAllowThreads(__tstate);
29747 if (PyErr_Occurred()) SWIG_fail;
29748 }
29749 resultobj = SWIG_From_int((result));
29750 return resultobj;
29751 fail:
29752 return NULL;
29753 }
29754
29755
29756 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29757 PyObject *obj;
29758 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29759 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29760 Py_INCREF(obj);
29761 return Py_BuildValue((char *)"");
29762 }
29763 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29764 PyObject *resultobj;
29765 wxClipboard *result;
29766 char *kwnames[] = {
29767 NULL
29768 };
29769
29770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29771 {
29772 PyThreadState* __tstate = wxPyBeginAllowThreads();
29773 result = (wxClipboard *)new wxClipboard();
29774
29775 wxPyEndAllowThreads(__tstate);
29776 if (PyErr_Occurred()) SWIG_fail;
29777 }
29778 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29779 return resultobj;
29780 fail:
29781 return NULL;
29782 }
29783
29784
29785 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29786 PyObject *resultobj;
29787 wxClipboard *arg1 = (wxClipboard *) 0 ;
29788 PyObject * obj0 = 0 ;
29789 char *kwnames[] = {
29790 (char *) "self", NULL
29791 };
29792
29793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29795 if (SWIG_arg_fail(1)) SWIG_fail;
29796 {
29797 PyThreadState* __tstate = wxPyBeginAllowThreads();
29798 delete arg1;
29799
29800 wxPyEndAllowThreads(__tstate);
29801 if (PyErr_Occurred()) SWIG_fail;
29802 }
29803 Py_INCREF(Py_None); resultobj = Py_None;
29804 return resultobj;
29805 fail:
29806 return NULL;
29807 }
29808
29809
29810 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29811 PyObject *resultobj;
29812 wxClipboard *arg1 = (wxClipboard *) 0 ;
29813 bool result;
29814 PyObject * obj0 = 0 ;
29815 char *kwnames[] = {
29816 (char *) "self", NULL
29817 };
29818
29819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29821 if (SWIG_arg_fail(1)) SWIG_fail;
29822 {
29823 PyThreadState* __tstate = wxPyBeginAllowThreads();
29824 result = (bool)(arg1)->Open();
29825
29826 wxPyEndAllowThreads(__tstate);
29827 if (PyErr_Occurred()) SWIG_fail;
29828 }
29829 {
29830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29831 }
29832 return resultobj;
29833 fail:
29834 return NULL;
29835 }
29836
29837
29838 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29839 PyObject *resultobj;
29840 wxClipboard *arg1 = (wxClipboard *) 0 ;
29841 PyObject * obj0 = 0 ;
29842 char *kwnames[] = {
29843 (char *) "self", NULL
29844 };
29845
29846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29848 if (SWIG_arg_fail(1)) SWIG_fail;
29849 {
29850 PyThreadState* __tstate = wxPyBeginAllowThreads();
29851 (arg1)->Close();
29852
29853 wxPyEndAllowThreads(__tstate);
29854 if (PyErr_Occurred()) SWIG_fail;
29855 }
29856 Py_INCREF(Py_None); resultobj = Py_None;
29857 return resultobj;
29858 fail:
29859 return NULL;
29860 }
29861
29862
29863 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29864 PyObject *resultobj;
29865 wxClipboard *arg1 = (wxClipboard *) 0 ;
29866 bool result;
29867 PyObject * obj0 = 0 ;
29868 char *kwnames[] = {
29869 (char *) "self", NULL
29870 };
29871
29872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29874 if (SWIG_arg_fail(1)) SWIG_fail;
29875 {
29876 PyThreadState* __tstate = wxPyBeginAllowThreads();
29877 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29878
29879 wxPyEndAllowThreads(__tstate);
29880 if (PyErr_Occurred()) SWIG_fail;
29881 }
29882 {
29883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29884 }
29885 return resultobj;
29886 fail:
29887 return NULL;
29888 }
29889
29890
29891 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29892 PyObject *resultobj;
29893 wxClipboard *arg1 = (wxClipboard *) 0 ;
29894 wxDataObject *arg2 = (wxDataObject *) 0 ;
29895 bool result;
29896 PyObject * obj0 = 0 ;
29897 PyObject * obj1 = 0 ;
29898 char *kwnames[] = {
29899 (char *) "self",(char *) "data", NULL
29900 };
29901
29902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29904 if (SWIG_arg_fail(1)) SWIG_fail;
29905 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29906 if (SWIG_arg_fail(2)) SWIG_fail;
29907 {
29908 PyThreadState* __tstate = wxPyBeginAllowThreads();
29909 result = (bool)(arg1)->AddData(arg2);
29910
29911 wxPyEndAllowThreads(__tstate);
29912 if (PyErr_Occurred()) SWIG_fail;
29913 }
29914 {
29915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29916 }
29917 return resultobj;
29918 fail:
29919 return NULL;
29920 }
29921
29922
29923 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29924 PyObject *resultobj;
29925 wxClipboard *arg1 = (wxClipboard *) 0 ;
29926 wxDataObject *arg2 = (wxDataObject *) 0 ;
29927 bool result;
29928 PyObject * obj0 = 0 ;
29929 PyObject * obj1 = 0 ;
29930 char *kwnames[] = {
29931 (char *) "self",(char *) "data", NULL
29932 };
29933
29934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29938 if (SWIG_arg_fail(2)) SWIG_fail;
29939 {
29940 PyThreadState* __tstate = wxPyBeginAllowThreads();
29941 result = (bool)(arg1)->SetData(arg2);
29942
29943 wxPyEndAllowThreads(__tstate);
29944 if (PyErr_Occurred()) SWIG_fail;
29945 }
29946 {
29947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29948 }
29949 return resultobj;
29950 fail:
29951 return NULL;
29952 }
29953
29954
29955 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29956 PyObject *resultobj;
29957 wxClipboard *arg1 = (wxClipboard *) 0 ;
29958 wxDataFormat *arg2 = 0 ;
29959 bool result;
29960 PyObject * obj0 = 0 ;
29961 PyObject * obj1 = 0 ;
29962 char *kwnames[] = {
29963 (char *) "self",(char *) "format", NULL
29964 };
29965
29966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29968 if (SWIG_arg_fail(1)) SWIG_fail;
29969 {
29970 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29971 if (SWIG_arg_fail(2)) SWIG_fail;
29972 if (arg2 == NULL) {
29973 SWIG_null_ref("wxDataFormat");
29974 }
29975 if (SWIG_arg_fail(2)) SWIG_fail;
29976 }
29977 {
29978 PyThreadState* __tstate = wxPyBeginAllowThreads();
29979 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29980
29981 wxPyEndAllowThreads(__tstate);
29982 if (PyErr_Occurred()) SWIG_fail;
29983 }
29984 {
29985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29986 }
29987 return resultobj;
29988 fail:
29989 return NULL;
29990 }
29991
29992
29993 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29994 PyObject *resultobj;
29995 wxClipboard *arg1 = (wxClipboard *) 0 ;
29996 wxDataObject *arg2 = 0 ;
29997 bool result;
29998 PyObject * obj0 = 0 ;
29999 PyObject * obj1 = 0 ;
30000 char *kwnames[] = {
30001 (char *) "self",(char *) "data", NULL
30002 };
30003
30004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30006 if (SWIG_arg_fail(1)) SWIG_fail;
30007 {
30008 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30009 if (SWIG_arg_fail(2)) SWIG_fail;
30010 if (arg2 == NULL) {
30011 SWIG_null_ref("wxDataObject");
30012 }
30013 if (SWIG_arg_fail(2)) SWIG_fail;
30014 }
30015 {
30016 PyThreadState* __tstate = wxPyBeginAllowThreads();
30017 result = (bool)(arg1)->GetData(*arg2);
30018
30019 wxPyEndAllowThreads(__tstate);
30020 if (PyErr_Occurred()) SWIG_fail;
30021 }
30022 {
30023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30024 }
30025 return resultobj;
30026 fail:
30027 return NULL;
30028 }
30029
30030
30031 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30032 PyObject *resultobj;
30033 wxClipboard *arg1 = (wxClipboard *) 0 ;
30034 PyObject * obj0 = 0 ;
30035 char *kwnames[] = {
30036 (char *) "self", NULL
30037 };
30038
30039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30041 if (SWIG_arg_fail(1)) SWIG_fail;
30042 {
30043 PyThreadState* __tstate = wxPyBeginAllowThreads();
30044 (arg1)->Clear();
30045
30046 wxPyEndAllowThreads(__tstate);
30047 if (PyErr_Occurred()) SWIG_fail;
30048 }
30049 Py_INCREF(Py_None); resultobj = Py_None;
30050 return resultobj;
30051 fail:
30052 return NULL;
30053 }
30054
30055
30056 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30057 PyObject *resultobj;
30058 wxClipboard *arg1 = (wxClipboard *) 0 ;
30059 bool result;
30060 PyObject * obj0 = 0 ;
30061 char *kwnames[] = {
30062 (char *) "self", NULL
30063 };
30064
30065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30067 if (SWIG_arg_fail(1)) SWIG_fail;
30068 {
30069 PyThreadState* __tstate = wxPyBeginAllowThreads();
30070 result = (bool)(arg1)->Flush();
30071
30072 wxPyEndAllowThreads(__tstate);
30073 if (PyErr_Occurred()) SWIG_fail;
30074 }
30075 {
30076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30077 }
30078 return resultobj;
30079 fail:
30080 return NULL;
30081 }
30082
30083
30084 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30085 PyObject *resultobj;
30086 wxClipboard *arg1 = (wxClipboard *) 0 ;
30087 bool arg2 = (bool) true ;
30088 PyObject * obj0 = 0 ;
30089 PyObject * obj1 = 0 ;
30090 char *kwnames[] = {
30091 (char *) "self",(char *) "primary", NULL
30092 };
30093
30094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30096 if (SWIG_arg_fail(1)) SWIG_fail;
30097 if (obj1) {
30098 {
30099 arg2 = (bool)(SWIG_As_bool(obj1));
30100 if (SWIG_arg_fail(2)) SWIG_fail;
30101 }
30102 }
30103 {
30104 PyThreadState* __tstate = wxPyBeginAllowThreads();
30105 (arg1)->UsePrimarySelection(arg2);
30106
30107 wxPyEndAllowThreads(__tstate);
30108 if (PyErr_Occurred()) SWIG_fail;
30109 }
30110 Py_INCREF(Py_None); resultobj = Py_None;
30111 return resultobj;
30112 fail:
30113 return NULL;
30114 }
30115
30116
30117 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30118 PyObject *resultobj;
30119 wxClipboard *result;
30120 char *kwnames[] = {
30121 NULL
30122 };
30123
30124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30125 {
30126 PyThreadState* __tstate = wxPyBeginAllowThreads();
30127 result = (wxClipboard *)wxClipboard::Get();
30128
30129 wxPyEndAllowThreads(__tstate);
30130 if (PyErr_Occurred()) SWIG_fail;
30131 }
30132 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30133 return resultobj;
30134 fail:
30135 return NULL;
30136 }
30137
30138
30139 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30140 PyObject *obj;
30141 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30142 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30143 Py_INCREF(obj);
30144 return Py_BuildValue((char *)"");
30145 }
30146 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30147 PyObject *resultobj;
30148 wxClipboard *arg1 = (wxClipboard *) NULL ;
30149 wxClipboardLocker *result;
30150 PyObject * obj0 = 0 ;
30151 char *kwnames[] = {
30152 (char *) "clipboard", NULL
30153 };
30154
30155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30156 if (obj0) {
30157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30158 if (SWIG_arg_fail(1)) SWIG_fail;
30159 }
30160 {
30161 PyThreadState* __tstate = wxPyBeginAllowThreads();
30162 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30163
30164 wxPyEndAllowThreads(__tstate);
30165 if (PyErr_Occurred()) SWIG_fail;
30166 }
30167 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30168 return resultobj;
30169 fail:
30170 return NULL;
30171 }
30172
30173
30174 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30175 PyObject *resultobj;
30176 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30177 PyObject * obj0 = 0 ;
30178 char *kwnames[] = {
30179 (char *) "self", NULL
30180 };
30181
30182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30184 if (SWIG_arg_fail(1)) SWIG_fail;
30185 {
30186 PyThreadState* __tstate = wxPyBeginAllowThreads();
30187 delete arg1;
30188
30189 wxPyEndAllowThreads(__tstate);
30190 if (PyErr_Occurred()) SWIG_fail;
30191 }
30192 Py_INCREF(Py_None); resultobj = Py_None;
30193 return resultobj;
30194 fail:
30195 return NULL;
30196 }
30197
30198
30199 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30200 PyObject *resultobj;
30201 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30202 bool result;
30203 PyObject * obj0 = 0 ;
30204 char *kwnames[] = {
30205 (char *) "self", NULL
30206 };
30207
30208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30210 if (SWIG_arg_fail(1)) SWIG_fail;
30211 {
30212 PyThreadState* __tstate = wxPyBeginAllowThreads();
30213 result = (bool)wxClipboardLocker___nonzero__(arg1);
30214
30215 wxPyEndAllowThreads(__tstate);
30216 if (PyErr_Occurred()) SWIG_fail;
30217 }
30218 {
30219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30220 }
30221 return resultobj;
30222 fail:
30223 return NULL;
30224 }
30225
30226
30227 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30228 PyObject *obj;
30229 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30230 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30231 Py_INCREF(obj);
30232 return Py_BuildValue((char *)"");
30233 }
30234 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30235 PyObject *resultobj;
30236 int arg1 = (int) 0 ;
30237 int arg2 = (int) 0 ;
30238 int arg3 = (int) 0 ;
30239 int arg4 = (int) 0 ;
30240 wxVideoMode *result;
30241 PyObject * obj0 = 0 ;
30242 PyObject * obj1 = 0 ;
30243 PyObject * obj2 = 0 ;
30244 PyObject * obj3 = 0 ;
30245 char *kwnames[] = {
30246 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30247 };
30248
30249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30250 if (obj0) {
30251 {
30252 arg1 = (int)(SWIG_As_int(obj0));
30253 if (SWIG_arg_fail(1)) SWIG_fail;
30254 }
30255 }
30256 if (obj1) {
30257 {
30258 arg2 = (int)(SWIG_As_int(obj1));
30259 if (SWIG_arg_fail(2)) SWIG_fail;
30260 }
30261 }
30262 if (obj2) {
30263 {
30264 arg3 = (int)(SWIG_As_int(obj2));
30265 if (SWIG_arg_fail(3)) SWIG_fail;
30266 }
30267 }
30268 if (obj3) {
30269 {
30270 arg4 = (int)(SWIG_As_int(obj3));
30271 if (SWIG_arg_fail(4)) SWIG_fail;
30272 }
30273 }
30274 {
30275 PyThreadState* __tstate = wxPyBeginAllowThreads();
30276 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30277
30278 wxPyEndAllowThreads(__tstate);
30279 if (PyErr_Occurred()) SWIG_fail;
30280 }
30281 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30282 return resultobj;
30283 fail:
30284 return NULL;
30285 }
30286
30287
30288 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30289 PyObject *resultobj;
30290 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30291 PyObject * obj0 = 0 ;
30292 char *kwnames[] = {
30293 (char *) "self", NULL
30294 };
30295
30296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30298 if (SWIG_arg_fail(1)) SWIG_fail;
30299 {
30300 PyThreadState* __tstate = wxPyBeginAllowThreads();
30301 delete arg1;
30302
30303 wxPyEndAllowThreads(__tstate);
30304 if (PyErr_Occurred()) SWIG_fail;
30305 }
30306 Py_INCREF(Py_None); resultobj = Py_None;
30307 return resultobj;
30308 fail:
30309 return NULL;
30310 }
30311
30312
30313 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30314 PyObject *resultobj;
30315 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30316 wxVideoMode *arg2 = 0 ;
30317 bool result;
30318 PyObject * obj0 = 0 ;
30319 PyObject * obj1 = 0 ;
30320 char *kwnames[] = {
30321 (char *) "self",(char *) "other", NULL
30322 };
30323
30324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30326 if (SWIG_arg_fail(1)) SWIG_fail;
30327 {
30328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30329 if (SWIG_arg_fail(2)) SWIG_fail;
30330 if (arg2 == NULL) {
30331 SWIG_null_ref("wxVideoMode");
30332 }
30333 if (SWIG_arg_fail(2)) SWIG_fail;
30334 }
30335 {
30336 PyThreadState* __tstate = wxPyBeginAllowThreads();
30337 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30338
30339 wxPyEndAllowThreads(__tstate);
30340 if (PyErr_Occurred()) SWIG_fail;
30341 }
30342 {
30343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30344 }
30345 return resultobj;
30346 fail:
30347 return NULL;
30348 }
30349
30350
30351 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30352 PyObject *resultobj;
30353 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30354 int result;
30355 PyObject * obj0 = 0 ;
30356 char *kwnames[] = {
30357 (char *) "self", NULL
30358 };
30359
30360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30362 if (SWIG_arg_fail(1)) SWIG_fail;
30363 {
30364 PyThreadState* __tstate = wxPyBeginAllowThreads();
30365 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30366
30367 wxPyEndAllowThreads(__tstate);
30368 if (PyErr_Occurred()) SWIG_fail;
30369 }
30370 {
30371 resultobj = SWIG_From_int((int)(result));
30372 }
30373 return resultobj;
30374 fail:
30375 return NULL;
30376 }
30377
30378
30379 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30380 PyObject *resultobj;
30381 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30382 int result;
30383 PyObject * obj0 = 0 ;
30384 char *kwnames[] = {
30385 (char *) "self", NULL
30386 };
30387
30388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30390 if (SWIG_arg_fail(1)) SWIG_fail;
30391 {
30392 PyThreadState* __tstate = wxPyBeginAllowThreads();
30393 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30394
30395 wxPyEndAllowThreads(__tstate);
30396 if (PyErr_Occurred()) SWIG_fail;
30397 }
30398 {
30399 resultobj = SWIG_From_int((int)(result));
30400 }
30401 return resultobj;
30402 fail:
30403 return NULL;
30404 }
30405
30406
30407 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30408 PyObject *resultobj;
30409 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30410 int result;
30411 PyObject * obj0 = 0 ;
30412 char *kwnames[] = {
30413 (char *) "self", NULL
30414 };
30415
30416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30418 if (SWIG_arg_fail(1)) SWIG_fail;
30419 {
30420 PyThreadState* __tstate = wxPyBeginAllowThreads();
30421 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30422
30423 wxPyEndAllowThreads(__tstate);
30424 if (PyErr_Occurred()) SWIG_fail;
30425 }
30426 {
30427 resultobj = SWIG_From_int((int)(result));
30428 }
30429 return resultobj;
30430 fail:
30431 return NULL;
30432 }
30433
30434
30435 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30436 PyObject *resultobj;
30437 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30438 bool result;
30439 PyObject * obj0 = 0 ;
30440 char *kwnames[] = {
30441 (char *) "self", NULL
30442 };
30443
30444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30446 if (SWIG_arg_fail(1)) SWIG_fail;
30447 {
30448 PyThreadState* __tstate = wxPyBeginAllowThreads();
30449 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30450
30451 wxPyEndAllowThreads(__tstate);
30452 if (PyErr_Occurred()) SWIG_fail;
30453 }
30454 {
30455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30456 }
30457 return resultobj;
30458 fail:
30459 return NULL;
30460 }
30461
30462
30463 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30464 PyObject *resultobj;
30465 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30466 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30467 bool result;
30468 PyObject * obj0 = 0 ;
30469 PyObject * obj1 = 0 ;
30470 char *kwnames[] = {
30471 (char *) "self",(char *) "other", NULL
30472 };
30473
30474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30476 if (SWIG_arg_fail(1)) SWIG_fail;
30477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30478 if (SWIG_arg_fail(2)) SWIG_fail;
30479 {
30480 PyThreadState* __tstate = wxPyBeginAllowThreads();
30481 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30482
30483 wxPyEndAllowThreads(__tstate);
30484 if (PyErr_Occurred()) SWIG_fail;
30485 }
30486 {
30487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30488 }
30489 return resultobj;
30490 fail:
30491 return NULL;
30492 }
30493
30494
30495 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30496 PyObject *resultobj;
30497 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30498 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30499 bool result;
30500 PyObject * obj0 = 0 ;
30501 PyObject * obj1 = 0 ;
30502 char *kwnames[] = {
30503 (char *) "self",(char *) "other", NULL
30504 };
30505
30506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30508 if (SWIG_arg_fail(1)) SWIG_fail;
30509 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30510 if (SWIG_arg_fail(2)) SWIG_fail;
30511 {
30512 PyThreadState* __tstate = wxPyBeginAllowThreads();
30513 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30514
30515 wxPyEndAllowThreads(__tstate);
30516 if (PyErr_Occurred()) SWIG_fail;
30517 }
30518 {
30519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30520 }
30521 return resultobj;
30522 fail:
30523 return NULL;
30524 }
30525
30526
30527 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30528 PyObject *resultobj;
30529 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30530 int arg2 ;
30531 PyObject * obj0 = 0 ;
30532 PyObject * obj1 = 0 ;
30533 char *kwnames[] = {
30534 (char *) "self",(char *) "w", NULL
30535 };
30536
30537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30539 if (SWIG_arg_fail(1)) SWIG_fail;
30540 {
30541 arg2 = (int)(SWIG_As_int(obj1));
30542 if (SWIG_arg_fail(2)) SWIG_fail;
30543 }
30544 if (arg1) (arg1)->w = arg2;
30545
30546 Py_INCREF(Py_None); resultobj = Py_None;
30547 return resultobj;
30548 fail:
30549 return NULL;
30550 }
30551
30552
30553 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30554 PyObject *resultobj;
30555 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30556 int result;
30557 PyObject * obj0 = 0 ;
30558 char *kwnames[] = {
30559 (char *) "self", NULL
30560 };
30561
30562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30564 if (SWIG_arg_fail(1)) SWIG_fail;
30565 result = (int) ((arg1)->w);
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_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30577 PyObject *resultobj;
30578 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30579 int arg2 ;
30580 PyObject * obj0 = 0 ;
30581 PyObject * obj1 = 0 ;
30582 char *kwnames[] = {
30583 (char *) "self",(char *) "h", NULL
30584 };
30585
30586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30588 if (SWIG_arg_fail(1)) SWIG_fail;
30589 {
30590 arg2 = (int)(SWIG_As_int(obj1));
30591 if (SWIG_arg_fail(2)) SWIG_fail;
30592 }
30593 if (arg1) (arg1)->h = arg2;
30594
30595 Py_INCREF(Py_None); resultobj = Py_None;
30596 return resultobj;
30597 fail:
30598 return NULL;
30599 }
30600
30601
30602 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30603 PyObject *resultobj;
30604 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30605 int result;
30606 PyObject * obj0 = 0 ;
30607 char *kwnames[] = {
30608 (char *) "self", NULL
30609 };
30610
30611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30613 if (SWIG_arg_fail(1)) SWIG_fail;
30614 result = (int) ((arg1)->h);
30615
30616 {
30617 resultobj = SWIG_From_int((int)(result));
30618 }
30619 return resultobj;
30620 fail:
30621 return NULL;
30622 }
30623
30624
30625 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30626 PyObject *resultobj;
30627 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30628 int arg2 ;
30629 PyObject * obj0 = 0 ;
30630 PyObject * obj1 = 0 ;
30631 char *kwnames[] = {
30632 (char *) "self",(char *) "bpp", NULL
30633 };
30634
30635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30637 if (SWIG_arg_fail(1)) SWIG_fail;
30638 {
30639 arg2 = (int)(SWIG_As_int(obj1));
30640 if (SWIG_arg_fail(2)) SWIG_fail;
30641 }
30642 if (arg1) (arg1)->bpp = arg2;
30643
30644 Py_INCREF(Py_None); resultobj = Py_None;
30645 return resultobj;
30646 fail:
30647 return NULL;
30648 }
30649
30650
30651 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30652 PyObject *resultobj;
30653 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30654 int result;
30655 PyObject * obj0 = 0 ;
30656 char *kwnames[] = {
30657 (char *) "self", NULL
30658 };
30659
30660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30662 if (SWIG_arg_fail(1)) SWIG_fail;
30663 result = (int) ((arg1)->bpp);
30664
30665 {
30666 resultobj = SWIG_From_int((int)(result));
30667 }
30668 return resultobj;
30669 fail:
30670 return NULL;
30671 }
30672
30673
30674 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30675 PyObject *resultobj;
30676 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30677 int arg2 ;
30678 PyObject * obj0 = 0 ;
30679 PyObject * obj1 = 0 ;
30680 char *kwnames[] = {
30681 (char *) "self",(char *) "refresh", NULL
30682 };
30683
30684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30686 if (SWIG_arg_fail(1)) SWIG_fail;
30687 {
30688 arg2 = (int)(SWIG_As_int(obj1));
30689 if (SWIG_arg_fail(2)) SWIG_fail;
30690 }
30691 if (arg1) (arg1)->refresh = arg2;
30692
30693 Py_INCREF(Py_None); resultobj = Py_None;
30694 return resultobj;
30695 fail:
30696 return NULL;
30697 }
30698
30699
30700 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30701 PyObject *resultobj;
30702 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30703 int result;
30704 PyObject * obj0 = 0 ;
30705 char *kwnames[] = {
30706 (char *) "self", NULL
30707 };
30708
30709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30711 if (SWIG_arg_fail(1)) SWIG_fail;
30712 result = (int) ((arg1)->refresh);
30713
30714 {
30715 resultobj = SWIG_From_int((int)(result));
30716 }
30717 return resultobj;
30718 fail:
30719 return NULL;
30720 }
30721
30722
30723 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30724 PyObject *obj;
30725 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30726 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30727 Py_INCREF(obj);
30728 return Py_BuildValue((char *)"");
30729 }
30730 static int _wrap_DefaultVideoMode_set(PyObject *) {
30731 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30732 return 1;
30733 }
30734
30735
30736 static PyObject *_wrap_DefaultVideoMode_get(void) {
30737 PyObject *pyobj;
30738
30739 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30740 return pyobj;
30741 }
30742
30743
30744 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30745 PyObject *resultobj;
30746 size_t arg1 = (size_t) 0 ;
30747 wxDisplay *result;
30748 PyObject * obj0 = 0 ;
30749 char *kwnames[] = {
30750 (char *) "index", NULL
30751 };
30752
30753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30754 if (obj0) {
30755 {
30756 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30757 if (SWIG_arg_fail(1)) SWIG_fail;
30758 }
30759 }
30760 {
30761 PyThreadState* __tstate = wxPyBeginAllowThreads();
30762 result = (wxDisplay *)new wxDisplay(arg1);
30763
30764 wxPyEndAllowThreads(__tstate);
30765 if (PyErr_Occurred()) SWIG_fail;
30766 }
30767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30768 return resultobj;
30769 fail:
30770 return NULL;
30771 }
30772
30773
30774 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30775 PyObject *resultobj;
30776 wxDisplay *arg1 = (wxDisplay *) 0 ;
30777 PyObject * obj0 = 0 ;
30778 char *kwnames[] = {
30779 (char *) "self", NULL
30780 };
30781
30782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30784 if (SWIG_arg_fail(1)) SWIG_fail;
30785 {
30786 PyThreadState* __tstate = wxPyBeginAllowThreads();
30787 delete arg1;
30788
30789 wxPyEndAllowThreads(__tstate);
30790 if (PyErr_Occurred()) SWIG_fail;
30791 }
30792 Py_INCREF(Py_None); resultobj = Py_None;
30793 return resultobj;
30794 fail:
30795 return NULL;
30796 }
30797
30798
30799 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30800 PyObject *resultobj;
30801 size_t result;
30802 char *kwnames[] = {
30803 NULL
30804 };
30805
30806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30807 {
30808 PyThreadState* __tstate = wxPyBeginAllowThreads();
30809 result = (size_t)wxDisplay::GetCount();
30810
30811 wxPyEndAllowThreads(__tstate);
30812 if (PyErr_Occurred()) SWIG_fail;
30813 }
30814 {
30815 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30816 }
30817 return resultobj;
30818 fail:
30819 return NULL;
30820 }
30821
30822
30823 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30824 PyObject *resultobj;
30825 wxPoint *arg1 = 0 ;
30826 int result;
30827 wxPoint temp1 ;
30828 PyObject * obj0 = 0 ;
30829 char *kwnames[] = {
30830 (char *) "pt", NULL
30831 };
30832
30833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30834 {
30835 arg1 = &temp1;
30836 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30837 }
30838 {
30839 PyThreadState* __tstate = wxPyBeginAllowThreads();
30840 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30841
30842 wxPyEndAllowThreads(__tstate);
30843 if (PyErr_Occurred()) SWIG_fail;
30844 }
30845 {
30846 resultobj = SWIG_From_int((int)(result));
30847 }
30848 return resultobj;
30849 fail:
30850 return NULL;
30851 }
30852
30853
30854 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30855 PyObject *resultobj;
30856 wxWindow *arg1 = (wxWindow *) 0 ;
30857 int result;
30858 PyObject * obj0 = 0 ;
30859 char *kwnames[] = {
30860 (char *) "window", NULL
30861 };
30862
30863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30865 if (SWIG_arg_fail(1)) SWIG_fail;
30866 {
30867 PyThreadState* __tstate = wxPyBeginAllowThreads();
30868 result = (int)Display_GetFromWindow(arg1);
30869
30870 wxPyEndAllowThreads(__tstate);
30871 if (PyErr_Occurred()) SWIG_fail;
30872 }
30873 {
30874 resultobj = SWIG_From_int((int)(result));
30875 }
30876 return resultobj;
30877 fail:
30878 return NULL;
30879 }
30880
30881
30882 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30883 PyObject *resultobj;
30884 wxDisplay *arg1 = (wxDisplay *) 0 ;
30885 bool result;
30886 PyObject * obj0 = 0 ;
30887 char *kwnames[] = {
30888 (char *) "self", NULL
30889 };
30890
30891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30893 if (SWIG_arg_fail(1)) SWIG_fail;
30894 {
30895 PyThreadState* __tstate = wxPyBeginAllowThreads();
30896 result = (bool)((wxDisplay const *)arg1)->IsOk();
30897
30898 wxPyEndAllowThreads(__tstate);
30899 if (PyErr_Occurred()) SWIG_fail;
30900 }
30901 {
30902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30903 }
30904 return resultobj;
30905 fail:
30906 return NULL;
30907 }
30908
30909
30910 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30911 PyObject *resultobj;
30912 wxDisplay *arg1 = (wxDisplay *) 0 ;
30913 wxRect result;
30914 PyObject * obj0 = 0 ;
30915 char *kwnames[] = {
30916 (char *) "self", NULL
30917 };
30918
30919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30921 if (SWIG_arg_fail(1)) SWIG_fail;
30922 {
30923 PyThreadState* __tstate = wxPyBeginAllowThreads();
30924 result = ((wxDisplay const *)arg1)->GetGeometry();
30925
30926 wxPyEndAllowThreads(__tstate);
30927 if (PyErr_Occurred()) SWIG_fail;
30928 }
30929 {
30930 wxRect * resultptr;
30931 resultptr = new wxRect((wxRect &)(result));
30932 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30933 }
30934 return resultobj;
30935 fail:
30936 return NULL;
30937 }
30938
30939
30940 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30941 PyObject *resultobj;
30942 wxDisplay *arg1 = (wxDisplay *) 0 ;
30943 wxString result;
30944 PyObject * obj0 = 0 ;
30945 char *kwnames[] = {
30946 (char *) "self", NULL
30947 };
30948
30949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30951 if (SWIG_arg_fail(1)) SWIG_fail;
30952 {
30953 PyThreadState* __tstate = wxPyBeginAllowThreads();
30954 result = ((wxDisplay const *)arg1)->GetName();
30955
30956 wxPyEndAllowThreads(__tstate);
30957 if (PyErr_Occurred()) SWIG_fail;
30958 }
30959 {
30960 #if wxUSE_UNICODE
30961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30962 #else
30963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30964 #endif
30965 }
30966 return resultobj;
30967 fail:
30968 return NULL;
30969 }
30970
30971
30972 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30973 PyObject *resultobj;
30974 wxDisplay *arg1 = (wxDisplay *) 0 ;
30975 bool result;
30976 PyObject * obj0 = 0 ;
30977 char *kwnames[] = {
30978 (char *) "self", NULL
30979 };
30980
30981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30983 if (SWIG_arg_fail(1)) SWIG_fail;
30984 {
30985 PyThreadState* __tstate = wxPyBeginAllowThreads();
30986 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30987
30988 wxPyEndAllowThreads(__tstate);
30989 if (PyErr_Occurred()) SWIG_fail;
30990 }
30991 {
30992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30993 }
30994 return resultobj;
30995 fail:
30996 return NULL;
30997 }
30998
30999
31000 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31001 PyObject *resultobj;
31002 wxDisplay *arg1 = (wxDisplay *) 0 ;
31003 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31004 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31005 PyObject *result;
31006 PyObject * obj0 = 0 ;
31007 PyObject * obj1 = 0 ;
31008 char *kwnames[] = {
31009 (char *) "self",(char *) "mode", NULL
31010 };
31011
31012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31014 if (SWIG_arg_fail(1)) SWIG_fail;
31015 if (obj1) {
31016 {
31017 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31018 if (SWIG_arg_fail(2)) SWIG_fail;
31019 if (arg2 == NULL) {
31020 SWIG_null_ref("wxVideoMode");
31021 }
31022 if (SWIG_arg_fail(2)) SWIG_fail;
31023 }
31024 }
31025 {
31026 PyThreadState* __tstate = wxPyBeginAllowThreads();
31027 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31028
31029 wxPyEndAllowThreads(__tstate);
31030 if (PyErr_Occurred()) SWIG_fail;
31031 }
31032 resultobj = result;
31033 return resultobj;
31034 fail:
31035 return NULL;
31036 }
31037
31038
31039 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31040 PyObject *resultobj;
31041 wxDisplay *arg1 = (wxDisplay *) 0 ;
31042 wxVideoMode result;
31043 PyObject * obj0 = 0 ;
31044 char *kwnames[] = {
31045 (char *) "self", NULL
31046 };
31047
31048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31050 if (SWIG_arg_fail(1)) SWIG_fail;
31051 {
31052 PyThreadState* __tstate = wxPyBeginAllowThreads();
31053 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31054
31055 wxPyEndAllowThreads(__tstate);
31056 if (PyErr_Occurred()) SWIG_fail;
31057 }
31058 {
31059 wxVideoMode * resultptr;
31060 resultptr = new wxVideoMode((wxVideoMode &)(result));
31061 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31062 }
31063 return resultobj;
31064 fail:
31065 return NULL;
31066 }
31067
31068
31069 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31070 PyObject *resultobj;
31071 wxDisplay *arg1 = (wxDisplay *) 0 ;
31072 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31073 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31074 bool result;
31075 PyObject * obj0 = 0 ;
31076 PyObject * obj1 = 0 ;
31077 char *kwnames[] = {
31078 (char *) "self",(char *) "mode", NULL
31079 };
31080
31081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31083 if (SWIG_arg_fail(1)) SWIG_fail;
31084 if (obj1) {
31085 {
31086 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31087 if (SWIG_arg_fail(2)) SWIG_fail;
31088 if (arg2 == NULL) {
31089 SWIG_null_ref("wxVideoMode");
31090 }
31091 if (SWIG_arg_fail(2)) SWIG_fail;
31092 }
31093 }
31094 {
31095 PyThreadState* __tstate = wxPyBeginAllowThreads();
31096 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31097
31098 wxPyEndAllowThreads(__tstate);
31099 if (PyErr_Occurred()) SWIG_fail;
31100 }
31101 {
31102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31103 }
31104 return resultobj;
31105 fail:
31106 return NULL;
31107 }
31108
31109
31110 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31111 PyObject *resultobj;
31112 wxDisplay *arg1 = (wxDisplay *) 0 ;
31113 PyObject * obj0 = 0 ;
31114 char *kwnames[] = {
31115 (char *) "self", NULL
31116 };
31117
31118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31120 if (SWIG_arg_fail(1)) SWIG_fail;
31121 {
31122 PyThreadState* __tstate = wxPyBeginAllowThreads();
31123 (arg1)->ResetMode();
31124
31125 wxPyEndAllowThreads(__tstate);
31126 if (PyErr_Occurred()) SWIG_fail;
31127 }
31128 Py_INCREF(Py_None); resultobj = Py_None;
31129 return resultobj;
31130 fail:
31131 return NULL;
31132 }
31133
31134
31135 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31136 PyObject *obj;
31137 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31138 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31139 Py_INCREF(obj);
31140 return Py_BuildValue((char *)"");
31141 }
31142 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31143 PyObject *resultobj;
31144 wxStandardPaths *result;
31145 char *kwnames[] = {
31146 NULL
31147 };
31148
31149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31150 {
31151 PyThreadState* __tstate = wxPyBeginAllowThreads();
31152 result = (wxStandardPaths *)StandardPaths_Get();
31153
31154 wxPyEndAllowThreads(__tstate);
31155 if (PyErr_Occurred()) SWIG_fail;
31156 }
31157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31158 return resultobj;
31159 fail:
31160 return NULL;
31161 }
31162
31163
31164 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31165 PyObject *resultobj;
31166 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31167 wxString result;
31168 PyObject * obj0 = 0 ;
31169 char *kwnames[] = {
31170 (char *) "self", NULL
31171 };
31172
31173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31175 if (SWIG_arg_fail(1)) SWIG_fail;
31176 {
31177 PyThreadState* __tstate = wxPyBeginAllowThreads();
31178 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31179
31180 wxPyEndAllowThreads(__tstate);
31181 if (PyErr_Occurred()) SWIG_fail;
31182 }
31183 {
31184 #if wxUSE_UNICODE
31185 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31186 #else
31187 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31188 #endif
31189 }
31190 return resultobj;
31191 fail:
31192 return NULL;
31193 }
31194
31195
31196 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31197 PyObject *resultobj;
31198 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31199 wxString result;
31200 PyObject * obj0 = 0 ;
31201 char *kwnames[] = {
31202 (char *) "self", NULL
31203 };
31204
31205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31207 if (SWIG_arg_fail(1)) SWIG_fail;
31208 {
31209 PyThreadState* __tstate = wxPyBeginAllowThreads();
31210 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31211
31212 wxPyEndAllowThreads(__tstate);
31213 if (PyErr_Occurred()) SWIG_fail;
31214 }
31215 {
31216 #if wxUSE_UNICODE
31217 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31218 #else
31219 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31220 #endif
31221 }
31222 return resultobj;
31223 fail:
31224 return NULL;
31225 }
31226
31227
31228 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31229 PyObject *resultobj;
31230 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31231 wxString result;
31232 PyObject * obj0 = 0 ;
31233 char *kwnames[] = {
31234 (char *) "self", NULL
31235 };
31236
31237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31239 if (SWIG_arg_fail(1)) SWIG_fail;
31240 {
31241 PyThreadState* __tstate = wxPyBeginAllowThreads();
31242 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31243
31244 wxPyEndAllowThreads(__tstate);
31245 if (PyErr_Occurred()) SWIG_fail;
31246 }
31247 {
31248 #if wxUSE_UNICODE
31249 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31250 #else
31251 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31252 #endif
31253 }
31254 return resultobj;
31255 fail:
31256 return NULL;
31257 }
31258
31259
31260 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31261 PyObject *resultobj;
31262 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31263 wxString result;
31264 PyObject * obj0 = 0 ;
31265 char *kwnames[] = {
31266 (char *) "self", NULL
31267 };
31268
31269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31271 if (SWIG_arg_fail(1)) SWIG_fail;
31272 {
31273 PyThreadState* __tstate = wxPyBeginAllowThreads();
31274 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31275
31276 wxPyEndAllowThreads(__tstate);
31277 if (PyErr_Occurred()) SWIG_fail;
31278 }
31279 {
31280 #if wxUSE_UNICODE
31281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31282 #else
31283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31284 #endif
31285 }
31286 return resultobj;
31287 fail:
31288 return NULL;
31289 }
31290
31291
31292 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31293 PyObject *resultobj;
31294 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31295 wxString result;
31296 PyObject * obj0 = 0 ;
31297 char *kwnames[] = {
31298 (char *) "self", NULL
31299 };
31300
31301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31303 if (SWIG_arg_fail(1)) SWIG_fail;
31304 {
31305 PyThreadState* __tstate = wxPyBeginAllowThreads();
31306 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31307
31308 wxPyEndAllowThreads(__tstate);
31309 if (PyErr_Occurred()) SWIG_fail;
31310 }
31311 {
31312 #if wxUSE_UNICODE
31313 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31314 #else
31315 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31316 #endif
31317 }
31318 return resultobj;
31319 fail:
31320 return NULL;
31321 }
31322
31323
31324 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31325 PyObject *resultobj;
31326 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31327 wxString result;
31328 PyObject * obj0 = 0 ;
31329 char *kwnames[] = {
31330 (char *) "self", NULL
31331 };
31332
31333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31335 if (SWIG_arg_fail(1)) SWIG_fail;
31336 {
31337 PyThreadState* __tstate = wxPyBeginAllowThreads();
31338 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31339
31340 wxPyEndAllowThreads(__tstate);
31341 if (PyErr_Occurred()) SWIG_fail;
31342 }
31343 {
31344 #if wxUSE_UNICODE
31345 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31346 #else
31347 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31348 #endif
31349 }
31350 return resultobj;
31351 fail:
31352 return NULL;
31353 }
31354
31355
31356 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31357 PyObject *resultobj;
31358 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31359 wxString result;
31360 PyObject * obj0 = 0 ;
31361 char *kwnames[] = {
31362 (char *) "self", NULL
31363 };
31364
31365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31367 if (SWIG_arg_fail(1)) SWIG_fail;
31368 {
31369 PyThreadState* __tstate = wxPyBeginAllowThreads();
31370 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31371
31372 wxPyEndAllowThreads(__tstate);
31373 if (PyErr_Occurred()) SWIG_fail;
31374 }
31375 {
31376 #if wxUSE_UNICODE
31377 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31378 #else
31379 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31380 #endif
31381 }
31382 return resultobj;
31383 fail:
31384 return NULL;
31385 }
31386
31387
31388 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31389 PyObject *resultobj;
31390 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31391 wxString *arg2 = 0 ;
31392 bool temp2 = false ;
31393 PyObject * obj0 = 0 ;
31394 PyObject * obj1 = 0 ;
31395 char *kwnames[] = {
31396 (char *) "self",(char *) "prefix", NULL
31397 };
31398
31399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31401 if (SWIG_arg_fail(1)) SWIG_fail;
31402 {
31403 arg2 = wxString_in_helper(obj1);
31404 if (arg2 == NULL) SWIG_fail;
31405 temp2 = true;
31406 }
31407 {
31408 PyThreadState* __tstate = wxPyBeginAllowThreads();
31409 (arg1)->SetInstallPrefix((wxString const &)*arg2);
31410
31411 wxPyEndAllowThreads(__tstate);
31412 if (PyErr_Occurred()) SWIG_fail;
31413 }
31414 Py_INCREF(Py_None); resultobj = Py_None;
31415 {
31416 if (temp2)
31417 delete arg2;
31418 }
31419 return resultobj;
31420 fail:
31421 {
31422 if (temp2)
31423 delete arg2;
31424 }
31425 return NULL;
31426 }
31427
31428
31429 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31430 PyObject *resultobj;
31431 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31432 wxString result;
31433 PyObject * obj0 = 0 ;
31434 char *kwnames[] = {
31435 (char *) "self", NULL
31436 };
31437
31438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31440 if (SWIG_arg_fail(1)) SWIG_fail;
31441 {
31442 PyThreadState* __tstate = wxPyBeginAllowThreads();
31443 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
31444
31445 wxPyEndAllowThreads(__tstate);
31446 if (PyErr_Occurred()) SWIG_fail;
31447 }
31448 {
31449 #if wxUSE_UNICODE
31450 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31451 #else
31452 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31453 #endif
31454 }
31455 return resultobj;
31456 fail:
31457 return NULL;
31458 }
31459
31460
31461 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31462 PyObject *obj;
31463 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31464 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31465 Py_INCREF(obj);
31466 return Py_BuildValue((char *)"");
31467 }
31468 static PyMethodDef SwigMethods[] = {
31469 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31476 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31484 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31549 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31557 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31575 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31578 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31581 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31584 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31590 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31604 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31610 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31616 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31619 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31633 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31636 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31637 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31640 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31667 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31669 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31671 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31673 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31680 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31686 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31700 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31704 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31707 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31724 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31732 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31779 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31797 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31807 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31823 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31839 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31853 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31863 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31906 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31909 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31912 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31916 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32009 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32010 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32011 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32012 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32029 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32074 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32108 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32116 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32117 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32122 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32131 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32138 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32141 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32144 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32149 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32152 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32156 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32159 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32163 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32164 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32168 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32172 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32174 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32184 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32197 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32201 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32205 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32213 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32215 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32225 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32227 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32231 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32236 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32239 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32243 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32244 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32245 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32247 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32249 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32250 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32251 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32252 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32253 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32256 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32257 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32258 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32259 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32260 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32261 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32262 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32263 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32264 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32265 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32267 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32268 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32271 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32272 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32273 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32274 { NULL, NULL, 0, NULL }
32275 };
32276
32277
32278 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32279
32280 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32281 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32282 }
32283 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32284 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32285 }
32286 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32287 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32288 }
32289 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32290 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32291 }
32292 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32293 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32294 }
32295 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32296 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32297 }
32298 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32299 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32300 }
32301 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32302 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32303 }
32304 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32305 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32306 }
32307 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32308 return (void *)((wxEvent *) ((wxPyEvent *) x));
32309 }
32310 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32311 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32312 }
32313 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32314 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32315 }
32316 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32317 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32318 }
32319 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32320 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32321 }
32322 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32323 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32324 }
32325 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32326 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32327 }
32328 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32329 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32330 }
32331 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32332 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32333 }
32334 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32335 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32336 }
32337 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32338 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32339 }
32340 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32341 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32342 }
32343 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32344 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32345 }
32346 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32347 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32348 }
32349 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32350 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32351 }
32352 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32353 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32354 }
32355 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32356 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32357 }
32358 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32359 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32360 }
32361 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32362 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32363 }
32364 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32365 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32366 }
32367 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32368 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32369 }
32370 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32371 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32372 }
32373 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32374 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32375 }
32376 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32377 return (void *)((wxEvent *) ((wxShowEvent *) x));
32378 }
32379 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32380 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32381 }
32382 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32383 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32384 }
32385 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32386 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32387 }
32388 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32389 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32390 }
32391 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32392 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32393 }
32394 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32395 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32396 }
32397 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32398 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32399 }
32400 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32401 return (void *)((wxConfigBase *) ((wxConfig *) x));
32402 }
32403 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32404 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32405 }
32406 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32407 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32408 }
32409 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32410 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32411 }
32412 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32413 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32414 }
32415 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32416 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32417 }
32418 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32419 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32420 }
32421 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32422 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32423 }
32424 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32425 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32426 }
32427 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32428 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32429 }
32430 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32431 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32432 }
32433 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32434 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32435 }
32436 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32437 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32438 }
32439 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32440 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32441 }
32442 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32443 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32444 }
32445 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32446 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32447 }
32448 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32449 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32450 }
32451 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32452 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32453 }
32454 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32455 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32456 }
32457 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32458 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32459 }
32460 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32461 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32462 }
32463 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32464 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32465 }
32466 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32467 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32468 }
32469 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32470 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32471 }
32472 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32473 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32474 }
32475 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32476 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32477 }
32478 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32479 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32480 }
32481 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32482 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32483 }
32484 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32485 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32486 }
32487 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32488 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32489 }
32490 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32491 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32492 }
32493 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32494 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32495 }
32496 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32497 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32498 }
32499 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32500 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32501 }
32502 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32503 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32504 }
32505 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32506 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32507 }
32508 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32509 return (void *)((wxObject *) ((wxSizerItem *) x));
32510 }
32511 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32512 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32513 }
32514 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32515 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32516 }
32517 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32518 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32519 }
32520 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32521 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32522 }
32523 static void *_p_wxSizerTo_p_wxObject(void *x) {
32524 return (void *)((wxObject *) ((wxSizer *) x));
32525 }
32526 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32527 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32528 }
32529 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32530 return (void *)((wxObject *) ((wxFileHistory *) x));
32531 }
32532 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32533 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32534 }
32535 static void *_p_wxEventTo_p_wxObject(void *x) {
32536 return (void *)((wxObject *) ((wxEvent *) x));
32537 }
32538 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32539 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32540 }
32541 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32542 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32543 }
32544 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32545 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32546 }
32547 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32548 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32549 }
32550 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32551 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32552 }
32553 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32554 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32555 }
32556 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32557 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32558 }
32559 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32560 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32561 }
32562 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32563 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32564 }
32565 static void *_p_wxControlTo_p_wxObject(void *x) {
32566 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32567 }
32568 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32569 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32570 }
32571 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32572 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32573 }
32574 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32575 return (void *)((wxObject *) ((wxFSFile *) x));
32576 }
32577 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32578 return (void *)((wxObject *) ((wxClipboard *) x));
32579 }
32580 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32581 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32582 }
32583 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32584 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32585 }
32586 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32587 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32588 }
32589 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32590 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32591 }
32592 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32593 return (void *)((wxObject *) ((wxToolTip *) x));
32594 }
32595 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32596 return (void *)((wxObject *) ((wxMenuItem *) x));
32597 }
32598 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32599 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32600 }
32601 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32602 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32603 }
32604 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32605 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32606 }
32607 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32608 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32609 }
32610 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32611 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32612 }
32613 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32614 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32615 }
32616 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32617 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32618 }
32619 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32620 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32621 }
32622 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32623 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32624 }
32625 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32626 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32627 }
32628 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32629 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32630 }
32631 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32632 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32633 }
32634 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32635 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32636 }
32637 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32638 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32639 }
32640 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32641 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32642 }
32643 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32644 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32645 }
32646 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32647 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32648 }
32649 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32650 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32651 }
32652 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32653 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32654 }
32655 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32656 return (void *)((wxObject *) ((wxImageHandler *) x));
32657 }
32658 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32659 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32660 }
32661 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32662 return (void *)((wxObject *) ((wxEvtHandler *) x));
32663 }
32664 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32665 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32666 }
32667 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32668 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32669 }
32670 static void *_p_wxImageTo_p_wxObject(void *x) {
32671 return (void *)((wxObject *) ((wxImage *) x));
32672 }
32673 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32674 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32675 }
32676 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32677 return (void *)((wxObject *) ((wxSystemOptions *) x));
32678 }
32679 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32680 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32681 }
32682 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32683 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32684 }
32685 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32686 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32687 }
32688 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32689 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32690 }
32691 static void *_p_wxWindowTo_p_wxObject(void *x) {
32692 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32693 }
32694 static void *_p_wxMenuTo_p_wxObject(void *x) {
32695 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32696 }
32697 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32698 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32699 }
32700 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32701 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32702 }
32703 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32704 return (void *)((wxObject *) ((wxFileSystem *) x));
32705 }
32706 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32707 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32708 }
32709 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32710 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32711 }
32712 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32713 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32714 }
32715 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32716 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32717 }
32718 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32719 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32720 }
32721 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32722 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32723 }
32724 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32725 return (void *)((wxObject *) ((wxBusyInfo *) x));
32726 }
32727 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32728 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32729 }
32730 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32731 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32732 }
32733 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32734 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32735 }
32736 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32737 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32738 }
32739 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32740 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32741 }
32742 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32743 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32744 }
32745 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32746 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32747 }
32748 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32749 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32750 }
32751 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32752 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32753 }
32754 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32755 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32756 }
32757 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32758 return (void *)((wxLog *) ((wxLogStderr *) x));
32759 }
32760 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32761 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32762 }
32763 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32764 return (void *)((wxLog *) ((wxLogWindow *) x));
32765 }
32766 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32767 return (void *)((wxLog *) ((wxLogChain *) x));
32768 }
32769 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32770 return (void *)((wxLog *) ((wxLogGui *) x));
32771 }
32772 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32773 return (void *)((wxLog *) ((wxPyLog *) x));
32774 }
32775 static void *_p_wxControlTo_p_wxWindow(void *x) {
32776 return (void *)((wxWindow *) ((wxControl *) x));
32777 }
32778 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32779 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32780 }
32781 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32782 return (void *)((wxWindow *) ((wxMenuBar *) x));
32783 }
32784 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32785 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32786 }
32787 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32788 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32789 }
32790 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}};
32791 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}};
32792 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}};
32793 static swig_type_info _swigt__p_wxLog[] = {{"_p_wxLog", 0, "wxLog *", 0, 0, 0, 0},{"_p_wxLogStderr", _p_wxLogStderrTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogTextCtrl", _p_wxLogTextCtrlTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogWindow", _p_wxLogWindowTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogChain", _p_wxLogChainTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogGui", _p_wxLogGuiTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxPyLog", _p_wxPyLogTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32794 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}};
32795 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}};
32796 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}};
32797 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}};
32798 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}};
32799 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}};
32800 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}};
32801 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}};
32802 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}};
32803 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}};
32804 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}};
32805 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}};
32806 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}};
32807 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}};
32808 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}};
32809 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}};
32810 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}};
32811 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}};
32812 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}};
32813 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}};
32814 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}};
32815 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}};
32816 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}};
32817 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}};
32818 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}};
32819 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}};
32820 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}};
32821 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}};
32822 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}};
32823 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}};
32824 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}};
32825 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}};
32826 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}};
32827 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}};
32828 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}};
32829 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}};
32830 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}};
32831 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}};
32832 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}};
32833 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}};
32834 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}};
32835 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}};
32836 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}};
32837 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}};
32838 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}};
32839 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}};
32840 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}};
32841 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}};
32842 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}};
32843 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}};
32844 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}};
32845 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}};
32846 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}};
32847 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}};
32848 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}};
32849 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}};
32850 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}};
32851 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}};
32852 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}};
32853 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}};
32854 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}};
32855 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}};
32856 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}};
32857 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}};
32858 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}};
32859 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}};
32860 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}};
32861 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}};
32862 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}};
32863 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}};
32864 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}};
32865 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}};
32866 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}};
32867 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}};
32868 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}};
32869 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}};
32870 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}};
32871 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}};
32872 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}};
32873 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}};
32874 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}};
32875 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}};
32876 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}};
32877 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}};
32878 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}};
32879 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}};
32880 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}};
32881 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}};
32882 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}};
32883 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}};
32884 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}};
32885 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}};
32886
32887 static swig_type_info *swig_types_initial[] = {
32888 _swigt__p_wxLogChain,
32889 _swigt__p_wxMutexGuiLocker,
32890 _swigt__p_wxFileHistory,
32891 _swigt__p_wxLog,
32892 _swigt__p_wxMenu,
32893 _swigt__p_wxEvent,
32894 _swigt__p_wxDateTime__TimeZone,
32895 _swigt__p_wxConfigBase,
32896 _swigt__p_wxDisplay,
32897 _swigt__p_wxFileType,
32898 _swigt__p_wxLogGui,
32899 _swigt__p_wxFont,
32900 _swigt__p_wxDataFormat,
32901 _swigt__p_wxTimerEvent,
32902 _swigt__p_wxCaret,
32903 _swigt__ptrdiff_t,
32904 _swigt__std__ptrdiff_t,
32905 _swigt__p_int,
32906 _swigt__p_wxSize,
32907 _swigt__p_wxClipboard,
32908 _swigt__p_wxStopWatch,
32909 _swigt__p_wxDC,
32910 _swigt__p_wxClipboardLocker,
32911 _swigt__p_wxIcon,
32912 _swigt__p_wxLogStderr,
32913 _swigt__p_wxLogTextCtrl,
32914 _swigt__p_wxTextCtrl,
32915 _swigt__p_wxBusyCursor,
32916 _swigt__p_wxBitmapDataObject,
32917 _swigt__p_wxTextDataObject,
32918 _swigt__p_wxDataObject,
32919 _swigt__p_wxPyTextDataObject,
32920 _swigt__p_wxPyBitmapDataObject,
32921 _swigt__p_wxFileDataObject,
32922 _swigt__p_wxCustomDataObject,
32923 _swigt__p_wxURLDataObject,
32924 _swigt__p_wxMetafileDataObject,
32925 _swigt__p_wxSound,
32926 _swigt__p_wxTimerRunner,
32927 _swigt__p_wxLogWindow,
32928 _swigt__p_wxTimeSpan,
32929 _swigt__p_wxArrayString,
32930 _swigt__p_wxWindowDisabler,
32931 _swigt__p_form_ops_t,
32932 _swigt__p_wxToolTip,
32933 _swigt__p_wxDataObjectComposite,
32934 _swigt__p_wxSystemSettings,
32935 _swigt__p_wxFileConfig,
32936 _swigt__p_wxVideoMode,
32937 _swigt__p_wxDataObjectSimple,
32938 _swigt__p_wxPyDataObjectSimple,
32939 _swigt__p_wxDuplexMode,
32940 _swigt__p_wxEvtHandler,
32941 _swigt__p_wxRect,
32942 _swigt__p_char,
32943 _swigt__p_wxSingleInstanceChecker,
32944 _swigt__p_wxStandardPaths,
32945 _swigt__p_wxFileTypeInfo,
32946 _swigt__p_wxFrame,
32947 _swigt__p_wxTimer,
32948 _swigt__p_wxPaperSize,
32949 _swigt__p_wxMimeTypesManager,
32950 _swigt__p_wxPyArtProvider,
32951 _swigt__p_wxPyTipProvider,
32952 _swigt__p_wxTipProvider,
32953 _swigt__p_wxJoystick,
32954 _swigt__p_wxSystemOptions,
32955 _swigt__p_wxPoint,
32956 _swigt__p_wxJoystickEvent,
32957 _swigt__p_wxCursor,
32958 _swigt__p_wxObject,
32959 _swigt__p_wxOutputStream,
32960 _swigt__p_wxDateTime,
32961 _swigt__p_wxPyDropSource,
32962 _swigt__p_unsigned_long,
32963 _swigt__p_wxKillError,
32964 _swigt__p_wxWindow,
32965 _swigt__p_wxString,
32966 _swigt__p_wxPyProcess,
32967 _swigt__p_wxBitmap,
32968 _swigt__p_wxConfig,
32969 _swigt__unsigned_int,
32970 _swigt__p_unsigned_int,
32971 _swigt__p_unsigned_char,
32972 _swigt__p_wxChar,
32973 _swigt__p_wxBusyInfo,
32974 _swigt__p_wxPyDropTarget,
32975 _swigt__p_wxPyTextDropTarget,
32976 _swigt__p_wxPyFileDropTarget,
32977 _swigt__p_wxProcessEvent,
32978 _swigt__p_wxPyLog,
32979 _swigt__p_wxLogNull,
32980 _swigt__p_wxColour,
32981 _swigt__p_wxPyTimer,
32982 _swigt__p_wxConfigPathChanger,
32983 _swigt__p_wxDateSpan,
32984 0
32985 };
32986
32987
32988 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32989
32990 static swig_const_info swig_const_table[] = {
32991 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32992 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32993 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32994 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32995 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32996 {0, 0, 0, 0.0, 0, 0}};
32997
32998 #ifdef __cplusplus
32999 }
33000 #endif
33001
33002
33003 #ifdef __cplusplus
33004 extern "C" {
33005 #endif
33006
33007 /* Python-specific SWIG API */
33008 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33009 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33010 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33011
33012 /* -----------------------------------------------------------------------------
33013 * global variable support code.
33014 * ----------------------------------------------------------------------------- */
33015
33016 typedef struct swig_globalvar {
33017 char *name; /* Name of global variable */
33018 PyObject *(*get_attr)(); /* Return the current value */
33019 int (*set_attr)(PyObject *); /* Set the value */
33020 struct swig_globalvar *next;
33021 } swig_globalvar;
33022
33023 typedef struct swig_varlinkobject {
33024 PyObject_HEAD
33025 swig_globalvar *vars;
33026 } swig_varlinkobject;
33027
33028 static PyObject *
33029 swig_varlink_repr(swig_varlinkobject *v) {
33030 v = v;
33031 return PyString_FromString("<Swig global variables>");
33032 }
33033
33034 static int
33035 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33036 swig_globalvar *var;
33037 flags = flags;
33038 fprintf(fp,"Swig global variables { ");
33039 for (var = v->vars; var; var=var->next) {
33040 fprintf(fp,"%s", var->name);
33041 if (var->next) fprintf(fp,", ");
33042 }
33043 fprintf(fp," }\n");
33044 return 0;
33045 }
33046
33047 static PyObject *
33048 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33049 swig_globalvar *var = v->vars;
33050 while (var) {
33051 if (strcmp(var->name,n) == 0) {
33052 return (*var->get_attr)();
33053 }
33054 var = var->next;
33055 }
33056 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33057 return NULL;
33058 }
33059
33060 static int
33061 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33062 swig_globalvar *var = v->vars;
33063 while (var) {
33064 if (strcmp(var->name,n) == 0) {
33065 return (*var->set_attr)(p);
33066 }
33067 var = var->next;
33068 }
33069 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33070 return 1;
33071 }
33072
33073 static PyTypeObject varlinktype = {
33074 PyObject_HEAD_INIT(0)
33075 0, /* Number of items in variable part (ob_size) */
33076 (char *)"swigvarlink", /* Type name (tp_name) */
33077 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33078 0, /* Itemsize (tp_itemsize) */
33079 0, /* Deallocator (tp_dealloc) */
33080 (printfunc) swig_varlink_print, /* Print (tp_print) */
33081 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33082 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33083 0, /* tp_compare */
33084 (reprfunc) swig_varlink_repr, /* tp_repr */
33085 0, /* tp_as_number */
33086 0, /* tp_as_sequence */
33087 0, /* tp_as_mapping */
33088 0, /* tp_hash */
33089 0, /* tp_call */
33090 0, /* tp_str */
33091 0, /* tp_getattro */
33092 0, /* tp_setattro */
33093 0, /* tp_as_buffer */
33094 0, /* tp_flags */
33095 0, /* tp_doc */
33096 #if PY_VERSION_HEX >= 0x02000000
33097 0, /* tp_traverse */
33098 0, /* tp_clear */
33099 #endif
33100 #if PY_VERSION_HEX >= 0x02010000
33101 0, /* tp_richcompare */
33102 0, /* tp_weaklistoffset */
33103 #endif
33104 #if PY_VERSION_HEX >= 0x02020000
33105 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33106 #endif
33107 #if PY_VERSION_HEX >= 0x02030000
33108 0, /* tp_del */
33109 #endif
33110 #ifdef COUNT_ALLOCS
33111 0,0,0,0 /* tp_alloc -> tp_next */
33112 #endif
33113 };
33114
33115 /* Create a variable linking object for use later */
33116 static PyObject *
33117 SWIG_Python_newvarlink(void) {
33118 swig_varlinkobject *result = 0;
33119 result = PyMem_NEW(swig_varlinkobject,1);
33120 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33121 result->ob_type = &varlinktype;
33122 result->vars = 0;
33123 result->ob_refcnt = 0;
33124 Py_XINCREF((PyObject *) result);
33125 return ((PyObject*) result);
33126 }
33127
33128 static void
33129 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33130 swig_varlinkobject *v;
33131 swig_globalvar *gv;
33132 v= (swig_varlinkobject *) p;
33133 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33134 gv->name = (char *) malloc(strlen(name)+1);
33135 strcpy(gv->name,name);
33136 gv->get_attr = get_attr;
33137 gv->set_attr = set_attr;
33138 gv->next = v->vars;
33139 v->vars = gv;
33140 }
33141
33142 /* -----------------------------------------------------------------------------
33143 * constants/methods manipulation
33144 * ----------------------------------------------------------------------------- */
33145
33146 /* Install Constants */
33147 static void
33148 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33149 PyObject *obj = 0;
33150 size_t i;
33151 for (i = 0; constants[i].type; i++) {
33152 switch(constants[i].type) {
33153 case SWIG_PY_INT:
33154 obj = PyInt_FromLong(constants[i].lvalue);
33155 break;
33156 case SWIG_PY_FLOAT:
33157 obj = PyFloat_FromDouble(constants[i].dvalue);
33158 break;
33159 case SWIG_PY_STRING:
33160 if (constants[i].pvalue) {
33161 obj = PyString_FromString((char *) constants[i].pvalue);
33162 } else {
33163 Py_INCREF(Py_None);
33164 obj = Py_None;
33165 }
33166 break;
33167 case SWIG_PY_POINTER:
33168 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33169 break;
33170 case SWIG_PY_BINARY:
33171 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33172 break;
33173 default:
33174 obj = 0;
33175 break;
33176 }
33177 if (obj) {
33178 PyDict_SetItemString(d,constants[i].name,obj);
33179 Py_DECREF(obj);
33180 }
33181 }
33182 }
33183
33184 /* -----------------------------------------------------------------------------*/
33185 /* Fix SwigMethods to carry the callback ptrs when needed */
33186 /* -----------------------------------------------------------------------------*/
33187
33188 static void
33189 SWIG_Python_FixMethods(PyMethodDef *methods,
33190 swig_const_info *const_table,
33191 swig_type_info **types,
33192 swig_type_info **types_initial) {
33193 size_t i;
33194 for (i = 0; methods[i].ml_name; ++i) {
33195 char *c = methods[i].ml_doc;
33196 if (c && (c = strstr(c, "swig_ptr: "))) {
33197 int j;
33198 swig_const_info *ci = 0;
33199 char *name = c + 10;
33200 for (j = 0; const_table[j].type; j++) {
33201 if (strncmp(const_table[j].name, name,
33202 strlen(const_table[j].name)) == 0) {
33203 ci = &(const_table[j]);
33204 break;
33205 }
33206 }
33207 if (ci) {
33208 size_t shift = (ci->ptype) - types;
33209 swig_type_info *ty = types_initial[shift];
33210 size_t ldoc = (c - methods[i].ml_doc);
33211 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33212 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33213 char *buff = ndoc;
33214 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33215 strncpy(buff, methods[i].ml_doc, ldoc);
33216 buff += ldoc;
33217 strncpy(buff, "swig_ptr: ", 10);
33218 buff += 10;
33219 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33220 methods[i].ml_doc = ndoc;
33221 }
33222 }
33223 }
33224 }
33225
33226 /* -----------------------------------------------------------------------------*
33227 * Initialize type list
33228 * -----------------------------------------------------------------------------*/
33229
33230 #if PY_MAJOR_VERSION < 2
33231 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33232 is copied out of Python/modsupport.c in python version 2.3.4 */
33233 static int
33234 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33235 {
33236 PyObject *dict;
33237 if (!PyModule_Check(m)) {
33238 PyErr_SetString(PyExc_TypeError,
33239 "PyModule_AddObject() needs module as first arg");
33240 return -1;
33241 }
33242 if (!o) {
33243 PyErr_SetString(PyExc_TypeError,
33244 "PyModule_AddObject() needs non-NULL value");
33245 return -1;
33246 }
33247
33248 dict = PyModule_GetDict(m);
33249 if (dict == NULL) {
33250 /* Internal error -- modules must have a dict! */
33251 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33252 PyModule_GetName(m));
33253 return -1;
33254 }
33255 if (PyDict_SetItemString(dict, name, o))
33256 return -1;
33257 Py_DECREF(o);
33258 return 0;
33259 }
33260 #endif
33261
33262 static swig_type_info **
33263 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33264 static PyMethodDef swig_empty_runtime_method_table[] = {
33265 {
33266 NULL, NULL, 0, NULL
33267 }
33268 };/* Sentinel */
33269
33270 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33271 swig_empty_runtime_method_table);
33272 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33273 if (pointer && module) {
33274 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33275 }
33276 return type_list_handle;
33277 }
33278
33279 static swig_type_info **
33280 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33281 swig_type_info **type_pointer;
33282
33283 /* first check if module already created */
33284 type_pointer = SWIG_Python_GetTypeListHandle();
33285 if (type_pointer) {
33286 return type_pointer;
33287 } else {
33288 /* create a new module and variable */
33289 return SWIG_Python_SetTypeListHandle(type_list_handle);
33290 }
33291 }
33292
33293 #ifdef __cplusplus
33294 }
33295 #endif
33296
33297 /* -----------------------------------------------------------------------------*
33298 * Partial Init method
33299 * -----------------------------------------------------------------------------*/
33300
33301 #ifdef SWIG_LINK_RUNTIME
33302 #ifdef __cplusplus
33303 extern "C"
33304 #endif
33305 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33306 #endif
33307
33308 #ifdef __cplusplus
33309 extern "C"
33310 #endif
33311 SWIGEXPORT(void) SWIG_init(void) {
33312 static PyObject *SWIG_globals = 0;
33313 static int typeinit = 0;
33314 PyObject *m, *d;
33315 int i;
33316 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33317
33318 /* Fix SwigMethods to carry the callback ptrs when needed */
33319 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33320
33321 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33322 d = PyModule_GetDict(m);
33323
33324 if (!typeinit) {
33325 #ifdef SWIG_LINK_RUNTIME
33326 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33327 #else
33328 # ifndef SWIG_STATIC_RUNTIME
33329 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33330 # endif
33331 #endif
33332 for (i = 0; swig_types_initial[i]; i++) {
33333 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33334 }
33335 typeinit = 1;
33336 }
33337 SWIG_InstallConstants(d,swig_const_table);
33338
33339 {
33340 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33341 }
33342 {
33343 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33344 }
33345 {
33346 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33347 }
33348 {
33349 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33350 }
33351 {
33352 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33353 }
33354 {
33355 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33356 }
33357 {
33358 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33359 }
33360 {
33361 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33362 }
33363 {
33364 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33365 }
33366 {
33367 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33368 }
33369 {
33370 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33371 }
33372 {
33373 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33374 }
33375 {
33376 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33377 }
33378 {
33379 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33380 }
33381 {
33382 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33383 }
33384 {
33385 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33386 }
33387 {
33388 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33389 }
33390 {
33391 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33392 }
33393 {
33394 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33395 }
33396 {
33397 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33398 }
33399 {
33400 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33401 }
33402 {
33403 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33404 }
33405 {
33406 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33407 }
33408 {
33409 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33410 }
33411 {
33412 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33413 }
33414 {
33415 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33416 }
33417 {
33418 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33419 }
33420 {
33421 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33422 }
33423 {
33424 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33425 }
33426 {
33427 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33428 }
33429 {
33430 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33431 }
33432 {
33433 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33434 }
33435 {
33436 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33437 }
33438 {
33439 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33440 }
33441 {
33442 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33443 }
33444 {
33445 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33446 }
33447 {
33448 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33449 }
33450 {
33451 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33452 }
33453 {
33454 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33455 }
33456 {
33457 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33458 }
33459 {
33460 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33461 }
33462 {
33463 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33464 }
33465 {
33466 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33467 }
33468 {
33469 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33470 }
33471 {
33472 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33473 }
33474 {
33475 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33476 }
33477 {
33478 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33479 }
33480 {
33481 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33482 }
33483 {
33484 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33485 }
33486 {
33487 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33488 }
33489 {
33490 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33491 }
33492 {
33493 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33494 }
33495 {
33496 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33497 }
33498 {
33499 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33500 }
33501 {
33502 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33503 }
33504 {
33505 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33506 }
33507 {
33508 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33509 }
33510 {
33511 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33512 }
33513 {
33514 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33515 }
33516 {
33517 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33518 }
33519 {
33520 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33521 }
33522 {
33523 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33524 }
33525 {
33526 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33527 }
33528 {
33529 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33530 }
33531 {
33532 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33533 }
33534 {
33535 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33536 }
33537 {
33538 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33539 }
33540 {
33541 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33542 }
33543 {
33544 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33545 }
33546 {
33547 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33548 }
33549 {
33550 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33551 }
33552 {
33553 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33554 }
33555 {
33556 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33557 }
33558 {
33559 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33560 }
33561 {
33562 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33563 }
33564 {
33565 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33566 }
33567 {
33568 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33569 }
33570 {
33571 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33572 }
33573 {
33574 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33575 }
33576 {
33577 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33578 }
33579 {
33580 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33581 }
33582 {
33583 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33584 }
33585 {
33586 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33587 }
33588 {
33589 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33590 }
33591 {
33592 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33593 }
33594 {
33595 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33596 }
33597 {
33598 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33599 }
33600 {
33601 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33602 }
33603 {
33604 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33605 }
33606 {
33607 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33608 }
33609 {
33610 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33611 }
33612 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33613 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33614 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33615 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33616 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33617 {
33618 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33619 }
33620 {
33621 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33622 }
33623 {
33624 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33625 }
33626 {
33627 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33628 }
33629 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33630
33631 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33632
33633 {
33634 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33635 }
33636 {
33637 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33638 }
33639 {
33640 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33641 }
33642 {
33643 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33644 }
33645 {
33646 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33647 }
33648 {
33649 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33650 }
33651 {
33652 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33653 }
33654 {
33655 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33656 }
33657 {
33658 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33659 }
33660 {
33661 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33662 }
33663 {
33664 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33665 }
33666 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33667 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33668 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33669 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33670 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33671 {
33672 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33673 }
33674 {
33675 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33676 }
33677 {
33678 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33679 }
33680 {
33681 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33682 }
33683 {
33684 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33685 }
33686 {
33687 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33688 }
33689 {
33690 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33691 }
33692 {
33693 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33694 }
33695 {
33696 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33697 }
33698 {
33699 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33700 }
33701 {
33702 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33703 }
33704 {
33705 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33706 }
33707 {
33708 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33709 }
33710 {
33711 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33712 }
33713 {
33714 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33715 }
33716 {
33717 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33718 }
33719 {
33720 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33721 }
33722 {
33723 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33724 }
33725 {
33726 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33727 }
33728 {
33729 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33730 }
33731 {
33732 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33733 }
33734 {
33735 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33736 }
33737 {
33738 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33739 }
33740 {
33741 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33742 }
33743 {
33744 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33745 }
33746 {
33747 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33748 }
33749 {
33750 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33751 }
33752 {
33753 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33754 }
33755 {
33756 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33757 }
33758 {
33759 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33760 }
33761 {
33762 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33763 }
33764 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33765 {
33766 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33767 }
33768 {
33769 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33770 }
33771 {
33772 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33773 }
33774 {
33775 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33776 }
33777 {
33778 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33779 }
33780
33781 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33782
33783 {
33784 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33785 }
33786 {
33787 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33788 }
33789 {
33790 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33791 }
33792 {
33793 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33794 }
33795 {
33796 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33797 }
33798 {
33799 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33800 }
33801 {
33802 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33803 }
33804 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33805 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33806 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33807 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33808 {
33809 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33810 }
33811 {
33812 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33813 }
33814 {
33815 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33816 }
33817 {
33818 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33819 }
33820 {
33821 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33822 }
33823 {
33824 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33825 }
33826 {
33827 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33828 }
33829 {
33830 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33831 }
33832 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33833 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33834 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33835 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33836 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33837 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33838 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33839 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33840 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33841 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33842 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33843 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33844 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33845 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33846 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33847 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33848 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33849 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33850 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33851 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33852 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33853 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33854 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33855 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33856 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33857 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33858 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33859 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33860 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33861 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33862 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33863 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33864 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33865 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33866 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33867 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33868 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33869 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33870 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33871 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33872 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33873 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33874 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33875 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33876 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33877 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33878 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33879 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33880 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33881 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33882 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33883 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33884 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33885 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33886 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33887 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33888
33889 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33890
33891 {
33892 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33893 }
33894 {
33895 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33896 }
33897 {
33898 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33899 }
33900 {
33901 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33902 }
33903 {
33904 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33905 }
33906 {
33907 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33908 }
33909 {
33910 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33911 }
33912 {
33913 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33914 }
33915 {
33916 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33917 }
33918 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33919 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33920 {
33921 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33922 }
33923 {
33924 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33925 }
33926 {
33927 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33928 }
33929 {
33930 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33931 }
33932 {
33933 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33934 }
33935 {
33936 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33937 }
33938 {
33939 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33940 }
33941 {
33942 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33943 }
33944 {
33945 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33946 }
33947 {
33948 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33949 }
33950 {
33951 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33952 }
33953 {
33954 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33955 }
33956 {
33957 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33958 }
33959 {
33960 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33961 }
33962 {
33963 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33964 }
33965 {
33966 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33967 }
33968 {
33969 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33970 }
33971 {
33972 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33973 }
33974 {
33975 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33976 }
33977 {
33978 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33979 }
33980 {
33981 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33982 }
33983 {
33984 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33985 }
33986 {
33987 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33988 }
33989 {
33990 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33991 }
33992 {
33993 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33994 }
33995 {
33996 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33997 }
33998 {
33999 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34000 }
34001 {
34002 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34003 }
34004 {
34005 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34006 }
34007 {
34008 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34009 }
34010 {
34011 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34012 }
34013 {
34014 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34015 }
34016 {
34017 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34018 }
34019 {
34020 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34021 }
34022 {
34023 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34024 }
34025 {
34026 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34027 }
34028 {
34029 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34030 }
34031 {
34032 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34033 }
34034 {
34035 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34036 }
34037 {
34038 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34039 }
34040 {
34041 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34042 }
34043 {
34044 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34045 }
34046 {
34047 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34048 }
34049 {
34050 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34051 }
34052 {
34053 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34054 }
34055 {
34056 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34057 }
34058 {
34059 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34060 }
34061 {
34062 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34063 }
34064 {
34065 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34066 }
34067 {
34068 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34069 }
34070 {
34071 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34072 }
34073 {
34074 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34075 }
34076 {
34077 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34078 }
34079 {
34080 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34081 }
34082 {
34083 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34084 }
34085 {
34086 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34087 }
34088 {
34089 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34090 }
34091 {
34092 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34093 }
34094 {
34095 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34096 }
34097 {
34098 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34099 }
34100 {
34101 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34102 }
34103 {
34104 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34105 }
34106 {
34107 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34108 }
34109 {
34110 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34111 }
34112 {
34113 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34114 }
34115 {
34116 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34117 }
34118 {
34119 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34120 }
34121 {
34122 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34123 }
34124 {
34125 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34126 }
34127 {
34128 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34129 }
34130 {
34131 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34132 }
34133 {
34134 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34135 }
34136 {
34137 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34138 }
34139 {
34140 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34141 }
34142 {
34143 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34144 }
34145 {
34146 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34147 }
34148 {
34149 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34150 }
34151 {
34152 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34153 }
34154 {
34155 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34156 }
34157 {
34158 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34159 }
34160 {
34161 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34162 }
34163 {
34164 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34165 }
34166 {
34167 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34168 }
34169 {
34170 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34171 }
34172 {
34173 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34174 }
34175 {
34176 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34177 }
34178 {
34179 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34180 }
34181 {
34182 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34183 }
34184 {
34185 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34186 }
34187 {
34188 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34189 }
34190 {
34191 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34192 }
34193 {
34194 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34195 }
34196 {
34197 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34198 }
34199 {
34200 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34201 }
34202 {
34203 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34204 }
34205 {
34206 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34207 }
34208 {
34209 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34210 }
34211 {
34212 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34213 }
34214 {
34215 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34216 }
34217 {
34218 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34219 }
34220 {
34221 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34222 }
34223 {
34224 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34225 }
34226 {
34227 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34228 }
34229 {
34230 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34231 }
34232 {
34233 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34234 }
34235 {
34236 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34237 }
34238 {
34239 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34240 }
34241 {
34242 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34243 }
34244 {
34245 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34246 }
34247 {
34248 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34249 }
34250 {
34251 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34252 }
34253 {
34254 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34255 }
34256 {
34257 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34258 }
34259 {
34260 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34261 }
34262 {
34263 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34264 }
34265 {
34266 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34267 }
34268 {
34269 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34270 }
34271 {
34272 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34273 }
34274 {
34275 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34276 }
34277 {
34278 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34279 }
34280 {
34281 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34282 }
34283 {
34284 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34285 }
34286 {
34287 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34288 }
34289 {
34290 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34291 }
34292 {
34293 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34294 }
34295 {
34296 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34297 }
34298 {
34299 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34300 }
34301 {
34302 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34303 }
34304 {
34305 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34306 }
34307 {
34308 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34309 }
34310 {
34311 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34312 }
34313 {
34314 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34315 }
34316 {
34317 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34318 }
34319 {
34320 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34321 }
34322 {
34323 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34324 }
34325 {
34326 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34327 }
34328 {
34329 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34330 }
34331 {
34332 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34333 }
34334 {
34335 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34336 }
34337 {
34338 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34339 }
34340 {
34341 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34342 }
34343 {
34344 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34345 }
34346 {
34347 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34348 }
34349 {
34350 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34351 }
34352 {
34353 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34354 }
34355 {
34356 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34357 }
34358 {
34359 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34360 }
34361 {
34362 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34363 }
34364 {
34365 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34366 }
34367 {
34368 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34369 }
34370 {
34371 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34372 }
34373 {
34374 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34375 }
34376 {
34377 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34378 }
34379 {
34380 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34381 }
34382 {
34383 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34384 }
34385 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34386 {
34387 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34388 }
34389 {
34390 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34391 }
34392 {
34393 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34394 }
34395 {
34396 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34397 }
34398 {
34399 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34400 }
34401 {
34402 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34403 }
34404 {
34405 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34406 }
34407 {
34408 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34409 }
34410 {
34411 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34412 }
34413 {
34414 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34415 }
34416 {
34417 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34418 }
34419 {
34420 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34421 }
34422 {
34423 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34424 }
34425 {
34426 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34427 }
34428 {
34429 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34430 }
34431 {
34432 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34433 }
34434 {
34435 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34436 }
34437 {
34438 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34439 }
34440 {
34441 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34442 }
34443 {
34444 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34445 }
34446 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34447 {
34448 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34449 }
34450 {
34451 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34452 }
34453 {
34454 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34455 }
34456 {
34457 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34458 }
34459 {
34460 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34461 }
34462 {
34463 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34464 }
34465 {
34466 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34467 }
34468 {
34469 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34470 }
34471 {
34472 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34473 }
34474 {
34475 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34476 }
34477 {
34478 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34479 }
34480 {
34481 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34482 }
34483
34484 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34485 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34486 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34487 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34488
34489 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34490 }
34491
wxWidgets (Impactor)